Some applications that you write to communicate over the network will not require the reliable, point-to-point channel provided by TCP. Rather, your applications might benefit from a mode of communication that delivers independent packages of information whose arrival and order of arrival are not guaranteed.
The UDP protocol provides a mode of network communication
whereby applications send packets of data, called datagrams, to one another. A
datagram is an independent, self-contained message sent over the network whose
arrival, arrival time, and content are not guaranteed. The DatagramPacket
and DatagramSocket
classes in the java.net
package implement system-independent datagram communication using UDP.
Clients and servers that communicate via a reliable channel, such as a URL or a socket, have a dedicated point-to-point channel between themselves, or at least the illusion of one. To communicate, they establish a connection, transmit the data, and then close the connection. All data sent over the channel is received in the same order in which it was sent. This is guaranteed by the channel.
In contrast, applications that communicate via datagrams send and receive completely independent packets of information. These clients and servers do not have and do not need a dedicated point-to-point channel. The delivery of datagrams to their destinations is not guaranteed. Nor is the order of their arrival.
Definition: A datagram is an independent, self-contained message sent over the network whose arrival, arrival time, and content are not guaranteed.
The java.net
package contains two classes to help you write Java programs that use datagrams
to send and receive packets over the network: DatagramSocket, DatagramPacket, and MulticastSocket. An application can send and
receive DatagramPackets
through a DatagramSocket.
In addition, DatagramPackets
can be broadcast to multiple recipients all listening to a MulticastSocket.
The example featured in this section consists of two applications: a client and a server. The server continuously receives datagram packets over a datagram socket. Each datagram packet received by the server indicates a client request for a quotation. When the server receives a datagram, it replies by sending a datagram packet that contains a one-line "quote of the moment" back to the client.
The client application in this example is fairly simple. It sends a single datagram packet to the server indicating that the client would like to receive a quote of the moment. The client then waits for the server to send a datagram packet in response.
Two classes implement the server application: QuoteServer
and QuoteServerThread.
A single class implements the client application: QuoteClient.
Let's investigate these classes, starting with class that
contains the main
method for the server application.
The QuoteServer class, shown here in its entirety,
contains a single method: the main method for the quote server application. The main method
simply creates a new QuoteServerThread
object and starts it:
import java.io.*;
public class
QuoteServer {
public static
void main(String[] args) throws IOException {
new
QuoteServerThread().start();
}
}
QuoteServerThread
ClassThe QuoteServerThread
class implements the main logic of the quote server:
import
java.io.*;
import
java.net.*;
import
java.util.*;
public
class QuoteServerThread extends Thread {
protected
DatagramSocket socket = null;
protected
BufferedReader in = null;
protected
boolean moreQuotes = true;
public
QuoteServerThread() throws IOException {
this("QuoteServerThread");
}
public
QuoteServerThread(String name) throws IOException {
super(name);
socket = new
DatagramSocket(4445);
try {
in
= new BufferedReader(new
FileReader("one-liners.txt"));
} catch
(FileNotFoundException e) {
System.err.println("Could not open quote file. Serving time
instead.");
}
}
public void run() {
while
(moreQuotes) {
try
{
byte[]
buf = new byte[256];
//
receive request
DatagramPacket packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
//
figure out response
String dString = null;
if
(in == null)
dString = new Date().toString();
else
dString = getNextQuote();
buf = dString.getBytes();
// send the
response to the client at "address" and "port"
InetAddress address =
packet.getAddress();
int
port = packet.getPort();
packet = new DatagramPacket(buf, buf.length, address, port);
socket.send(packet);
} catch
(IOException e) {
e.printStackTrace();
moreQuotes
= false;
}
}
socket.close();
}
protected String
getNextQuote() {
String returnValue = null;
try {
if
((returnValue = in.readLine()) == null) {
in.close();
moreQuotes
= false;
returnValue = "No more quotes. Goodbye.";
}
} catch (IOException e) {
returnValue = "IOException occurred in server.";
}
return
returnValue;
}
}
When created, the QuoteServerThread creates a DatagramSocket
on port 4445 (arbitrarily chosen). This is the DatagramSocket through which
the server communicates with all of its clients.
public
QuoteServerThread() throws IOException {
this("QuoteServer");
}
public
QuoteServerThread(String name) throws IOException {
super(name);
socket = new
DatagramSocket(4445);
try {
in = new BufferedReader(
new
FileReader("one-liners.txt"));
} catch
(FileNotFoundException e)
System.err.println("Couldn't open quote file. " +
"Serving time instead.");
}
}
Remember that certain ports are dedicated to well-known
services and you cannot use them. If you specify a port that is in use, the
creation of the DatagramSocket
will fail.
The constructor also opens a BufferedReader on a file named one-liners.txt:
Artificial Intelligence usually beats real stupidity.
Life is wonderful. Without it we'd all be dead.
Too many clicks spoil the browse.
Good programming is 99% sweat and 1% coffee.
"Daddy, what does FORMATTING DRIVE C mean?"
Error, no keyboard - press F1 to continue.
which contains a list of quotes. Each quote in the file is on a line by itself :
Now for the interesting part of the QuoteServerThread:
its run
method. The run
method overrides run
in the Thread
class and provides the implementation for the thread.
The run
method contains a while
loop that continues as long as there are more quotes in the file. During each
iteration of the loop, the thread waits for a DatagramPacket to arrive over
the DatagramSocket.
The packet indicates a request from a client. In response to the client's
request, the QuoteServerThread
gets a quote from the file, puts it in a DatagramPacket and sends it over the DatagramSocket
to the client that asked for it.
Let's look first at the section that receives the requests from clients:
byte[]
buf = new byte[256];
DatagramPacket
packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
The first statement creates an array of bytes which is
then used to create a DatagramPacket.
The DatagramPacket
will be used to receive a datagram from the socket because of the constructor
used to create it. This constructor requires only two arguments: a byte array
that contains client-specific data and the length of the byte array. When
constructing a DatagramPacket
to send over the DatagramSocket,
you also must supply the Internet address and port number of the packet's
destination. You'll see this later when we discuss how the server responds to a
client request.
The last statement in the previous code snippet receives a datagram from the socket (the information received from the client gets copied into the packet). The receive method waits forever until a packet is received. If no packet is received, the server makes no further progress and just waits.
Now assume that, the server has received a request from a client for a quote. Now the server must respond. This section of code in the run method constructs the response:
String
dString = null;
if
(in == null)
dString = new
Date().toString();
else
dString = getNextQuote();
buf
= dString.getBytes();
If the quote file did not get opened for some reason, then in equals null. If this is the case, the quote server serves up the time of day instead. Otherwise, the quote server gets the next quote from the already opened file. Finally, the code converts the string to an array of bytes.
Now, the run method sends the response to the client over
the DatagramSocket
with this code:
InetAddress
address = packet.getAddress();
int
port = packet.getPort();
packet
= new DatagramPacket(buf, buf.length, address,
port);
socket.send(packet);
The first two statements in this code segment get the Internet address and the port number, respectively, from the datagram packet received from the client. The Internet address and port number indicate where the datagram packet came from. This is where the server must send its response. In this example, the byte array of the datagram packet contains no relevant information. The arrival of the packet itself indicates a request from a client that can be found at the Internet address and port number indicated in the datagram packet.
The third statement creates a new DatagramPacket
object intended for sending a datagram message over the datagram socket. You
can tell that the new DatagramPacket
is intended to send data over the socket because of the constructor used to
create it. This constructor requires four arguments. The first two arguments
are the same required by the constructor used to create receiving datagrams: a
byte array containing the message from the sender to the receiver and the
length of this array. The next two arguments are different: an Internet address
and a port number. These two arguments are the complete address of the
destination of the datagram packet and must be supplied by the sender of the
datagram. The last line of code sends the DatagramPacket on its way.
When the server has read all the quotes from the quote
file, the while
loop terminates and the run
method cleans up:
socket.close();
The QuoteClient class implements a client
application for the QuoteServer.
This application sends a request to the QuoteServer, waits for the response,
and, when the response is received, displays it to the standard output. Let's
look at the code in detail:
import
java.io.*;
import
java.net.*;
import
java.util.*;
public
class QuoteClient {
public static void
main(String[] args) throws IOException {
if
(args.length != 1) {
System.out.println("Usage: java QuoteClient <hostname>");
return;
}
// get a
datagram socket
DatagramSocket socket = new DatagramSocket();
// send
request
byte[]
buf = new byte[256];
InetAddress address =
InetAddress.getByName(args[0]);
DatagramPacket packet = new DatagramPacket(buf, buf.length, address, 4445);
socket.send(packet);
// get
response
packet = new
DatagramPacket(buf, buf.length);
socket.receive(packet);
// display
response
String received = new String(packet.getData());
System.out.println("Quote of the Moment: " + received);
socket.close();
}
}
The QuoteClient
class contains one method, the main method for the client application. The top of
the main
method declares several local variables for its use:
int
port;
InetAddress
address;
DatagramSocket
socket = null;
DatagramPacket
packet;
byte[]
sendBuf = new byte[256];
First, the main method processes the command-line arguments
used to invoke the QuoteClient
application:
if
(args.length != 1) {
System.out.println("Usage: java QuoteClient <hostname>");
return;
}
The QuoteClient
application requires one command-line arguments: the name of the machine on
which the QuoteServer
is running.
Next, the main method creates a DatagramSocket:
DatagramSocket socket = new
DatagramSocket();
The client uses a constructor that does not require a port
number. This constructor just binds the DatagramSocket to any available local
port. It doesn't matter what port the client is connected to because the DatagramPackets
contain the addressing information. The server gets the port number from the DatagramPackets
and send its response to that port.
Next, the QuoteClient program sends a request to the server:
byte[]
buf = new byte[256];
InetAddress
address = InetAddress.getByName(args[0]);
DatagramPacket
packet = new DatagramPacket(buf, buf.length,
address,
4445);
socket.send(packet);
The code segment gets the Internet address for the host
named on the command line (presumably the name of the machine on which the
server is running). This InetAddress
and the port number 4445 (the port number that the server used to create its DatagramSocket)
are then used to create DatagramPacket
destined for that Internet address and port number. Therefore the DatagramPacket
will be delivered to the quote server.
Note that the code creates a DatagramPacket with an empty
byte array. The byte array is empty because this datagram packet is simply a
request to the server for information. All the server needs to know to send a
response--the address and port number to which reply--is automatically part of
the packet.
Next, the client gets a response from the server and displays it:
packet
= new DatagramPacket(buf, buf.length);
socket.receive(packet);
String
received = new String(packet.getData());
System.out.println("Quote of
the Moment: " + received);
To get a response from the server, the client creates a
"receive" packet and uses the DatagramSocket receive method to
receive the reply from the server. The receive method waits until a datagram
packet destined for the client comes through the socket. Note that if the
server's reply is somehow lost, the client will wait forever because of the
no-guarantee policy of the datagram model. Normally, a client sets a timer so
that it doesn't wait forever for a reply; if no reply arrives, the timer goes
off and the client retransmits.
When the client receives a reply from the server, the client uses the getData method to retrieve that data from the packet. The client then converts the data to a string and displays it.
After you've successfully compiled the server and the
client programs, you run them. You have to run the server program first. Just
use the Java interpreter and specify the QuoteServer class name.
Once the server has started, you can run the client program.
Remember to run the client program with one command-line argument: the name of
the host on which the QuoteServer
is running.
After the client sends a request and receives a response from the server, you should see output similar to this:
Quote of the Moment:
Good programming is 99% sweat and 1% coffee.
In addition to DatagramSocket, which lets programs
send packets to one another, java.net includes a class called MulticastSocket.
This kind of socket is used on the client-side to listen for packets that the
server broadcasts to multiple clients.
Let's rewrite the quote server so that it broadcasts DatagramPackets
to multiple recipients. Instead of sending quotes to a specific client that
makes a request, the new server now needs to broadcast quotes at a regular
interval. The client needs to be modified so that it passively listens for
quotes and does so on a MulticastSocket.
This example is comprised of three classes which are
modifications of the three classes from the previous example: MulticastServer, MulticastServerThread, and MulticastClient. This discussion highlights
the interesting parts of these classes.
Here is the new version of the server's main program. The
differences between this code and the previous version, QuoteServer,
are shown in bold:
import java.io.*;
public class MulticastServer {public static void main(String[] args) throws IOException {
new MulticastServerThread().start();
}
}
Basically, the server got a new name and creates a MulticastServerThread
instead of a QuoteServerThread.
Now let's look at the MulticastServerThread
which contains the heart of the server:
import
java.io.*;
import
java.net.*;
import
java.util.*;
public
class MulticastServerThread extends
QuoteServerThread {
private long FIVE_SECONDS = 5000;
public
MulticastServerThread() throws IOException {
super("MulticastServerThread");
}
public void run() {
while
(moreQuotes) {
try
{
byte[]
buf = new byte[256];
// construct quote
String dString = null;
if
(in == null)
dString = new Date().toString();
else
dString = getNextQuote();
buf = dString.getBytes();
// send it
InetAddress group =
InetAddress.getByName("230.0.0.1");
DatagramPacket packet = new DatagramPacket(buf, buf.length,
group, 4446);
socket.send(packet);
// sleep for a while
try
{
sleep((long)(Math.random() * FIVE_SECONDS));
} catch
(InterruptedException e) { }
} catch
(IOException e) {
e.printStackTrace();
moreQuotes = false;
}
}
socket.close();
}
}
Here's its class declaration:
public class
MulticastServerThread extends QuoteServerThread
{
...
}
We've made this class a subclass of QuoteServerThread
so that it can use the constructor, and inherit some member variable and the getNextQuote
method. Recall that QuoteServerThread
creates a DatagramSocket
bound to port 4445 and opens the quote file. The DatagramSocket's port number
doesn't actually matter in this example because the client never send anything
to the server.
The only method explicitly implemented in MulticastServerThread
is its run
method. The differences between this run method and the one in QuoteServerThread
are shown in bold:
public void run() {while (moreQuotes) {
try {
byte[] buf new byte[256];
// don't wait for request...just send a quote
String dString = null;
if (in == null)
dString = new Date().toString();
else
dString = getNextQuote();
buf = dString.getBytes();
InetAddress group = InetAddress.getByName(
"230.0.0.1");
DatagramPacket packet;
packet = new DatagramPacket(buf, buf.length,
group, 4446);
socket.send(packet);
try {
sleep((long)Math.random() * FIVE_SECONDS);
} catch (InterruptedException e) { }
} catch (IOException e) {
e.printStackTrace();
moreQuotes = false;
}
}
socket.close();
}
The interesting change is how the DatagramPacket
is constructed, in particular, the InetAddress and port used to construct
the DatagramPacket.
Recall that the previous example retrieved the InetAddress and port number
from the packet sent to the server from the client. This was because the server
needed to reply directly to the client. Now, the server needs to address
multiple clients. So this time both the InetAddress and the port number are
hard-coded.
The hard-coded port number is 4446 (the client must have a
MulticastSocket
bound to this port). The hard-coded InetAddress of the DatagramPacket
is "230.0.0.1" and is a group identifier (rather than the Internet
address of the machine on which a single client is running). This particular
address was arbitrarily chosen from the reserved for this purpose.
Created in this way, the DatagramPacket is destined for
all clients listening to port number 4446 who are member of the
"230.0.0.1" group.
To listen to port number 4446, the new client program just
created its MulticastSocket
with that port number. To become a member of the "230.0.0.1" group,
the client calls the MulticastSocket's
joinGroup
method with the InetAddress
that identifies the group. Now, the client is set up to receive DatagramPackets
destined for the port and group specified. Here's the relevant code from the
new client program (which was also rewritten to passively receive quotes rather
than actively request them). The bold statements are the ones that interact
with the MulticastSocket:
MulticastSocket socket = new MulticastSocket(4446);
InetAddress group = InetAddress.getByName("230.0.0.1");socket.joinGroup(group);
DatagramPacket packet;
for (int i = 0; i < 5; i++) {byte[] buf = new byte[256];
packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
String received = new String(packet.getData());
System.out.println("Quote of the Moment: " + received);
}
socket.leaveGroup(group);
socket.close();
Notice that the server uses a DatagramSocket
to broadcast packet received by the client over a MulticastSocket. Alternatively,
it could have used a MulticastSocket.
The socket used by the server to send the DatagramPacket is not important.
What's important when broadcasting packets is the addressing information
contained in the DatagramPacket,
and the socket used by the client to listen for it
Try this: Run the MulticastServer
and several clients. Watch how the clients all get the same quotes.