Java DatagramSocket and Java DatagramPacket

Datagrams

TCP/IP style networking specifies a serialized, predictable, and reliable stream of data in the form of a packet. Servers and clients communicate through a reliable channel, such as TCP socket, have a dedicated point-to-point channel between themselves. They make a connection, transmit the data, and then close the connection. All of the data visit over the channel and are received in the same order in which it is sent.

Datagrams are groups(bundles) of information passed from one device to another over the network. When the datagram has been released for its intended target, there is no assurance that it will arrive or even that someone will be there to catch the datagram packets. Likewise, when the datagram is received, there is no assurance that it has not been damaged in the transit or that whosoever sent it, is still there to receive a response.

The applications that communicate through datagrams send and receive completely independent packets of information. These applications of the clients and servers do not have a dedicated point-to-point channel. The order of the datagrams and their delivery to their destinations is not guaranteed.

A datagram is self-contained, and an independent message is sent over a network whose arrival time, and content is not guaranteed.

Java implements datagrams on top of the UDP protocol by using two classes: the

DatagramPacket object is the data container, while the DatagramSocket is the mechanism used to send or receive the DatagramPackets. Java provides the DatagramSocket class and DatagramPacket class for implementing UDP connections. DatagramSocket objects are used to create sockets through which UDP traffic can be passed as DatagramPacket objects. When using DatagramSockets, the server waits for the client to make a request. Once the client makes this request, the server sends its UDP traffic via Datagram packets to the client.

DatagramSocket class

This class represents a socket for sending and receiving a datagram packet. A datagram socket provides sending or receiving ends for a connectionless packet. Each packet is sent or received on the socket. Many packets are sent from one machine to another and maybe routed differently in any order. DatagramSocket defines many methods.

Creation of the DatagramSocket class

Syntax:

DatagramSocket ds =DatagramSocket();

Commonly used the constructor of DatagramSocket class

Method of DatagramSocket class

DatagramPacket class

This class represents a datagram packet. The DatagramPacket class provides a connectionless packet delivery service. Each message routes from one machine to another based on the information contained within that packet. Numerous packets are sent from one host to another that may route differently and may arrive in random order.

Creation the object of the DatagramPacket class

Syntax:

DatagramPacket dp=DatagramPacket(byte[] b, int length)

Commonly used constructor

Methods of DatagramPacket class.

Note: ServerSocket and Socket class use TCP protocol(Connection-oriented).

DatagramSocket and DatagramPacket use UDP (Connectionless Protocol).

Example1: Sending the UDP packets to the server.

Client side:

import java.io.*;
import java.net.*;
class UdpClient
{
public static void main(String s1[])throws Exception
{
DatagramSocket ds=new DatagramSocket();
String s="india is a good country";
byte b[]=s.getBytes();
InetAddress i=InetAddress.getLocalHost();
DatagramPacket dp=new DatagramPacket(b,b.length,i,8);
ds.send(dp);
}
} 

The output of the program:

Receiver side: Receiving the UDP packets from the clients.

import java.net.*;
import java.io.*;
class UdpServer
{
public static void main(String s2[])throws Exception{
DatagramSocket ds=new DatagramSocket(8);
byte b[]=new byte[1024];
DatagramPacket dp=new DatagramPacket(b,b.length);
ds.receive(dp);
String r=new String(dp.getData());
System.out.println(r.trim());
}
} 

The Output:

Example 2: The following example implements a very simple networked communication between the client and server. Messages are typed at the server-side that is written to the client-side, where they are displayed.

import java.net.*;
class UDPDemo
{
public static int  serverPort=922;
public static int clientPort=988;
public static int buffer_size=2000;
public static DatagramSocket ds;
public static byte buffer[]=new byte[buffer_size];
public static void TheServer() throws Exception {
int pos=0;
while(true)
{
int c=System.in.read();
switch(c)
{
case -1:
System.out.println("Server Quits.");
return;
case '\r':
break;
case '\n':
ds.send(new DatagramPacket(buffer,pos,InetAddress.getLocalHost(),clientPort));
pos=0;
break;
default:
buffer[pos++]=(byte)c;
}
}
}
public static void TheClient()throws Exception
{
while(true)
{
DatagramPacket p=new DatagramPacket(buffer, buffer.length);
ds.receive(p);
System.out.println(new String(p.getData(), 0, p.getLength()));
}
}
public static void main(String s8[])throws Exception
{
if(s8.length==1)
{
ds=new DatagramSocket(serverPort);
TheServer();
}
else
{
ds=new DatagramSocket(clientPort);
TheClient();
}
}
} 

Anything that is typed in the server window will be sent to the client window after a newline is received.

The output of the Server side:

The output of the Client side:

Example 3: Sending the UDP packets to the server.

Sender class:

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class Sender
{
public static void main(String s1[])throws Exception
{
DatagramSocket ds=new DatagramSocket();
String str="shifa is good";
InetAddress ip=InetAddress.getByName("localhost");
byte[] b=str.getBytes();
DatagramPacket dp=new DatagramPacket(b,b.length,ip,2000);
ds.send(dp);
ds.close();
}
} 

The output of the above program:

Receiver class: Receiving the UDP packets from the clients.

import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class Receiver
{
public static void main(String s[])throws Exception
{
DatagramSocket ds=new DatagramSocket(2000);
byte[] b1=new byte[1024];
DatagramPacket dp=new DatagramPacket(b1,b1.length);
ds.receive(dp);
String str1=new String(dp.getData());
System.out.println(str1);
ds.close();
}
} 

The output of the program: