Seven
In /**
Week previous tutorials, we have examined I/O streams, which are useful in dealing with files and connection-oriented services. Another form of communication uses packets of information. Datagram packets, for example, allow us to send data in small chunks, and have this data sent over the Internet. In this tutorial, we will look at a simple sender/receiver example, without any error-detection or retransmission. We will also look at the ByteArrayInputStream and ByteArrayOutputStream classes, which make it easy to convert from a data type (say a String), into an array of bytes.
Java has support for datagrams, and allows us to send data over networks using UDP (User Datagram Protocol with the Internet at transport layer). We can represent packets by using the DatagramPacket class, and we can send/receive packets by using the DatagramSocket class. Both of these classes can be found in the java.net package.
Part A
Using the online documentation of Borland JBuilder, familiarize yourself with the DatagramPacket and DatagramSocket class. Look in particular at the constructors for datagram packets and datagram sockets . We must store our packet data as a byte array, and we may specify a port number for socket communcation.
Part B
Conversion of data to bytes can be a difficult task in any language. Java, however, makes it easy with the ByteArrayOutputStream and ByteArrayInputStream classes. Just like any other input or output stream, we have read and write methods. We'll be using the ByteArrayOutputStream, and ByteArrayInputStream classes in our datagram example, so it is important to understand how they work before attempting Part C & D.
Examine the following application, which reads a line of text, and coverts the line into a sequence of bytes using ByteArrayOutputStream. Once we have an array of bytes, the program displays the numerical value of each byte. We will use a ByteArrayOutputStream in the next example, to covert text to bytes for transmission over a network.
**/
import java.io.*;
//
//
// ByteArrayDemo
//
// Demonstrates conversion of text to a byte array, using the
// ByteArrayOutputStream class
//
//
public class ByteArrayDemo
{
public static void main (String args[]) throws IOException
{
try {
System.out.println ("Enter a line of text to be coverted to bytes :");
// Read a line of text from the user
DataInputStream din = new DataInputStream (System.in);
String line = din.readLine();
// Create a byte array output stream to create our byte array
ByteArrayOutputStream bout = new ByteArrayOutputStream ();
// Write each char out
for (int i= 0; i < line.length(); i++)
bout.write ( line.charAt(i) );
// Get our byte array
byte[] barray = bout.toByteArray();
// Now display the byte value of each element of our
// array, except the last
for (int j= 0; j < barray.length-1; j++)
System.out.print (barray[j] + ", ");
// Display last element with a . rather than a ,
System.out.println (barray[barray.length-1] + ".");
// Pause for user
System.in.read();
}
catch (Exception e)
{
System.out.println ("I/O error " + e);
System.in.read();
}
}
}
/**
BPart C
Type out the following example, and look in particular at how we place a string into a packet, send a packet to a remote host, and pause the application. Run this example, and it will attempt to send data to a receiver which listens to port 2000 of the local machine.
Note : You will need to leave this program running when you run the receiver example Part in D
import java.net.*;
import java.io.*;
//
//
// PacketSender
//
// Sends UDP datagrams to port 2000 of the local machine
//
//
public class PacketSender
{
public static void main(String args[]) throws IOException
{
// Try .. catch any errors thrown
try
{
// Socket allows us to send/receive data
DatagramSocket senderSocket = new DatagramSocket();
// Datagram packet allows us to store data for sending
DatagramPacket packet;
// Get the local address for sending packets
InetAddress localAddr = InetAddress.getLocalHost();
// Sequence number for packets
int sequence_number = 1;
// Repeat indefinitely
for (;;)
{
// Create a string message, to send in our datagram
String message = "I am packet number " + sequence_number;
// Display sequence number
System.out.println ("Sequence number " + sequence_number);
// Increment sequence_number using ++ operator
sequence_number++;
// Convert our message to a byte array, using
// ByteArrayOutputStream
ByteArrayOutputStream bout = new ByteArrayOutputStream();
// For every character in message, write it to our byte array
// output stream
for (int index = 0; index < message.length(); index++)
{
// Get a character
char tmpChar = message.charAt(index);
// Write it to our byte array
bout.write ( tmpChar );
}
// Get our byte array
byte[] array = bout.toByteArray();
// Now, create a packet that will be send to receiver on port 2000
packet = new DatagramPacket (array, array.length, localAddr,
2000);
// Write packet to receiver using UDP
senderSocket.send (packet);
// Sleep for one second second, pausing to prevent
// flooding receiver
Thread.sleep (1000);
}
}
catch (Exception e)
{
System.err.println ("Error : " + e);
System.in.read();
}
}
}
Part D
Type out the following example, which listens for UDP packets on port 2000. Run the application from Part C, and then the following application, and you'll see data from one application being sent over the network to the other appplication.
Note: You will need to make Part C running simultaneously when you run this example.
import java.net.*;
import...