Top Most UDP Client Server Networking Program

First write a server program as follows and run on command prompt as below:
java UDPReceive 80


Java Program as below:



package com.myapp.udp;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * This program waits to receive datagrams sent to the specified port. When it
 * receives one, it displays the sending host and prints the contents of the
 * datagram as a string. Then it loops and waits again.
 **/

public class UDPReceive {
public static final String usage = "Usage: java UDPReceive <port>";

public static void main(String args[]) {
try {
if (args.length != 1)
throw new IllegalArgumentException("Wrong number of args");

// Get the port from the command line
int port = Integer.parseInt(args[0]);

// Create a socket to listen on the port.
DatagramSocket dsocket = new DatagramSocket(port);

// Create a buffer to read datagrams into. If anyone sends us a
// packet containing more than will fit into this buffer, the
// excess will simply be discarded!
byte[] buffer = new byte[2048];

// Create a packet to receive data into the buffer
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

// Now loop forever, waiting to receive packets and printing them.
for (;;) {
// Wait to receive a datagram
dsocket.receive(packet);

// Decode the bytes of the packet to characters, using the
// UTF-8 encoding, and then display those characters.
String msg = new String(buffer, 0, packet.getLength(), "UTF-8");
System.out.println(packet.getAddress().getHostName() + ": "
+ msg);

// Reset the length of the packet before reusing it.
// Prior to Java 1.1, we'd just create a new packet each time.
packet.setLength(buffer.length);
}
} catch (Exception e) {
System.err.println(e);
System.err.println(usage);
}
}

}

Now Write a Client as below Program

package com.myapp.udp;

import java.io.File;

import java.io.FileInputStream;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

/*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

 * 

 * */

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);

}

}

}

Now run your client on command prompt as below 

java UDPSend localhost 80 "hello world"