Java Chat Program

Creating a Simple, Multithreaded Chat
System with Java

by George Crawford III
Introduction
In this edition of Objective Viewpoint, you will learn how to develop a simple chat system. The
program will demonstrate some key Java programming techniques including I/O, networking,
and multithreading.
Chat System Design

The chat system presented here consists of two classes: ChatServer and ChatHandler. The
ChatServer class is responsible for accepting connections from clients and providing each client
with a dedicated thread for messaging. The ChatHandler is an extension of class Thread. This
class is responsible for receiving client messages and broadcasting those messages to other
clients.
ChatServer Code
Listing 1 shows the code for the ChatServer class. The class has only one method, main(). The
first three lines declare three variables: port, serverSocket, and socket. The port variable
stores the port on which the server will listen for new connections. The default value for the port
in this example is 9800. In the first try/catch block, we determine if the user passed any
parameters. If so, we attempt to parse the first command line parameter (the only one we care
about in this case) using the Integer.parseInt method. If the string does not represent an
integer, then a NumberFormatException will be thrown. The catch block simply specifies
proper program usage and exits.
In the second try/catch block, the chat server attempts to create a new server socket and begin
to accept connections. First, a new ServerSocket object is created with a specific port. The code
then enters an endless loop, continuously accepting connections and creating new chat client
handlers. The ServerSocket.accept() method waits forever until a new connection is
established. When a new connection is detected, a Socket object is created inherently and
returned. A new ChatHandler object is then constructed with the newly created socket. Since the
ChatHandler is a Thread, we must call the start method to make the chat client code run.
If anything goes awry with either the server socket or client socket, an IOException will be
thrown. In this example, we simply print the stack trace. In the finally block, we attempt to
close the server socket connection since the loop has been exited.
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ChatServer {
public static final int DEFAULT_PORT = 9800;
public static void main(String[] args) {
int port = DEFAULT_PORT;
ServerSocket serverSocket = null;
Socket socket = null;
try {
if(args.length > 0)
port = Integer.parseInt(args[0]);
} catch(NumberFormatException nfe) {
System.err.println("Usage: java ChatServer [port]");
System.err.println("Where options include:");
System.err.println("\tport the port on which to listen.");
System.exit(0);
}
try {
serverSocket = new ServerSocket(port);
while(true) {
socket = serverSocket.accept();
ChatHandler handler = new ChatHandler(socket);
handler.start();
}
} catch(IOException ioe) {
ioe.printStackTrace();
} finally {
try {
serverSocket.close();
}
}
}
}
Listing 1: ChatServer Code
ChatHandler Code
The ChatHandler code is shown in Listing 2. In the constructor, we assign the socket the
handler we will use and construct the socket input and output streams. The BufferedReader and
PrintWriter classes are used for handling user I/O. The Reader classes enable proper handling
of bytes and characters. For example, the BufferedReader class method readLine() will
properly convert 8-bit bytes to 16-bit UNICODE characters.
The following line constructs a new BufferedReader object:
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

Since the BufferedReader constructor requires an object of class Reader, we must construct
another reader. Since the Socket.getInputStream() method returns an object of class
InputStream, we must create a new InputStreamReader to capture the socket input stream.
Another advantage of the BufferedReader class besides proper character encoding is character
buffering. Without buffering, the characters would be read one byte at a time, thus crippling
performance.
The construction of the PrintWriter is similar in context to the BufferedReader.
The run method simply captures client input and broadcasts the message to all the other clients.
This process continues until the user sends a "quit" message.
The first few lines synchronize on the static Vector object handlers that contains all the
actively connected clients and adds the current object to the list. It is important to synchronize on
the list, otherwise other threads that are accessing the list concurrently may miss any newly
added clients during a broadcast.
In the try block, we enter a continuous loop which is terminated when either the user sends a
"/quit" message or an exception is thrown. When a message is received, we propogate the
message by iterating through the ChatHandler list and sending the message through the
appropriate handler socket output stream.
If an exception is thrown or the user sends a "/quit" message, we attempt to close the I/O streams
and the socket, and finally remove the current handler from the list.
Listing 2:
// ChatHandler.java
//
import
import
import
import
import
import
import
java.io.BufferedReader;
java.io.InputStreamReader;
java.io.IOException;
java.io.OutputStreamWriter;
java.io.PrintWriter;
java.net.Socket;
java.util.Vector;
public class ChatHandler extends Thread {

static Vector handlers = new Vector( 10 );
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public ChatHandler(Socket socket) throws IOException {
this.socket = socket;
in = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(

new OutputStreamWriter(socket.getOutputStream()));
}
public void run() {
String line;
synchronized(handlers) {
handlers.addElement(this);
// add() not found in Vector class
}
try {
while(!(line = in.readLine()).equalsIgnoreCase("/quit")) {
for(int i = 0; i < handlers.size(); i++) {
ChatHandler handler =
(ChatHandler)handlers.elementAt(i);
handler.out.println(line + "\r");
handler.out.flush();
}
}
}
} finally {
try {
in.close();
out.close();
socket.close();
} finally {
handlers.removeElement(this);
}
}
}
}
}
Editor's Note: Many thanks to Dick Seabrook for finding and correcting some errors in the
above code listing 2.
Running The Program

To run the server, simply enter the following line at a command prompt:
java ChatServer
The above will open a socket on the default port. Alternatively, you can specify a port like so:
java ChatServer 7900
Also, if you are on a UNIX machine, append an "&" to the above command line so that the
server runs in a background process.
Use telnet to connect to the server. For example:

telnet machine.somewhere.net 9800
Summary
In this article, you learned how to use the standard Java networking and I/O classes, and also
how to handle concurrent I/O safely using threads. As an exercise, try creating a chat GUI, and
also expand the current programs to include identifiable users and user groups.

Java Chat Program

Uploaded by

Java Chat Program

Uploaded by

Creating a Simple, Multithreaded Chat

System with Java

Chat System Design

Listing 1: ChatServer Code

in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

public class ChatHandler extends Thread {

out = new PrintWriter(

Running The Program

Use telnet to connect to the server. For example:

You might also like