Java Examples In A Nutshell (3rd Edition) [Electronic resources] نسخه متنی

5.11 Sending Datagrams

Now that
we've thoroughly covered the possibilities of
networking with sockets and streams, let's examine
how low-level networking can be done using datagrams and packets.
Examples Example 5-12 show how you can implement simple network
communication using datagrams. Datagram communication is sometimes
called UDP, for Unreliable Datagram Protocol. Sending datagrams is
fast, but the trade-off is that they are not guaranteed to reach
their destination. In addition, multiple datagrams are not guaranteed
to travel to their destination by the same route or to arrive at
their destination in the order in which they were sent. Datagrams are
useful when you want low-overhead communication of noncritical data
and when a stream model of communication is not necessary. For
example, you might implement a multiuser chat server for a local area
network using datagrams.

To send and receive datagrams, you use the
DatagramPacket and
DatagramSocket classes. These objects are created
and initialized differently, depending on whether they send or
receive datagrams. Example 5-11 shows how to send a
datagram; Example 5-12 shows how to receive a
datagram and how to find who sent it.

To send a datagram, you first create a
DatagramPacket, specifying the data to be sent,
the length of the data, the host to send it to, and the port on that
host where it is to be sent. You then use the send(
) method of a DatagramSocket to send the
packet. The DatagramSocket is a generic one,
created with no arguments. It can be reused to send any packet to any
address and port.

Example 5-11. UDPSend.java

package je3.net;
import java.io.*;
import java.net.*;
/**
* This class sends the specified text or file as a datagram to the 
* specified port of the specified host.
**/
public class UDPSend {
public static final String usage = 
"Usage: java UDPSend <hostname> <port> <msg>...\n" +
"   or: java UDPSend <hostname> <port> -f <file>";
public static void main(String args[  ]) {
try { 
// Check the number of arguments
if (args.length < 3) 
throw new IllegalArgumentException("Wrong number of args");
// Parse the arguments
String host = args[0];
int port = Integer.parseInt(args[1]);
// Figure out the message to send.  
// If the third argument is -f, then send the contents of the file
// specified as the fourth argument.  Otherwise, concatenate the 
// third and all remaining arguments and send that.
byte[  ] message;
if (args[2].equals("-f")) {
File f = new File(args[3]);
int len = (int)f.length( );    // figure out how big the file is
message = new byte[len];      // create a buffer big enough
FileInputStream in = new FileInputStream(f);
int bytes_read = 0, n;
do {                          // loop until we've read it all
n = in.read(message, bytes_read, len-bytes_read);
bytes_read += n;
} while((bytes_read < len)&& (n != -1));
}
else { // Otherwise, just combine all the remaining arguments.
String msg = args[2];  
for (int i = 3; i < args.length; i++) msg += " " + args[i];
// Convert the message to bytes using UTF-8 encoding
message = msg.getBytes("UTF-8");
}
// Get the internet address of the specified host
InetAddress address = InetAddress.getByName(host);
// Initialize a datagram packet with data and address
DatagramPacket packet = new DatagramPacket(message, message.length,
address, port);
// Create a datagram socket, send the packet through it, close it.
DatagramSocket dsocket = new DatagramSocket( );
dsocket.send(packet);
dsocket.close( );
}
catch (Exception e) {
System.err.println(e);
System.err.println(usage);
}
}
}