1|Page

CHAT APPLICATION
Introduction
Our chat application is a simple yet robust solution designed to facilitate real-time communication between

multiple users. Developed using Java, this application employs socket programming to create a central

server that manages connections from multiple clients (Mishra, T. 2019). Each client can send messages to

the server, which then broadcasts these messages to all other connected clients, ensuring seamless

communication. The user interface is text-based, providing a straightforward and efficient way for users to

input and receive messages. This application exemplifies the fundamental principles of network

programming and client-server architecture, making it an ideal project for understanding the basics of real-

time communication systems.

Chat Server Overview

The chat server is the core component of our application, responsible for managing multiple client

connections and ensuring efficient message distribution. Implemented in Java using socket programming,

the server listens for incoming connections on a specified port and assigns a unique user ID to each client. A

dedicated thread handles communication for each connected client, allowing simultaneous interactions

without blocking. The server maintains a list of active clients and uses a broadcast mechanism to relay

messages from one client to all others. This architecture ensures that the chat experience is real-time and

cohesive, providing a reliable platform for multi-user communication (Maruyama, H. 2002). By efficiently

managing resources and connections, the chat server demonstrates fundamental concepts of concurrent

programming and network communication, making it a valuable learning tool for understanding server-

client dynamics in a distributed environment.

package uoPeopleChatApplication;

import java.io.*;

import java.net.*;

import java.util.*;
2|Page

