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.