Transcript No Slide Title - The University of Winnipeg

Java Networking UDP
Yangjun Chen
Dept. Business Computing
University of Winnipeg
Jan. 2004
1
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, IT’S LOST.
• The packets appear in the order they are received not
necessarily in the order they were sent.
Jan. 2004
2
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.
Jan. 2004
3
UDP
• Java classes using UDP
-
java. net
DatagramPacket()
DatagramSocket()
Jan. 2004
4
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.
Jan. 2004
5
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.
Jan. 2004
6
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.
Jan. 2004
7
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.
Jan. 2004
8
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
Jan. 2004
9
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.
Jan. 2004
10
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.
Jan. 2004
11
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.
Jan. 2004
12
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.
Jan. 2004
13
Sending UDP Datagrams
try {
TnetAddress tr=new
InetAddress("win.tr1abs.ca”);
int pt=9100;
string data = "Sending a Datagram";
byte[] b = data.getBytes();
DatagramPacket dP=new
DatagramPacket(b,b.length,tr,pt);
}//try catch (UnknownHostException e) {
system.err.println(e);
}//catch
Jan. 2004
14
Sending UDP Datagrams
try {
DatagramSocket sender = new Datagramsocket();
sender.send(dP);
}//try
catch (IOException e) {
system.out.printIn(e);
}//catch
Jan. 2004
15
Receiving UDP Datagrams
• 1) Construct a DatagramSocket object on the port you wish to
listen.
• 2) Pass it an empty Datagrampacket object to the
Datagramsocket’s receive() method.
• 3) Use methods
getport ( ),
getAddress( ),
getData ( ),
getLength( )
to retrieve information about the data.
Jan. 2004
16
Receiving UDP Datagrams
try {
byte buf=new byte[655361;
DatagramPacket dp = new
DatagramPacket(buf, buf.length);
DatagramSocket ds=newDatagramSocket(9100);
ds.receive(dp);
byte[] data=dp.getData();
String s=new String(data, 0, data.getLength());
System.out.println(s);
}//try
catch (IOException e) {
System.err.println(e);
}//catch
Jan. 2004
17
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.
Jan. 2004
18
UDP Echo Example
import java.io.*;
import java.net.*;
public class UDPEcho extends Thread {
static int port=7;
static volatile boolean running=false;
DatagramSocket ds;
public static void main(String args[]) {
InputstreamReader isr=new
InputStreamReader(System.in);
BufferedReader in = new
BufferedReader(isr);
String line;
Jan. 2004
19
UDP Echo Example
running=true;
try{
while ((line==in.readLine()) != null) {
byte[] data = line.getBytes();
DatagramPacket dP = new DatagramPacket
(data, data.length, server, port);
ds.send(dp);
Thread.yield();
}//while
}//try
Jan. 2004
20
UDP Echo Example
catch(IoException e) {
system.err.println(e); }
//catch
running = false; }
//main
public UDPEcho(DatagramSocket ds) {
this.ds=ds; }
//UDPEcho constructor
Jan. 2004
21
UDP Echo Example
public void run() {
byte[] buf = new byte[1024];
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());
Jan. 2004
22
UDP Echo Example
System.out.println("Echo: ", line);
} //try
catch(IOException e){
system.err.println(e);
}//catch
}//while
}//run
}//UDPEcho class
Jan. 2004
23