Simple 2-Way Chat with Java

In this post, I'm going to discuss how to create a simple chat application with Java. Basically, this is going to be a tutorial on Socket API and Java Thread API.

Here is the basic idea. A chat class should be running two tasks simultaneously: one is to send messages that the user inputs, and the other is to receive incoming message from the other side. Because these two tasks should be run simultaneously, we will need to implement a multi-threaded application.

I am going to let the main thread take care of user input and transmitting over to the other side, and a separate thread for receiving any incoming messages. Here we go.

	import java.io.PrintWriter;
	import java.net.Socket;
	import java.util.Scanner;
	public class ChatThread extends Thread {
	private Socket socket = null;
	private Scanner inputStream = null;
	private String name = null;
	/**
	* Socket must be already connected
	*
	* @param socket
	* @param name
	*/
	public ChatThread(Socket socket, String name) throws Throwable {
	super(name);
	setSocket(socket);
	inputStream = new Scanner(socket.getInputStream());
	}
	public void run() {
	while (inputStream.hasNext()) {
	String inputString = inputStream.nextLine();
	System.out.println(inputString);
	}
	try {
	if (socket != null) socket.close();
	if (inputStream != null) inputStream.close();
	} catch (Throwable t) {
	System.out.println(t.getMessage());
	}
	}
	private void setSocket(Socket socket) throws Throwable {
	if (socket == null) throw new Throwable("invalid socket");
	if (!socket.isConnected()) throw new Throwable("socket not connected");
	this.socket = socket;
	}
	public void startChat() throws Throwable {
	this.start(); // receive incoming messages
	PrintWriter outputStream = new PrintWriter(socket.getOutputStream());
	Scanner keyboard = new Scanner(System.in);
	while (keyboard.hasNext()) {
	String msg = keyboard.nextLine();
	outputStream.println(msg);
	outputStream.flush();
	}
	socket.close();
	keyboard.close();
	outputStream.close();
	}
	public static void main(String[] args) {
	if (args.length != 2) {
	System.out.println("Usage: java ChatThread server_address port");
	} else {
	try {
	Socket socket = new Socket(args[0], Integer.parseInt(args[1]));
	ChatThread t = new ChatThread(socket, "client");
	t.startChat();
	} catch (Throwable t) {
	System.out.println(t.getMessage());
	}
	}
	}
	}

view raw ChatThread.java hosted with ❤ by GitHub

	import java.net.ServerSocket;
	import java.net.Socket;
	public class Server {
	private ChatThread chatThread = null;
	private ServerSocket serverSocket = null;
	private Socket socket = null;
	public Server(String name, int port) {
	try {
	serverSocket = new ServerSocket(port);
	System.out.println("waiting for a client...");
	socket = serverSocket.accept();
	System.out.println("client connected");
	chatThread = new ChatThread(socket, name);
	chatThread.startChat();
	} catch (Throwable t) {
	System.out.println(t.getMessage());
	}
	}
	public static void main(String[] args) {
	if (args.length != 1) {
	System.out.println("Usage: java Server port");
	} else {
	new Server("server", Integer.parseInt(args[0]));
	}
	}
	}

view raw Server.java hosted with ❤ by GitHub

So, the base class is ChatThread, which pretty much takes care of what I described above. The main thread takes care of user input and transmitting over to the other side, whereas a separate thread is going to run in the background, which receives incoming messages.

For this 2-way simple application, there are only two sides: one for server and the other for client. The server needs to take care of creating the server socket and wait for a client to join. Once the client joins, the server starts the ChatThread. The client will simply join the server and start the chatThread.

The implementation here is very basic and doesn't take care of properly exiting the connections. However, this should give you good introduction as to how to deal with socket programming and threading.

Happy hacking!