public class ChatServer {

private static int clientId = 0;

private static Set<ClientHandler> clientHandlers = new HashSet<>();

public static void main(String[] args) {

try (ServerSocket serverSocket = new ServerSocket(12345)) {

System.out.println("Chat server started on port 12345...");

while (true) {

Socket socket = serverSocket.accept();

clientId++;

ClientHandler clientHandler = new ClientHandler(socket, clientId);

clientHandlers.add(clientHandler);

new Thread(clientHandler).start();

} catch (IOException e) {

e.printStackTrace();

}
3|Page

public static void broadcastMessage(String message, ClientHandler sender) {

for (ClientHandler client : clientHandlers) {

if (client != sender) {

client.sendMessage(message);

public static void removeClient(ClientHandler clientHandler) {

clientHandlers.remove(clientHandler);

class ClientHandler implements Runnable {

private Socket socket;

private int clientId;

private PrintWriter out;

public ClientHandler(Socket socket, int clientId) {

this.socket = socket;

this.clientId = clientId;
4|Page

@Override

public void run() {

try {

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

out = new PrintWriter(socket.getOutputStream(), true);

out.println("Welcome! You are user #" + clientId);

String message;

while ((message = in.readLine()) != null) {

System.out.println("User #" + clientId + ": " + message);

ChatServer.broadcastMessage("User #" + clientId + ": " + message, this);

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

socket.close();

} catch (IOException e) {
5|Page

e.printStackTrace();

ChatServer.removeClient(this);

public void sendMessage(String message) {

out.println(message);

Chat Client Overview

The chat client is an essential component that enables users to connect to the server and communicate in

real-time. Each client connects to the server using sockets, ensuring a stable and persistent connection. The

text-based user interface allows users to easily input and send messages, which are then broadcast to all

other connected clients by the server. This setup supports multiple users simultaneously, ensuring a dynamic

and interactive chat environment. The client is designed to handle incoming messages efficiently, displaying

them promptly to the user. By leveraging Java’s socket programming capabilities, the chat client provides a

seamless and responsive communication experience, highlighting the principles of client-server architecture

and multi-threaded programming. This allows for a scalable and robust solution suitable for various real-

time communication needs.

package uoPeopleChatApplication;

import java.io.*;
6|Page

import java.net.*;

public class ChatClient {

private Socket socket;

private BufferedReader in;

private PrintWriter out;

public ChatClient(String serverAddress, int serverPort) {

try {

// Connect to the server

socket = new Socket(serverAddress, serverPort);

// Set up input and output streams

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

out = new PrintWriter(socket.getOutputStream(), true);

// Start a thread to handle incoming messages

new Thread(new IncomingMessagesHandler()).start();

// Read user input from console and send it to the server

BufferedReader keyboardInput = new BufferedReader(new InputStreamReader(System.in));

7|Page

String userInput;

while ((userInput = keyboardInput.readLine()) != null) {

out.println(userInput); // Send message to server

} catch (IOException e) {

e.printStackTrace();

// Inner class to handle incoming messages

private class IncomingMessagesHandler implements Runnable {

@Override

public void run() {

try {

String message;

while ((message = in.readLine()) != null) {

System.out.println(message); // Print incoming messages to console

} catch (IOException e) {

e.printStackTrace();

} finally {
8|Page

try {

socket.close(); // Close socket when done

} catch (IOException e) {

e.printStackTrace();

// Main method to start the client

public static void main(String[] args) {

new ChatClient("localhost", 12345); // Connect to server on localhost and port 12345

User Interface
The user interface of our chat application is designed to be simple, intuitive, and text-based, ensuring ease of

use for users of all levels. Users interact with the application through a console-based interface, where they

can input messages to send and receive messages from other connected users. The interface provides a clean

and minimalist design, focusing on functionality and efficiency.Upon launching the application, users are

greeted with a prompt to input their messages. Messages sent by the user are displayed in real-time, along

with incoming messages from other users. This real-time display ensures seamless communication and

fosters a sense of immediacy in conversations.A sample screenshot of the chat interface is provided below,

showcasing the simplicity and clarity of the user interface design.This user-friendly interface makes our chat
9|Page

application accessible to users across various platforms and devices, providing a seamless communication

experience.

Read me File
Simple Chat Application

This is a simple chat application implemented in Java, consisting of a server and client component. The

server allows multiple clients to connect simultaneously and exchange messages in a chat room-like

environment.

Features

Server:

Listens for incoming connections from clients.

Assigns a unique client ID to each connected client.

Broadcasts messages from one client to all other connected clients, allowing multiple users to chat with each

other.

Client:

Connects to the server using the server's IP address and port number.

Sends messages to the server.

10 | P a g e

Receives messages from the server and displays them in the console.

Usage

Server

Compile the ChatServer.java file: javac uoPeopleChatApplication/ChatServer.java

Run the compiled server class: java uoPeopleChatApplication.ChatServer

Client

Compile the ChatClient.java file: javac uoPeopleChatApplication/ChatClient.java

Run the compiled client class: java uoPeopleChatApplication.ChatClient <server_ip> <server_port>

Replace <server_ip> with the IP address of the server and <server_port> with the port number on which the

server is running (default port is 12345).

Enter messages in the client console to send them to the server and receive messages from other clients.

Important Notes

Make sure the server is running before clients attempt to connect.

Clients must know the IP address and port number of the server to connect successfully.

This application is intended for educational purposes and may not be suitable for production use without

further enhancements (e.g., security features, error handling).

Contributing
11 | P a g e

Contributions are welcome! Feel free to submit issues or pull requests if you have any suggestions for

improvements or bug fixes.

In conclusion, developing a chat application provides a valuable hands-on experience in understanding

network programming concepts and client-server communication protocols. Throughout this project,

developers gain insights into socket programming, threading, and handling concurrent connections. By

building a simple chat application, developers learn how to manage multiple clients, assign unique

identifiers, and facilitate real-time communication over a network. Additionally, this project fosters

collaboration and problem-solving skills, as developers encounter challenges related to synchronization,

error handling, and scalability. Overall, creating a chat application offers a practical opportunity to apply

theoretical knowledge, hone programming skills, and appreciate the complexities involved in designing and

implementing networked systems. Moreover, it serves as a foundational step towards developing more

sophisticated communication platforms and reinforces the importance of clear documentation, testing, and

iterative development practices.

12 | P a g e

References
1. Mishra, T. (2019). Java Based Chat Server.

2. Maruyama, H. (2002). XML and Java: developing Web applications. Addison-Wesley Professional.