What Is a Socket?
Normally, a server runs on a specific computer and has a socket that
is bound to a specific port number. The server just waits, listening to
the socket for a client to make a connection request.
On the client-side: The client knows the hostname of the machine on
which the server is running and the port number on which the server is
listening. To make a connection request, the client tries to rendezvous
with the server on the server's machine and port. The client also needs
to identify itself to the server so it binds to a local port number that
it will use during this connection. This is usually assigned by the
system.
If
everything goes well, the server accepts the connection. Upon
acceptance, the server gets a new socket bound to the same local port
and also has its remote endpoint set to the address and port of the
client. It needs a new socket so that it can continue to listen to the
original socket for connection requests while tending to the needs of
the connected client.
On
the client side, if the connection is accepted, a socket is
successfully created and the client can use the socket to communicate
with the server.
The client and server can now communicate by writing to or reading from their sockets.
Definition: A socket
is one endpoint of a two-way communication link between two programs
running on the network. A socket is bound to a port number so that the
TCP layer can identify the application that data is destined to be sent.
An endpoint is a combination of an IP address and a port number.
Every TCP connection can be uniquely identified by its two endpoints.
That way you can have multiple connections between your host and the
server.
The
java.net package in the Java platform provides a class,
Socket, that implements one side of a two-way connection between your Java program and another program on the network. The
Socket
class sits on top of a platform-dependent implementation, hiding the
details of any particular system from your Java program. By using the
java.net.Socket class instead of relying on native code, your Java programs can communicate over the network in a platform-independent fashion.
Additionally,
java.net includes the
ServerSocket
class, which implements a socket that servers can use to listen for and
accept connections to clients. This lesson shows you how to use the
Socket and
ServerSocket classes.
If you are trying to connect to the Web, the
URL class and related classes (
URLConnection,
URLEncoder)
are probably more appropriate than the socket classes. In fact, URLs
are a relatively high-level connection to the Web and use sockets as
part of the underlying implementation. See
Working with URLs for information about connecting to the Web via URLs.
Reading from and Writing to a Socket
Let's look at a simple example that illustrates how a program can establish a connection to a server program using the
Socket class and then, how the client can send data to and receive data from the server through the socket.
The example program implements a client,
EchoClient,
that connects to the Echo server. The Echo server simply receives data
from its client and echoes it back. The Echo server is a well-known
service that clients can rendezvous with on port 7.
EchoClient creates a socket thereby getting a connection
to the Echo server. It reads input from the user on the standard input
stream, and then forwards that text to the Echo server by writing the
text to the socket. The server echoes the input back through the socket
to the client. The client program reads and displays the data passed
back to it from the server:
import java.io.*;
import java.net.*;
public class EchoClient {
public static void main(String[] args) throws IOException {
Socket echoSocket = null;
PrintWriter out = null;
BufferedReader in = null;
try {
echoSocket = new Socket("taranis", 7);
out = new PrintWriter(echoSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(
echoSocket.getInputStream()));
} catch (UnknownHostException e) {
System.err.println("Don't know about host: taranis.");
System.exit(1);
} catch (IOException e) {
System.err.println("Couldn't get I/O for "
+ "the connection to: taranis.");
System.exit(1);
}
BufferedReader stdIn = new BufferedReader(
new InputStreamReader(System.in));
String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput);
System.out.println("echo: " + in.readLine());
}
out.close();
in.close();
stdIn.close();
echoSocket.close();
}
}
Note that
EchoClient both writes to and reads from its socket, thereby sending data to and receiving data from the Echo server.
Let's walk through the program and investigate the interesting parts. The three statements in the
try block of the
main method are critical. These lines establish the socket connection between the client and the server and open a
PrintWriter and a
BufferedReader on the socket:
echoSocket = new Socket("taranis", 7);
out = new PrintWriter(echoSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(
echoSocket.getInputStream()));
The first statement in this sequence creates a new
Socket object and names it
echoSocket. The
Socket
constructor used here requires the name of the machine and the port
number to which you want to connect. The example program uses the host
name
taranis. This is the name of a hypothetical machine on
our local network. When you type in and run this program on your
machine, change the host name to the name of a machine on your network.
Make sure that the name you use is the fully qualified IP name of the
machine to which you want to connect. The second argument is the port
number. Port number 7 is the port on which the Echo server listens.
The second statement gets the socket's output stream and opens a
PrintWriter on it. Similarly, the third statement gets the socket's input stream and opens a
BufferedReader on it. The example uses readers and writers so that it can write Unicode characters over the socket.
To send data through the socket to the server,
EchoClient simply needs to write to the
PrintWriter. To get the server's response,
EchoClient reads from the
BufferedReader. The rest of the program achieves this. If you are not yet familiar with the Java platform's I/O classes, you may wish to read
Basic I/O.
The next interesting part of the program is the
while
loop. The loop reads a line at a time from the standard input stream and
immediately sends it to the server by writing it to the
PrintWriter connected to the socket:
String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput);
System.out.println("echo: " + in.readLine());
}
The last statement in the
while loop reads a line of information from the
BufferedReader connected to the socket. The
readLine method waits until the server echoes the information back to
EchoClient. When
readline returns,
EchoClient prints the information to the standard output.
The
while loop continues until the user types an end-of-input character. That is,
EchoClient
reads input from the user, sends it to the Echo server, gets a response
from the server, and displays it, until it reaches the end-of-input.
The
while loop then terminates and the program continues, executing the next four lines of code:
out.close();
in.close();
stdIn.close();
echoSocket.close();
These lines of code fall into the category of housekeeping. A
well-behaved program always cleans up after itself, and this program is
well-behaved. These statements close the readers and writers connected
to the socket and to the standard input stream, and close the socket
connection to the server. The order here is important. You should close
any streams connected to a socket before you close the socket itself.
This client program is straightforward and simple because the Echo
server implements a simple protocol. The client sends text to the
server, and the server echoes it back. When your client programs are
talking to a more complicated server such as an HTTP server, your client
program will also be more complicated. However, the basics are much the
same as they are in this program:
- Open a socket.
- Open an input stream and output stream to the socket.
- Read from and write to the stream according to the server's protocol.
- Close the streams.
- Close the socket.
Only step 3 differs from client to client, depending on the server. The other steps remain largely the same.
Writing the Server Side of a Socket
This section shows you how to write a server and the client that goes
with it. The server in the client/server pair serves up Knock Knock
jokes. Knock Knock jokes are favored by children and are usually
vehicles for bad puns. They go like this:
Server: "Knock knock!"
Client: "Who's there?"
Server: "Dexter."
Client: "Dexter who?"
Server: "Dexter halls with boughs of holly."
Client: "Groan."
The example consists of two independently running Java programs: the
client program and the server program. The client program is implemented
by a single class,
KnockKnockClient, and is very similar to the
EchoClient example from the previous section. The server program is implemented by two classes:
KnockKnockServer and
KnockKnockProtocol,
KnockKnockServer contains the
main
method for the server program and performs the work of listening to the
port, establishing connections, and reading from and writing to the
socket.
KnockKnockProtocol serves up the jokes. It keeps
track of the current joke, the current state (sent knock knock, sent
clue, and so on), and returns the various text pieces of the joke
depending on the current state. This object implements the protocol-the
language that the client and server have agreed to use to communicate.
The following section looks in detail at each class in both the client and the server and then shows you how to run them.
The Knock Knock Server
This section walks through the code that implements the Knock Knock server program. Here is the complete source for the
KnockKnockServer class.
The server program begins by creating a new
ServerSocket
object to listen on a specific port (see the statement in bold in the
following code segment). When writing a server, choose a port that is
not already dedicated to some other service.
KnockKnockServer
listens on port 4444 because 4 happens to be my favorite number and
port 4444 is not being used for anything else in my environment:
try {
serverSocket = new ServerSocket(4444);
} catch (IOException e) {
System.out.println("Could not listen on port: 4444");
System.exit(-1);
}
ServerSocket is a
java.net class that
provides a system-independent implementation of the server side of a
client/server socket connection. The constructor for
ServerSocket throws an exception if it can't listen on the specified port (for example, the port is already being used). In this case, the
KnockKnockServer has no choice but to exit.
If the server successfully binds to its port, then the
ServerSocket object is successfully created and the server continues to the next step--accepting a connection from a client (shown in bold):
Socket clientSocket = null;
try {
clientSocket = serverSocket.accept();
} catch (IOException e) {
System.out.println("Accept failed: 4444");
System.exit(-1);
}
The
accept method waits until a client starts up and
requests a connection on the host and port of this server (in this
example, the server is running on the hypothetical machine taranis on
port 4444). When a connection is requested and successfully established,
the accept method returns a new
Socket object which is
bound to the same local port and has its remote address and remote port
set to that of the client. The server can communicate with the client
over this new
Socket and continue to listen for client connection requests on the original
ServerSocket
This particular version of the program doesn't listen for more client
connection requests. However, a modified version of the program is
provided in
Supporting Multiple Clients.
After the server successfully establishes a connection with a client, it communicates with the client using this code:
PrintWriter out = new PrintWriter(
clientSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader(
new InputStreamReader(
clientSocket.getInputStream()));
String inputLine, outputLine;
// initiate conversation with client
KnockKnockProtocol kkp = new KnockKnockProtocol();
outputLine = kkp.processInput(null);
out.println(outputLine);
while ((inputLine = in.readLine()) != null) {
outputLine = kkp.processInput(inputLine);
out.println(outputLine);
if (outputLine.equals("Bye."))
break;
}
This code:
- Gets the socket's input and output stream and opens readers and writers on them.
- Initiates communication with the client by writing to the socket (shown in bold).
- Communicates with the client by reading from and writing to the socket (the
while loop).
Step 1 is already familiar. Step 2 is shown in bold and is worth a
few comments. The bold statements in the code segment above initiate the
conversation with the client. The code creates a
KnockKnockProtocol object-the object that keeps track of the current joke, the current state within the joke, and so on.
After the
KnockKnockProtocol is created, the code calls
KnockKnockProtocol's
processInput
method to get the first message that the server sends to the client.
For this example, the first thing that the server says is "Knock!
Knock!" Next, the server writes the information to the
PrintWriter connected to the client socket, thereby sending the message to the client.
Step 3 is encoded in the
while loop. As long as the
client and server still have something to say to each other, the server
reads from and writes to the socket, sending messages back and forth
between the client and the server.
The server initiated the conversation with a "Knock! Knock!" so
afterwards the server must wait for the client to say "Who's there?" As a
result, the while loop iterates on a read from the input stream. The
readLine method waits until the client responds by writing something to
its output stream (the server's input stream). When the client responds,
the server passes the client's response to the
KnockKnockProtocol object and asks the
KnockKnockProtocol
object for a suitable reply. The server immediately sends the reply to
the client via the output stream connected to the socket, using a call
to println. If the server's response generated from the
KnockKnockServer object is "Bye." this indicates that the client doesn't want any more jokes and the loop quits.
The
KnockKnockServer class is a well-behaved server, so the last several lines of this section of
KnockKnockServer clean up by closing all of the input and output streams, the client socket, and the server socket:
out.close();
in.close();
clientSocket.close();
serverSocket.close();
The Knock Knock Protocol
The
KnockKnockProtocol
class implements the protocol that the client and server use to
communicate. This class keeps track of where the client and the server
are in their conversation and serves up the server's response to the
client's statements. The
KnockKnockServer object contains
the text of all the jokes and makes sure that the client gives the
proper response to the server's statements. It wouldn't do to have the
client say "Dexter who?" when the server says "Knock! Knock!"
All client/server pairs must have some protocol by which they speak
to each other; otherwise, the data that passes back and forth would be
meaningless. The protocol that your own clients and servers use depends
entirely on the communication required by them to accomplish the task.
The Knock Knock Client
The
KnockKnockClient class implements the client program that speaks to the
KnockKnockServer.
KnockKnockClient is based on the
EchoClient program in the previous section,
Reading from and Writing to a Socket
and should be somewhat familiar to you. But we'll go over the program
anyway and look at what's happening in the client in the context of
what's going on in the server.
When you start the client program, the server should already be
running and listening to the port, waiting for a client to request a
connection. So, the first thing the client program does is to open a
socket that is connected to the server running on the hostname and port
specified:
kkSocket = new Socket("taranis", 4444);
out = new PrintWriter(kkSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(
kkSocket.getInputStream()));
When creating its socket,
KnockKnockClient uses the host name
taranis,
the name of a hypothetical machine on our network. When you type in and
run this program, change the host name to the name of a machine on your
network. This is the machine on which you will run the
KnockKnockServer.
The
KnockKnockClient program also specifies the port number 4444 when creating its socket. This is a
remote port number--the number of a port on the server machine--and is the port to which
KnockKnockServer is listening. The client's socket is bound to any available
local port--a
port on the client machine. Remember that the server gets a new socket
as well. That socket is bound to local port number 4444 on its machine.
The server's socket and the client's socket are connected.
Next comes the while loop that implements the communication between
the client and the server. The server speaks first, so the client must
listen first. The client does this by reading from the input stream
attached to the socket. If the server does speak, it says "Bye." and the
client exits the loop. Otherwise, the client displays the text to the
standard output and then reads the response from the user, who types
into the standard input. After the user types a carriage return, the
client sends the text to the server through the output stream attached
to the socket.
while ((fromServer = in.readLine()) != null) {
System.out.println("Server: " + fromServer);
if (fromServer.equals("Bye."))
break;
fromUser = stdIn.readLine();
if (fromUser != null) {
System.out.println("Client: " + fromUser);
out.println(fromUser);
}
}
The communication ends when the server asks if the client wishes to
hear another joke, the client says no, and the server says "Bye."
In the interest of good housekeeping, the client closes its input and output streams and the socket:
out.close();
in.close();
stdIn.close();
kkSocket.close();
Running the Programs
You must start the server program first. To do this, run the server
program using the Java interpreter, just as you would any other Java
application. Remember to run the server on the machine that the client
program specifies when it creates the socket.
Next, run the client program. Note that you can run the client on any
machine on your network; it does not have to run on the same machine as
the server.
If you are too quick, you might start the client before the server
has a chance to initialize itself and begin listening on the port. If
this happens, you will see a stack trace from the client. If this
happens, just restart the client.
If you forget to change the host name in the source code for the
KnockKnockClient program, you will see the following error message:
Don't know about host: taranis
To fix this, modify the
KnockKnockClient program and provide a valid host name for your network. Recompile the client program and try again.
If you try to start a second client while the first client is
connected to the server, the second client just hangs. The next section,
Supporting Multiple Clients, talks about supporting multiple clients.
When you successfully get a connection between the client and server, you will see the following text displayed on your screen:
Now, you must respond with:
The client echoes what you type and sends the text to the server. The
server responds with the first line of one of the many Knock Knock
jokes in its repertoire. Now your screen should contain this (the text
you typed is in bold):
Server: Knock! Knock!
Who's there?
Client: Who's there?
Server: Turnip
Now, you respond with:
Again, the client echoes what you type and sends the text to the
server. The server responds with the punch line. Now your screen should
contain this:
Server: Knock! Knock!
Who's there?
Client: Who's there?
Server: Turnip
Turnip who?
Client: Turnip who?
Server: Turnip the heat, it's cold in here! Want another? (y/n)
If you want to hear another joke, type
y; if not, type
n. If you type
y, the server begins again with "Knock! Knock!" If you type
n, the server says "Bye." thus causing both the client and the server to exit.
If at any point you make a typing mistake, the
KnockKnockServer object catches it and the server responds with a message similar to this:
Server: You're supposed to say "Who's there?"!
The server then starts the joke over again:
Server: Try again. Knock! Knock!
Note that the
KnockKnockProtocol object is particular about spelling and punctuation but not about capitalization.
To keep the
KnockKnockServer example simple, we designed
it to listen for and handle a single connection request. However,
multiple client requests can come into the same port and, consequently,
into the same
ServerSocket. Client connection requests are
queued at the port, so the server must accept the connections
sequentially. However, the server can service them simultaneously
through the use of threads - one thread per each client connection.
The basic flow of logic in such a server is this:
while (true) {
accept a connection ;
create a thread to deal with the client ;
end while
The thread reads from and writes to the client connection as necessary.
What are Sockets and Threads?
A
socket is a software endpoint that establishes bidirectional
communication between a server program and one or more client programs.
The socket associates the server program with a specific hardware port
on the machine where it runs so any client program anywhere in the
network with a socket associated with that same port can communicate
with the server program.
A server program typically provides resources to a network of client
programs. Client programs send requests to the server program, and the
server program responds to the request.
One way to handle
requests from more than one client is to make the server program
multi-threaded. A multi-threaded server creates a thread for each
communication it accepts from a client. A thread is a sequence of
instructions that run independently of the program and of any other
threads.
Using threads, a
multi-threaded server program can accept a connection from a client,
start a thread for that communication, and continue listening for
requests from other clients.
About the Examples
The examples for this lesson consist of two versions of the client and server program pair adapted from the
FileIO.java application presented in
Part 1, Lesson 6: File Access and Permissions.
Example 1 sets up a
client and server communication between one server program and one
client program. The server program is not multi-threaded and cannot
handle requests from more than one client.
Example 2 converts the server program to a multi-threaded version so it can handle requests from more than one client.
Example 1: Client-Side Behavior
The
client program presents a simple user interface and prompts for text input. When you click the
Click Me button, the text is sent to the server
program. The client program expects an echo from the server and prints
the echo it receives on its standard output.
Example 1: Server-Side Behavior
The
server program presents a simple user interface, and when you click the
Click Me button, the text received from the client is displayed. The server echoes the text it receives whether or not you click the
Click Me button.
Example 1: Compile and Run
To
run the example programs, start the server program first. If you do
not, the client program cannot establish the socket connection. Here are
the compiler and interpreter commands to compile and run the example.
javac SocketServer.java
javac SocketClient.java
java SocketServer
java SocketClient
|
Example 1: Server-Side Program
The
server program establishes a socket connection on Port 4321 in its
listenSocket method. It reads data sent to it and sends that same data back to the server in its
actionPerformed method.
listenSocket Method
The
listenSocket method creates a
ServerSocket object with the port number on
which the server program is going to listen for client communications.
The port number must be an available port, which means the number cannot
be reserved or already in use. For example, Unix systems reserve ports 1
through 1023 for administrative functions leaving port numbers greater
than 1024 available for use.
public void listenSocket(){
try{
server = new ServerSocket(4321);
} catch (IOException e) {
System.out.println("Could not listen on port 4321");
System.exit(-1);
}
|
listenSocketSocketserver.acceptSocket
try{
client = server.accept();
} catch (IOException e) {
System.out.println("Accept failed: 4321");
System.exit(-1);
}
|
listenSocketBufferedReaderclientPrintWriter
try{
in = new BufferedReader(new InputStreamReader(
client.getInputStream()));
out = new PrintWriter(client.getOutputStream(),
true);
} catch (IOException e) {
System.out.println("Read failed");
System.exit(-1);
}
}
|
listenSocket
while(true){
try{
line = in.readLine();
//Send data back to client
out.println(line);
} catch (IOException e) {
System.out.println("Read failed");
System.exit(-1);
}
}
|
actionPerformed Method
The
actionPerformed method is called by the Java platform for action events such as button clicks. This
actionPerformed method uses the text stored in the
line object to initialize the
textArea object so the retrieved text can be displayed to the end user.
public void actionPerformed(ActionEvent event) {
Object source = event.getSource();
if(source == button){
textArea.setText(line);
}
}
|
Example 1: Client-Side Program
The
client program establishes a connection to the server program on a particular host and port number in its
listenSocket method, and sends the data entered by the end user to the server program in its
actionPerformed method. The
actionPerformed method also receives the data back from the server and prints it to the command line.
listenSocket Method
The
listenSocket method first creates a
Socket object with the computer name (
kq6py) and port number (4321) where the server program is listening for client connection requests. Next, it creates a
PrintWriter object to send data over the socket connection to the server program. It also creates a
BufferedReader object to read the text sent by the server back to the client.
public void listenSocket(){
//Create socket connection
try{
socket = new Socket("kq6py", 4321);
out = new PrintWriter(socket.getOutputStream(),
true);
in = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
} catch (UnknownHostException e) {
System.out.println("Unknown host: kq6py");
System.exit(1);
} catch (IOException e) {
System.out.println("No I/O");
System.exit(1);
}
}
|
actionPerformed Method
The
actionPerformed method is called by the Java platform for action events such as button clicks. This
actionPerformed method code gets the text in the
Textfield object and passes it to the
PrintWriter object, which then sends it over the socket connection to the server program.
The
actionPerformed method then makes the
Textfield object blank so it is ready for more
end user input. Lastly, it receives the text sent back to it by the
server and prints the text out.
public void actionPerformed(ActionEvent event){
Object source = event.getSource();
if(source == button){
//Send data over socket
String text = textField.getText();
out.println(text);
textField.setText(new String(""));
out.println(text);
}
//Receive text from server
try{
String line = in.readLine();
System.out.println("Text received: " + line);
} catch (IOException e){
System.out.println("Read failed");
System.exit(1);
}
}
|
Example 2: Multithreaded Server Example
The
example in its current state works between the server program and one
client program only. To allow multiple client connections, the server
program has to be converted to a
multithreaded server program.
First Client
Second Client
Third Client
|
 |
In this example the
listenSocket method loops on the
server.accept call waiting for client connections and creates an instance of the
ClientWorker class for each client connection it accepts. The
textArea component that displays the text received from the client connection is passed to the
ClientWorker instance with the accepted client connection.
public void listenSocket(){
try{
server = new ServerSocket(4444);
} catch (IOException e) {
System.out.println("Could not listen on port 4444");
System.exit(-1);
}
while(true){
ClientWorker w;
try{
//server.accept returns a client connection
w = new ClientWorker(server.accept(), textArea);
Thread t = new Thread(w);
t.start();
} catch (IOException e) {
System.out.println("Accept failed: 4444");
System.exit(-1);
}
}
}
|
The important changes in this version of the server program over the non-threaded server program are the
line and
client variables are no longer instance variables of the server class, but are handled inside the
ClientWorker class.
The
ClientWorker class implements the
Runnable interface, which has one method,
run. The
run method executes independently in each thread. If three clients request connections, three
ClientWorker instances are created, a thread is started for each
ClientWorker instance, and the
run method executes for each thread.
In this example, the
run method creates the input buffer and output
writer, loops on the input stream waiting for input from the client,
sends the data it receives back to the client, and sets the text in the
text area.
class ClientWorker implements Runnable {
private Socket client;
private JTextArea textArea;
//Constructor
ClientWorker(Socket client, JTextArea textArea) {
this.client = client;
this.textArea = textArea;
}
public void run(){
String line;
BufferedReader in = null;
PrintWriter out = null;
try{
in = new BufferedReader(new
InputStreamReader(client.getInputStream()));
out = new
PrintWriter(client.getOutputStream(), true);
} catch (IOException e) {
System.out.println("in or out failed");
System.exit(-1);
}
while(true){
try{
line = in.readLine();
//Send data back to client
out.println(line);
//Append data to text area
textArea.append(line);
}catch (IOException e) {
System.out.println("Read failed");
System.exit(-1);
}
}
}
}
|
JTextArea.appendJTextArea.appendtextArea.append(line)synchronizedruntextArea.append(line)appendText(line) public synchronized void appendText(line){
textArea.append(line);
}
synchronizedtextAreatextAreaThe
finalize() method is called by the Java virtual
machine (JVM)* before the program exits to give the program a chance to
clean up and release resources. Multi-threaded programs should close
all
Files and
Sockets they use before exiting so they do not face resource starvation. The call to
server.close() in the
finalize() method closes the
Socket connection used by each thread in this program.
protected void finalize(){
//Objects created in run method are finalized when
//program terminates and thread exits
try{
server.close();
} catch (IOException e) {
System.out.println("Could not close socket");
System.exit(-1);
}
}
|
