Java Network Programming, Part 2: Sockets, Server Sockets, and UDP
Java Network Programming, Part 2: Sockets, Server Sockets, and UDP
Elliotte Rusty Harold
elharo@metalab.unc.edu
http://metalab.unc.edu/javafaq/slides/
Please turn off all
Cell Phones
Pagers
Alarm Watches
etc.
and set your notebook's volume to zero
We will learn how Java handles
Sockets
Server Sockets
UDP
I assume you
Understand basic Java syntax and I/O
Have a user's view of the Internet
No prior network programming experience
Have heard Java Network Programming Part 1
Applet Network Security Restrictions
Applets may:
send data to the code base
receive data from the code base
Applets may not:
send data to hosts other than the code base
receive data from hosts other than the code base
Datagrams
Before data is sent across the Internet from one host to another using TCP/IP, it is split into packets of varying but finite size called datagrams.
Datagrams range in size from a few dozen bytes to about 60,000 bytes.
Packets larger than this, and often smaller than this, must be split into smaller pieces before they can be transmitted.
Packets Allow Error Correction
If one packet is lost, it can be retransmitted without requiring redelivery of all other packets.
If packets arrive out of order they can be reordered at the receiving end of the connection.
Abstraction
Datagrams are mostly hidden from the Java programmer.
The host's native networking software transparently splits data into packets on the sending end of a connection, and then reassembles packets on the receiving end.
Instead, the Java programmer is presented with a higher level abstraction called a socket.
Sockets
A socket is a reliable connection for the transmission of data between two hosts.
Sockets isolate programmers from the details of packet encodings, lost and retransmitted packets, and packets that arrive out of order.
There are limits. Sockets are more likely to throw
IOException
s than files, for example.
Socket Operations
There are four fundamental operations a socket performs. These are:
Connect to a remote machine
Send data
Receive data
Close the connection
A socket may not be connected to more than one host at a time.
A socket may not reconnect after it's closed.
The java.net.Socket class
The
java.net.Socket
class allows you to create socket objects that perform all four fundamental socket operations.You can connect to remote machines; you can send data; you can receive data; you can close the connection.
Each
Socket
object is associated with exactly one remote host. To connect to a different host, you must create a newSocket
object.
Constructing a Socket
Connection is accomplished through the constructors.
public Socket(String host, int port) throws UnknownHostException, IOException public Socket(InetAddress address, int port) throws IOException public Socket(String host, int port, InetAddress localAddr, int localPort) throws IOException public Socket(InetAddress address, int port, InetAddress localAddr, int localPort) throws IOException
Opening Sockets
The
Socket()
constructors do not just create a Socket object. They also attempt to connect the underlying socket to the remote server.All the constructors throw an
IOException
if the connection can't be made for any reason.
Example
You must at least specify the remote host and port to connect to.
The host may be specified as either a string like "utopia.poly.edu" or as an
InetAddress
object.The port should be an int between 1 and 65535.
Socket webMetalab = new Socket("metalab.unc.edu", 80);
You cannot just connect to any port on any host. The remote host must actually be listening for connections on that port.
You can use the constructors to determine which ports on a host are listening for connections.
Example
public static void scan(InetAddress remote) {
String hostname = remote.getHostName();
for (int port = 1; port < 65536; port++) {
try {
Socket s = new Socket(remote, port);
System.out.println("A server is listening on port "
+ port + " of " + hostname);
s.close();
}
catch (IOException e) {
// The remote host is not listening on this port
}
}
}
Picking an IP address
The last two constructors also specify the host and port you're connecting from.
On a system with multiple IP addresses, like many web servers, this allows you to pick your network interface and IP address.
Choosing a Local Port
You can also specify a local port number,
Setting the port to 0 tells the system to randomly choose an available port.
If you need to know the port you're connecting from, you can always get it with
getLocalPort()
.Socket webMetalab = new Socket("metalab.unc.edu", 80, "calzone.oit.unc.edu", 0);
Sending and Receiving Data
Data is sent and received with output and input streams.
There are methods to get an input stream for a socket and an output stream for the socket.
public InputStream getInputStream() throws IOException
public OutputStream getOutputStream() throws IOExceptionThere's also a method to close a socket:
public synchronized void close() throws IOException
Reading Input from a Socket
The
getInputStream()
method returns anInputStream
which reads data from the socket.You can use all the normal methods of the
InputStream
class to read this data.Most of the time you'll chain the input stream to some other input stream or reader object to more easily handle the data.
Time Client
The following code fragment connects to the daytime server on port 13 of tock.usno.navy.mil, and displays the data it sends.
try {
Socket s = new Socket("tock.usno.navy.mil", 13);
InputStream in = s.getInputStream();
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr, "ASCII");
int c;
while ((c = br.read()) != -1) {
System.out.print((char) c);
}
System.out.println();
}
catch (IOException e) {
return (new Date()).toString();
}
Writing Output to a Socket
The
getOutputStream()
method returns an output stream which writes data to the socket.Most of the time you'll chain the raw output stream to some other output stream or writer class to more easily handle the data.
Discard
byte[] b = new byte[128];
try {
Socket s = new Socket("metalab.unc.edu", 9);
OutputStream theOutput = s.getOutputStream();
while (true) {
int n = theInput.available();
if (n > b.length) n = b.length;
int m = theInput.read(b, 0, n);
if (m == -1) break;
theOutput.write(b, 0, n);
}
s.close();
}
catch (IOException e) {}
Reading and Writing to a Socket
It's unusual to only read from a socket. It's even more unusual to only write to a socket.
Most protocols require the client to both read and write.
Example
Some protocols require the reads and the writes to be interlaced. That is:
write read write read write read
Example
Other protocols, such as HTTP 1.0, have multiple writes, followed by multiple reads, like this:
write write write read read read read
Example
Other protocols don't care and allow client requests and server responses to be freely intermixed.
Java places no restrictions on reading and writing to sockets.
One thread can read from a socket while another thread writes to the socket at the same time.
Example
import java.net.*;
import java.io.*;
public class SocketCat {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
int port = 80;
String file = "/";
try {
URL u = new URL(args[i]);
if (u.getPort() != -1) port = u.getPort();
if (!(u.getProtocol().equalsIgnoreCase("http"))) {
System.err.println("I only understand http.");
continue;
}
if (!(u.getFile().equals(""))) file = u.getFile();
Socket s = new Socket(u.getHost(), port);
OutputStream theOutput = s.getOutputStream();
PrintWriter pw = new PrintWriter(theOutput, false);
pw.print("GET " + file + " HTTP/1.0\r\n");
pw.print("Accept: text/plain, text/html, text/*\r\n");
pw.print("\r\n");
pw.flush();
InputStream in = s.getInputStream();
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr, "ASCII");
String theLine;
while ((theLine = br.readLine()) != null) {
System.out.println(theLine);
}
}
catch (MalformedURLException e) {
System.err.println(args[i] + " is not a valid URL");
}
catch (IOException e) {
System.err.println(e);
}
}
}
}
Better Example
No
PrintStream
No
readLine()
import java.net.*;
import java.io.*;
public class BetterCat {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
int port = 80;
String file = "/";
try {
URL u = new URL(args[i]);
if (u.getPort() != -1) port = u.getPort();
if (!(u.getProtocol().equalsIgnoreCase("http"))) {
System.err.println("I only understand http.");
}
if (!(u.getFile().equals(""))) file = u.getFile();
Socket s = new Socket(u.getHost(), port);
OutputStream theOutput = s.getOutputStream();
OutputStreamWriter out = new OutputStreamWriter(theOutput);
out.write("GET " + file + " HTTP/1.0\r\n");
out.write("Accept: text/plain, text/html, text/*\r\n");
out.write("\r\n");
out.flush();
InputStream in = s.getInputStream();
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr);
int c;
while ((c = br.read()) != -1) {
System.out.print((char) c);
}
}
catch (MalformedURLException e) {
System.err.println(args[i] + " is not a valid URL");
}
catch (IOException e) {
System.err.println(e);
}
}
}
}
Socket Options
Several methods set various socket options. Most of the time the defaults are fine.
public void setTcpNoDelay(boolean on) throws SocketException public boolean getTcpNoDelay() throws SocketException public void setSoLinger(boolean on, int val) throws SocketException public int getSoLinger() throws SocketException public void setSoTimeout(int timeout) throws SocketException public int getSoTimeout() throws SocketException
Example
These methods to return information about the socket:
public InetAddress getInetAddress()
public InetAddress getLocalAddress()
public int getPort()
public int getLocalPort()Finally there's the usual
toString()
method:public String toString()
Servers
There are two ends to each connection: the client, that is the host that initiates the connection, and the server, that is the host that responds to the connection.
Clients and servers are connected by sockets.
A server, rather than connecting to a remote host, a program waits for other hosts to connect to it.
Server Sockets
A server socket binds to a particular port on the local machine.
Once it has successfully bound to a port, it listens for incoming connection attempts.
When a server detects a connection attempt, it accepts the connection. This creates a socket between the client and the server over which the client and the server communicate.
Multiple Clients
Multiple clients can connect to the same port on the server at the same time.
Incoming data is distinguished by the port to which it is addressed and the client host and port from which it came.
The server can tell for which service (like http or ftp) the data is intended by inspecting the port.
It can tell which open socket on that service the data is intended for by looking at the client address and port stored with the data.
Queueing
Incoming connections are stored in a queue until the server can accept them.
On most systems the default queue length is between 5 and 50.
Once the queue fills up further incoming connections are refused until space in the queue opens up.
The java.net.ServerSocket Class
The
java.net.ServerSocket
class represents a server socket.A
ServerSocket
object is constructed on a particular local port. Then it callsaccept()
to listen for incoming connections.accept()
blocks until a connection is detected. Thenaccept()
returns ajava.net.Socket
object that performs the actual communication with the client.
Constructors
There are three constructors that let you specify the port to bind to, the queue length for incoming connections, and the IP address to bind to:
public ServerSocket(int port) throws IOException
public ServerSocket(int port, int backlog) throws IOException
public ServerSocket(int port, int backlog, InetAddress networkInterface) throws IOException
Constructing Server Sockets
Normally you only specify the port you want to listen on, like this:
try { ServerSocket ss = new ServerSocket(80); } catch (IOException e) { System.err.println(e); }
Example
When a
ServerSocket
object is created, it attempts to bind to the port on the local host given by the port argument.If another server socket is already listening to the port, then a
java.net.BindException
, a subclass ofIOException
, is thrown.No more than one process or thread can listen to a particular port at a time. This includes non-Java processes or threads.
For example, if there's already an HTTP server running on port 80, you won't be able to bind to port 80.
Example
On Unix systems (but not Windows or the Mac) your program must be running as root to bind to a port between 1 and 1023.
0 is a special port number. It tells Java to pick an available port.
The
getLocalPort()
method tells you what port the server socket is listening on. This is useful if the client and the server have already established a separate channel of communication over which the chosen port number can be communicated.FTP
Expanding the Queue
If you think you aren't going to be processing connections very quickly you may wish to expand the queue when you construct the server socket. For example,
try { ServerSocket httpd = new ServerSocket(80, 50); } catch (IOException e) { System.err.println(e); }
Choosing an IP address
Many hosts have more than one IP address.
By default, a server socket binds to all available IP addresses on a given port.
You can modify that behavior with this constructor:
public ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException
Example
try {
InetAddress ia = InetAddress.getByName("199.1.32.90");
ServerSocket ss = new ServerSocket(80, 50, ia);
}
catch (IOException e) {
System.err.println(e);
}
Example
On a server with multiple IP addresses, the
getInetAddress()
method tells you which one this server socket is listening to.public InetAddress getInetAddress()
The
getLocalPort()
method tells you which port you're listening to.public int getLocalPort()
Example
The
accept()
andclose()
methods provide the basic functionality of a server socket.public Socket accept() throws IOException public void close() throws IOException
A server socket can't be reopened after it's closed
Reading Data with a ServerSocket
ServerSocket
objects use theiraccept()
method to connect to a client.public Socket accept() throws IOException
There are no
getInputStream()
orgetOutputStream()
methods forServerSocket
.accept()
returns a Socket object, and itsgetInputStream()
andgetOutputStream()
methods provide streams.
Example
try {
ServerSocket ss = new ServerSocket(2345);
Socket s = ss.accept();
PrintWriter pw = new
PrintWriter(s.getOutputStream());
pw.println("Hello There!");
pw.println("Goodbye now.");
s.close();
}
catch (IOException e) {
System.err.println(e);
}
Better Example
try {
ServerSocket ss = new ServerSocket(2345);
Socket s = ss.accept();
Writer out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
out.write("Hello There!\r\n");
out.write("Goodbye now.\r\n");
out.flush();
s.close();
}
catch (IOException e) {
System.err.println(e);
}
Writing Data to a Client
try {
ServerSocket ss = new ServerSocket(port);
while (true) {
try {
Socket s = ss.accept();
Writer out = new OutputStreamWriter(s.getOutputStream());
out = new BufferedWriter(out);
out.write("Hello " + s.getInetAddress() + " on port "
+ s.getPort() + "\r\n");
out.write("This is " + s.getLocalAddress() + " on port "
+ s.getLocalPort() + "\r\n");
out.flush();
s.close();
}
catch (IOException e) {}
}
}
catch (IOException e) { System.err.println(e); }
Interacting with a Client
More commonly, a server needs to both read a client request and write a response.
Threading
No more than one server socket can listen to a particular port at one time.
Since a server may need to handle many connections at once, server programs tend to be heavily multi-threaded.
Generally the server socket passes off the actual processing of connections to a separate thread.
Adding Threading to a Server
It's better to make your server multi-threaded.
There should be a loop which continually accepts new connections.
Rather than handling the connection directly the socket should be passed to a
Thread
object that handles the connection.
Adding a Thread Pool to a Server
Multi-threading is a good thing but it's still not a perfect solution.
Look at this accept loop:
while (true) { try { Socket s = ss.accept(); ThreadedEchoServer tes = new ThreadedEchoServer(s); tes.start(); } catch (IOException e) {} }
Example
Every time you pass through this loop, a new thread gets created. Every time a connection is finished the thread is disposed of.
Spawning a new thread for each connection takes a non-trivial amount of time, especially on a heavily loaded server. It would be better not to spawn so many threads.
Thread Pools
Create a pool of threads when the server launches, store incoming connections in a queue, and have the threads in the pool progressively remove connections from the queue and process them.
The main change you need to make to implement this is to call
accept()
in therun()
method rather than in themain()
method.
Setting Server Socket Options
There are three methods to set and get various options. The defaults are generally fine.
public synchronized void setSoTimeout(int timeout) throws SocketException public synchronized int getSoTimeout() throws IOException public static synchronized void setSocketFactory(SocketImplFactory fac) throws IOException
Utility Methods
Finally, there's the usual
toString()
method:public String toString()
UDP
User Datagram Protocol
Unreliable Datagram Protocol
Packet Oriented, not stream oriented like TCP/IP
Much faster but no error correction
NFS, TFTP, and FSP use UDP/IP
Must fit data into packets of about 8K or less
The UDP Classes
Java's support for UDP is contained in two classes:
java.net.DatagramSocket
java.net.DatagramPacket
A datagram socket is used to send and receive datagram packets.
java.net.DatagramPacket
A wrapper for an array of bytes from which data will be sent or into which data will be received.
Also contains the address and port to which the packet will be sent.
java.net.DatagramSocket
A
DatagramSocket
object is a local connection to a port that does the sending and receiving.There is no distinction between a UDP socket and a UDP server socket.
Also unlike TCP sockets, a
DatagramSocket
can send to multiple, different addresses.The address to which data goes is stored in the packet, not in the socket.
UDP ports
Separate from TCP ports.
Each computer has 65,536 UDP ports as well as its 65,536 TCP ports.
A server socket can be bound to TCP port 20 at the same time as a datagram socket is bound to UDP port 20.
Two DatagramPacket Constructors
public DatagramPacket(byte[] data, int length)
public DatagramPacket(byte[] data, int length, InetAddress iaddr, int iport)
First is for receiving, second is for sending
For example,
String s = "My first UDP Packet"
byte[] b = s.getBytes();
DatagramPacket dp = new DatagramPacket(b, b.length);
With a destination:
try {
InetAddress metalab = new InetAddess("metalab.unc.edu");
int chargen = 19;
String s = "My second UDP Packet"
byte[] b = s.getBytes();
DatagramPacket dp = new DatagramPacket(b, b.length, metalab, chargen);
}
catch (UnknownHostException e) {
System.err.println(e);
}
DatagramPackets are not immutable.
public synchronized void setAddress(InetAddress iaddr)
public synchronized void setPort(int iport)
public synchronized void setData(byte ibuf[])
public synchronized void setLength(int ilength)
public synchronized InetAddress getAddress()
public synchronized int getPort()
public synchronized byte[] getData()
public synchronized int getLength()
These methods are primarily useful when you're receiving datagrams.
java.net.DatagramSocket
public DatagramSocket() throws SocketException
public DatagramSocket(int port) throws SocketException
public DatagramSocket(int port, InetAddress laddr) throws SocketException
The first is for client datagram sockets; that is sockets that send datagrams before receiving any.
The second two are for server datagram sockets since they specify the port and optionally the IP address of the socket
Sending UDP Datagrams
To send data to a particular server
Convert the data into byte array.
Pass this byte array, the length of the data in the array (most of the time this will be the length of the array) and the
InetAddress
and port to which you wish to send it into theDatagramPacket()
constructor.Next create a
DatagramSocket
and pass the packet to itssend()
method
For example,
InetAddress metalab = new InetAddess("metalab.unc.edu");
int chargen = 19;
String s = "My second UDP Packet";
byte[] b = s.getBytes();
DatagramPacket dp = new DatagramPacket(b, b.length, ia, chargen);
DatagramSocket sender = new DatagramSocket();
sender.send(dp);
Receiving UDP Datagrams
Construct a
DatagramSocket
object on the port on which you want to listen.Pass an empty
DatagramPacket
object to theDatagramSocket
'sreceive()
method.public synchronized void receive(DatagramPacket dp) throws IOException
The calling thread blocks until a datagram is received.
dp
is filled with the data from that datagram.Use
getPort()
and andgetAddress()
to tell where the packet came from,getData()
to retrieve the data, andgetLength()
to see how many bytes were in the data.If the received packet was too long for the buffer, it's truncated to the length of the buffer.
Length is reset when packet is received
For example,
try {
byte buffer = new byte[65536];
DatagramPacket incoming = new DatagramPacket(buffer, buffer.length);
DatagramSocket ds = new DatagramSocket(2134);
ds.receive(incoming);
byte[] data = incoming.getData();
String s = new String(data, 0, data.getLength());
System.out.println("Port" + incoming.getPort() + " on "
+ incoming.getAddress() + " sent this message:");
System.out.println(s);
}
catch (IOException e) {
System.err.println(e);
}
To Learn More
Java Network Programming, Second Edition
Elliotte Rusty Harold
O'Reilly & Associates, 2000
ISBN: 1-565-92870-9
Java I/O
O'Reilly & Associates, 1999
ISBN 1-56592-485-1
This presentation: http://www.ibiblio.org/javafaq/slides/sd2000east/sockets/
Questions?
Copyright 2000 Elliotte Rusty Harold
elharo@metalab.unc.edu
Last Modified November 8, 2000
No comments:
Post a Comment