Java Networking UDP

1
Java Networking UDP Yangjun Chen Dept. Business
Computing University of Winnipeg
2
User Datagram Protocol

• UDP (User Datagrarn Protocol)
• - a protocol that sends independent packets of
  data, called datagrams,
• from one computer to another with no guarantees
  about arrival
• - not connection based like TCP
• If a UDP packet is lost, ITS LOST.
• The packets appear in the order they are received
  not necessarily in the order they were sent.

3
So Why UDP?

• Speed!
• UDP can be up to three times faster than TCP.
• There are applications where speed is more
  important than reliability, such as audio and
  video data.

4
UDP

• Java classes using UDP
• - java. net
• DatagramPacket()
• DatagramSocket()

5
UDP Classes

• Java has two classes for UDP support
• java.net.DatagramSocket
• java.net.DatagramPacket
• A DatagramSocket is used to send and receive
  DatagramPacket.
• Since UDP is connectionless, streams are not
  used.
• The maximum size of a Datagrarm packet is
• limited to slightly less than 64Kbytes.

6
UDP Classes

• DatagramSockets are connected to a port that
  allow for sending and receiving of data.
• Unlike TCP sockets, there is no distinction
  between client and server sockets in UDP.
• Also, a DatagramSocket can be used to send data
  to multiple different hosts.
• - This is because the address is stored in the
  packet, not in
• the socket.
• There are 65,536 UDP ports as well as TCP ports
  that are separate from each other.

7
DatagramPacket Class

• You construct a DatagrarmPacket by using one of
  the two constructors.
• - public DatagramPacket(byte data, int
  length)
• - public DatagramPacket(byte data, int
  length,
• InetAddress addr, int port)
• The byte array is passed by reference and not by
  value. A change in its contents will change the
  packet.

8
DatagramPacket Class

• Example of using the constructors
• String data "My UDP Packet
• byte h data.getBytes()
• DatagramPacket dp new DatagramPacket(b,
  b.length)
• You can also pass in the host and port to which
  the packet is to be sent.

9
DatagramPacket Class
try InetAddress tr new InetAddress("
www.win.trlabs.ca) int port 9100
String data "Another UDP Packet" byte
b data.getBytes( ) DatagramPacket dp new
DatagramPacket(b, b.length, tr,port)
//try catch (UnknownHostException e)
System.err.printin(e) //catch
10
DatagramPacket Class

• After creation of a DatagramPacket, it is
  possible to change the date, the length of the
  data, the port, or the address by using the
  following methods
• setAddress(InetAddress addr)
• setPort(int port)
• setData(byte buf)
• setLength(int length)
• To retrieve the current status of a
  DatagramPacket, use the corresponding get methods.

11
DatagramSocket Class

• This class is a connection to a port that does
  the transmitting and receiving.
• Unlike TCP sockets, the same Datagramsocket can
  be used to send and receive.
• The Datagramsocket class has three constructors.

12
DatagramSocket Class

• public DatagramSocket()
• public DatagramSocket(int port)
• public Datagramsocket(int port, InetAddress addr)
• all three constructors throw an IOException.
• The first constructor is mainly used to act as
  clients.
• The other two that specify a port and optionally
  an IP address are intended for servers that must
  run on a well known port.

13
Sending UDP Datagrams

• 1) Convert the data into a byte array.
• 2) Pass this byte array, length of data, port and
  address to the DatagramPacket constructor.
• 3) Create a DatagramSocket object.
• 4) Pass the Datagram packet to the send method.

14
Sending UDP Datagrams
try TnetAddress trnew InetAddress("win.tr
1abs.ca) int pt9100 string data
"Sending a Datagram" byte b
data.getBytes() DatagramPacket
dPnew DatagramPacket(b,b.length,tr,pt)
//try catch (UnknownHostException e)
system.err.println(e) //catch
15
Sending UDP Datagrams
try DatagramSocket sender new
Datagramsocket() sender.send(dP) //try
catch (IOException e) system.out.printIn(e)
//catch
16
Receiving UDP Datagrams

• 1) Construct a DatagramSocket object on the port
  you wish to listen.
• 2) Pass it an empty Datagrampacket object to the
  Datagramsockets receive() method.
• 3) Use methods
• getport ( ),
• getAddress( ),
• getData ( ),
• getLength( )
• to retrieve information about the data.

17
Receiving UDP Datagrams
try byte bufnew byte655361 DatagramPacke
t dp new DatagramPacket(buf,
buf.length) DatagramSocket dsnewDatagramSocket
(9100) ds.receive(dp) byte
datadp.getData() String snew String(data, 0,
data.getLength()) System.out.println(s)
//try catch (IOException e)
System.err.println(e) //catch
18
UDP Echo Example

• As with the TCP echo port, the UDP echo port is
  port 7.
• When this port receives a datagram, it copies the
  data and sends it back to the user.
• As with the TCP echo example, the UDP echo
  example will read in data from System.in, send it
  to the echo server on port 7 and then display the
  results.
• Remember that since UDP is connectionless, a
  packet might be lost somewhere between the client
  and the server.

19
UDP Echo Example
import java.io. import java.net. publi
c class UDPEcho extends Thread static int
port7 static volatile boolean
runningfalse DatagramSocket ds public
static void main(String args)
InputstreamReader isrnew InputStreamR
eader(System.in) BufferedReader in
new BufferedReader(isr) String line
20
UDP Echo Example
runningtrue try while
((linein.readLine()) ! null) byte data
line.getBytes() DatagramPacket dP new
DatagramPacket (data, data.length, server,
port) ds.send(dp) Thread.yield()
//while //try
21
UDP Echo Example
catch(IoException e) system.err.println(e)
//catch running false //main public
UDPEcho(DatagramSocket ds) this.dsds
//UDPEcho constructor
22
UDP Echo Example
public void run() byte buf new
byte1024 String line DatagramPacket
incoming new DatagramPacket (buf, buf.length)
while(running) try ds.receive(incoming
) byte data incoming.getData() line
new String(data,0,incoming.getLength())
23
UDP Echo Example
System.out.println("Echo ", line)
//try catch(IOException e) system.err.pr
intln(e) //catch //while //run //UD
PEcho class