package net.codejava.networking.chat.server; import java.io.*; import java.net.*; import java.util.*; /** * This is the chat server program. * Press Ctrl + C to terminate the program. * * @author www.codejava.net */ public class ChatServer { private int port; private Set<String> userNames = new HashSet<>(); private Set<UserThread> userThreads = new HashSet<>(); public ChatServer(int port) { this.port = port; } public void execute() { try (ServerSocket serverSocket = new ServerSocket(port)) { System.out.println("Chat Server is listening on port " + port); while (true) { Socket socket = serverSocket.accept(); System.out.println("New user connected"); UserThread newUser = new UserThread(socket, this); userThreads.add(newUser); newUser.start(); } } catch (IOException ex) { System.out.println("Error in the server: " + ex.getMessage()); ex.printStackTrace(); } } public static void main(String[] args) { if (args.length < 1) { System.out.println("Syntax: java ChatServer <port-number>"); System.exit(0); } int port = Integer.parseInt(args[0]); ChatServer server = new ChatServer(port); server.execute(); } /** * Delivers a message from one user to others (broadcasting) */ void broadcast(String message, UserThread excludeUser) { for (UserThread aUser : userThreads) { if (aUser != excludeUser) { aUser.sendMessage(message); } } } /** * Stores username of the newly connected client. */ void addUserName(String userName) { userNames.add(userName); } /** * When a client is disconneted, removes the associated username and UserThread */ void removeUser(String userName, UserThread aUser) { boolean removed = userNames.remove(userName); if (removed) { userThreads.remove(aUser); System.out.println("The user " + userName + " quitted"); } } Set<String> getUserNames() { return this.userNames; } /** * Returns true if there are other users connected (not count the currently connected user) */ boolean hasUsers() { return !this.userNames.isEmpty(); } }As you can see, the ChatServer class has two Set collections to keep track the names and threads of the connected clients. Set is used because it doesn’t allow duplication and the order of elements does not matter:
private Set<String> userNames = new HashSet<>(); private Set<UserThread> userThreads = new HashSet<>();An important method in the ChatServer class is broadcast() which deliver a message from one client to all others clients:
void broadcast(String message, UserThread excludeUser) { for (UserThread aUser : userThreads) { if (aUser != excludeUser) { aUser.sendMessage(message); } } }The UserThread class is responsible for reading messages sent from the client and broadcasting messages to all other clients. First, it sends a list of online users to the new user. Then it reads the username and notifies other users about the new user.The following code is of the UserThread class:
package net.codejava.networking.chat.server; import java.io.*; import java.net.*; import java.util.*; /** * This thread handles connection for each connected client, so the server * can handle multiple clients at the same time. * * @author www.codejava.net */ public class UserThread extends Thread { private Socket socket; private ChatServer server; private PrintWriter writer; public UserThread(Socket socket, ChatServer server) { this.socket = socket; this.server = server; } public void run() { try { InputStream input = socket.getInputStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(input)); OutputStream output = socket.getOutputStream(); writer = new PrintWriter(output, true); printUsers(); String userName = reader.readLine(); server.addUserName(userName); String serverMessage = "New user connected: " + userName; server.broadcast(serverMessage, this); String clientMessage; do { clientMessage = reader.readLine(); serverMessage = "[" + userName + "]: " + clientMessage; server.broadcast(serverMessage, this); } while (!clientMessage.equals("bye")); server.removeUser(userName, this); socket.close(); serverMessage = userName + " has quitted."; server.broadcast(serverMessage, this); } catch (IOException ex) { System.out.println("Error in UserThread: " + ex.getMessage()); ex.printStackTrace(); } } /** * Sends a list of online users to the newly connected user. */ void printUsers() { if (server.hasUsers()) { writer.println("Connected users: " + server.getUserNames()); } else { writer.println("No other users connected"); } } /** * Sends a message to the client. */ void sendMessage(String message) { writer.println(message); } }Then it enters a loop of reading message from the user and sending it to all other users, until the user sends ‘bye’ indicating he or she is going to quit. And finally it notifies other users about the disconnection of this user and closes the connection.
package net.codejava.networking.chat.client; import java.net.*; import java.io.*; /** * This is the chat client program. * Type 'bye' to terminte the program. * * @author www.codejava.net */ public class ChatClient { private String hostname; private int port; private String userName; public ChatClient(String hostname, int port) { this.hostname = hostname; this.port = port; } public void execute() { try { Socket socket = new Socket(hostname, port); System.out.println("Connected to the chat server"); new ReadThread(socket, this).start(); new WriteThread(socket, this).start(); } catch (UnknownHostException ex) { System.out.println("Server not found: " + ex.getMessage()); } catch (IOException ex) { System.out.println("I/O Error: " + ex.getMessage()); } } void setUserName(String userName) { this.userName = userName; } String getUserName() { return this.userName; } public static void main(String[] args) { if (args.length < 2) return; String hostname = args[0]; int port = Integer.parseInt(args[1]); ChatClient client = new ChatClient(hostname, port); client.execute(); } }The ReadThread is responsible for reading input from the server and printing it to the console repeatedly, until the client disconnects. This class is implemented as follows:
package net.codejava.networking.chat.client; import java.io.*; import java.net.*; /** * This thread is responsible for reading server's input and printing it * to the console. * It runs in an infinite loop until the client disconnects from the server. * * @author www.codejava.net */ public class ReadThread extends Thread { private BufferedReader reader; private Socket socket; private ChatClient client; public ReadThread(Socket socket, ChatClient client) { this.socket = socket; this.client = client; try { InputStream input = socket.getInputStream(); reader = new BufferedReader(new InputStreamReader(input)); } catch (IOException ex) { System.out.println("Error getting input stream: " + ex.getMessage()); ex.printStackTrace(); } } public void run() { while (true) { try { String response = reader.readLine(); System.out.println("\n" + response); // prints the username after displaying the server's message if (client.getUserName() != null) { System.out.print("[" + client.getUserName() + "]: "); } } catch (IOException ex) { System.out.println("Error reading from server: " + ex.getMessage()); ex.printStackTrace(); break; } } } }And the WriteThread is responsible for reading input from the user and sending it to the server, continuously until the user types ‘bye’ to end the chat. This class is implemented as follows:
package net.codejava.networking.chat.client; import java.io.*; import java.net.*; /** * This thread is responsible for reading user's input and send it * to the server. * It runs in an infinite loop until the user types 'bye' to quit. * * @author www.codejava.net */ public class WriteThread extends Thread { private PrintWriter writer; private Socket socket; private ChatClient client; public WriteThread(Socket socket, ChatClient client) { this.socket = socket; this.client = client; try { OutputStream output = socket.getOutputStream(); writer = new PrintWriter(output, true); } catch (IOException ex) { System.out.println("Error getting output stream: " + ex.getMessage()); ex.printStackTrace(); } } public void run() { Console console = System.console(); String userName = console.readLine("\nEnter your name: "); client.setUserName(userName); writer.println(userName); String text; do { text = console.readLine("[" + userName + "]: "); writer.println(text); } while (!text.equals("bye")); try { socket.close(); } catch (IOException ex) { System.out.println("Error writing to server: " + ex.getMessage()); } } }The reasons for running these two threads simultaneously is that the reading operation always blocks the current thread (both reading user’s input from command line and reading server’s input via network). That means if the current thread is waiting for the user’s input, it can’t read input from the server.Therefore, two separate threads are used to make the client responsive: it can display messages from other users while reading message from the current user.That’s how the chat application is designed. For more details, you can read the comments in the source code provided. But there are no many comments because the code is self-explanatory.
java ChatServer 8989This starts the server listening on the port number 8989, and you see the following output in the server once it started:
Chat Server is listening on port 8989The server is waiting for new clients forever, so you have to press Ctrl + C to terminate it.
java ChatClient localhost 8989This tells the client to connect to the server at localhost on port 8989. Then you see the following message in the server’s console:
New user connectedAnd in the client’s console:
Connected to chat server No other users connectedYou see, the server tells the client how many users are connected, but there’s no user at this time. Then the program asks for the username:
Enter your name:_Enter a username, say John, and then you can start chatting:
Enter your name: John [John]:_Now, let’s start the second client with username is Peter. At this time, you see the server tells that there’s one online user is John:
Connected users: [John]The user John is notified about new user Peter:
New user connected: PeterType some messages from John and Peter and you see each user sees other’s messages, just like talking in a chat room.Now, John wants to quit so he types ‘bye’- the client program terminates, and you see the following output in the server’s console:
The user John quittedPeter also gets a message from the server:
John has quitted.That’s basically how the chat application is running. You can test it with more clients and the application is still running smoothly. The following screenshot illustrates a test with 4 clients:Now, it’s your time to play around with this chat application with the source code attached.