Skip to content
Implement multi-client support in a socket-based Java chat application using threads.Allow clients to enter a username, which will be used to identify them in the chat.Broadcast messages from one client to all connected clients, simulating a group chat.
Share
Explore
Lab Workbook: Building the Chat Server with Java J2EE
Lab 1: Socket Programming - Foundation for Distributed Systems
Preamble: The Journey to Enterprise Java
Welcome to CSD-4464! This course charts an exciting journey through the evolution of distributed systems, starting with the foundational building blocks and progressing to enterprise-grade architectures.
Think of it as climbing a mountain of abstraction - each layer building upon the previous one to create increasingly powerful and flexible systems.
The Knowledge Lineage
In this course, we'll traverse five crucial layers of distributed computing:
1. **Sockets** (Where we are now) - The fundamental communication channel between networked processes
2. **Remote Method Invocation (RMI)** - Object-oriented abstraction over network communication
3. **JSP/JSF with Servlets** - Web-centric presentation and processing
4. **Enterprise JavaBeans (EJB)** - Component-based business logic and transaction management
5. **JAX Web Services** - Platform-independent service-oriented architecture
Once we get here, we will fold on JPA Java Persistance Architecture by connecting to a MySQL database and build a complete MVC application.
We begin with sockets because they represent the raw essence of network communication - the ability for two processes to exchange information across a network. Understanding sockets provides crucial insights into how all higher-level abstractions ultimately work.
Why This Progression Matters
Modern enterprise applications are built using JAX-RS (REST) or JAX-WS (SOAP) web services, but these sophisticated frameworks abstract away the underlying network communication.
By starting with sockets, you'll gain a deep understanding of:
- How distributed systems fundamentally communicate
- The challenges of network programming (latency, failures, concurrency)
- Why higher-level abstractions are valuable
- The trade-offs between simplicity and power at each layer
### Our Development Environment
We'll use a minimalist but powerful toolkit:
- MySQL for persistence
- GlassFish as our Java EE application server
- Sublime Text as our editor
We've chosen Sublime Text over more complex IDEs to maintain focus on the core concepts rather than IDE-specific workflows. This approach ensures you understand the fundamental principles without the overhead of learning complex tool chains.
## Lab 1 Instructions
### Objective
Create a multi-client chat application using Java sockets, demonstrating fundamental network programming concepts and laying the groundwork for understanding distributed systems.
### Requirements
1. **Server Implementation (40 points)**
- Create a server that accepts multiple client connections
- Implement thread management for concurrent client handling
- Maintain a list of connected clients
- Properly handle client disconnections
2. **Client Implementation (30 points)**
- Implement connection to server
- Handle user input and server messages concurrently
- Provide clean shutdown mechanism
- Display appropriate status messages
3. **Protocol Implementation (20 points)**
- Define clear message format for client-server communication
- Implement user identification mechanism
- Handle broadcast messages
- Manage connection/disconnection messages
4. **Code Quality (10 points)**
- Clear documentation and comments
- Proper exception handling
- Clean code organization
- Following Java naming conventions
### Deliverables
1. **Source Code**
- Server.java
- Client.java
- Any additional utility classes
- README.md explaining how to run your application
2. **Documentation**
- Brief design document explaining your implementation choices
- Protocol specification
- Known limitations or issues
3. **Test Results**
- Screenshots showing multiple clients connected
- Evidence of proper message broadcasting
- Demonstration of graceful error handling
### Submission Guidelines
1. Create a ZIP file containing all deliverables
2. Name the file: `Lab1_StudentID_LastName.zip`
3. Submit through the designated course submission system
4. Ensure all code is properly commented and formatted
## Grading Rubric
### Server Implementation (40 points)
- Multi-client support (15 points)
- Excellent: Handles multiple clients flawlessly with proper thread management
- Good: Handles multiple clients with minor issues
- Fair: Basic multi-client support with significant limitations
- Poor: Single client only or major issues
- Connection Management (15 points)
- Excellent: Robust handling of connections/disconnections
- Good: Proper connection management with minor issues
- Fair: Basic connection management with some bugs
- Poor: Unreliable connection management
- Error Handling (10 points)
- Excellent: Comprehensive error handling and recovery
- Good: Most error cases handled appropriately
- Fair: Basic error handling
- Poor: Minimal or no error handling
### Client Implementation (30 points)
- User Interface (10 points)
- Excellent: Clear, intuitive interface with status updates
- Good: Functional interface with basic status information
- Fair: Basic interface with minimal feedback
- Poor: Confusing or broken interface
- Message Handling (10 points)
- Excellent: Smooth message sending/receiving with proper threading
- Good: Reliable message handling with minor issues
- Fair: Basic message handling with some bugs
- Poor: Unreliable message handling
- Resource Management (10 points)
- Excellent: Proper cleanup of resources, graceful shutdown
- Good: Most resources properly managed
- Fair: Basic resource management
- Poor: Resource leaks or improper cleanup
### Protocol Implementation (20 points)
- Message Format (10 points)
- Excellent: Well-defined, efficient protocol
- Good: Clear protocol with minor inconsistencies
- Fair: Basic protocol with some issues
- Poor: Poorly defined or inconsistent protocol
- Feature Support (10 points)
- Excellent: All required features implemented properly
- Good: Most features implemented with minor issues
- Fair: Basic feature implementation
- Poor: Missing key features
### Code Quality (10 points)
- Documentation (4 points)
- Excellent: Comprehensive, clear documentation
- Good: Adequate documentation with minor gaps
- Fair: Basic documentation
- Poor: Minimal or unclear documentation
- Code Organization (3 points)
- Excellent: Well-organized, modular code
- Good: Mostly organized code with some issues
- Fair: Basic organization
- Poor: Poor organization or structure
- Coding Standards (3 points)
- Excellent: Follows all Java conventions
- Good: Mostly follows conventions
- Fair: Some adherence to conventions
- Poor: Ignores conventions
## Mapping to Course Learning Outcomes
This lab specifically addresses the following course learning outcomes:
1. CLO 1.1: Configure and use testing frameworks
- Implementation of basic testing for network communication
2. CLO 1.4: Implement source-control techniques
- Organization and submission of code demonstrates version control practices
3. CLO 2.6: Utilize functional programming paradigm
- Use of lambda expressions for thread handling
4. CLO 3.3: Manage network requests
- Direct implementation of socket-based communication
5. CLO 3.9: Implement contexts and dependency injection
- Basic introduction through socket connection management
Remember: This lab sets the foundation for understanding how distributed systems communicate at their most basic level. The skills you develop here will be crucial as we progress to more sophisticated architectures in subsequent labs.
Introduction
In Java, services are enabled by PORTS.
A Service is a METHOD CALL.
Calling a Method on a REMOTE JVM? You will be connect to the PORT in that REMOTE JVM for that METHOD.
HAND IN: A word Document with all code and screen shots demonstrating the successfuly operation of this illustration of how Java Sockets work, uploaded to the Moodle Assigment Page.
Due December 15.
Preamble: From Sockets to SOAP-Based Web Services
In this lab, you will build a fundamental networking application—a simple chat program using Java sockets.
This exercise introduces core concepts of object communication where the objects live in different JVMs connected by TCP/IP network.
Understanding how data flows between a client and server in this low-level setting is essential as we progress towards more advanced technologies like **Remote Method Invocation (RMI)** and **SOAP-based web services**.
Socket programming allows us to establish direct, low-level connections between systems, enabling real-time data exchange.
While this is effective for small, simple applications, real-world systems often require more sophisticated, robust, and scalable solutions.
As we move up the abstraction ladder, RMI will introduce the concept of calling methods on remote objects as if they were local, simplifying the complexity of network communication. Building on this, SOAP (Simple Object Access Protocol) offers a standardized, XML-based framework for exchanging structured data over a network, suitable for large-scale, distributed applications.
By learning socket communication first, you'll gain a deeper appreciation of how high-level web services—such as SOAP—are built on the same fundamental principles of client-server interaction.
SOAP services, unlike socket-based programs, add essential features such as platform independence, language-agnostic communication, and standardized messaging, all of which are vital for modern enterprise-level distributed applications.
This lab sets the foundation for that journey, connecting the dots from basic networking to sophisticated J2EE web services architecture.
Lesson 1: Introduction to Java Networking with Sockets
Welcome to your journey towards understanding J2EE web services!
In this initial step, we will lay the foundation by exploring a simple concept: a **socket-based chat application**.
This will help you grasp the basics of how text messages can be sent between computers over a TCP/IP connection, setting the stage for more advanced topics like Remote Method Invocation (RMI) in future lessons.
---
### **Objective**
By the end of this lesson, you will:
1. Understand the concept of sockets and how they enable communication between two systems.
2. Implement a simple Java socket-based chat application.
3. Gain an appreciation of how TCP/IP networking underpins higher-level services like web services in J2EE.
---
### **Prerequisites**
- Basic understanding of Java SE.
- Familiarity with input/output streams, basic Java programming, and threads.
---
### **Tools Required**
- **Java Development Kit (JDK)** (preferably version 11 or above).
- Any Java Integrated Development Environment (IDE) such as Eclipse, IntelliJ IDEA, or NetBeans.
Concept Overview**
What are Sockets?
In networking, a **socket** is one endpoint of a two-way communication link between two programs running on a network.
It is bound to a port number so that the Transmission Control Protocol (TCP) layer can identify the application that data is destined for.
In simpler terms, sockets allow two computers (or programs) to "talk" to each other over the internet or a local network.
How Sockets Work A socket connection is established as follows:
1. **Server**: Waits for a client to connect.
2. **Client**: Initiates a connection to the server.
3. **Connection Established**: The server and client can now send and receive data.
4. **Data Transfer**: The client and server exchange messages (data).
5. **Close**: The connection is terminated when either side decides to close the socket.
This socket-to-socket communication forms the basis of many modern-day Internet applications, such as chat apps, file transfer systems, and even web services.
---
Step-by-Step Instructions
Step 1: Create the Server
First, we will create the server-side of the chat application. The server will wait for a connection from the client and, once connected, will facilitate the exchange of messages.
import java.io.*;
import java.net.*;
public class ChatServer {
private ServerSocket serverSocket;
private Socket clientSocket;
private PrintWriter out;
private BufferedReader in;
public void start(int port) {
try {
serverSocket = new ServerSocket(port);
System.out.println("Server started. Waiting for a client...");
clientSocket = serverSocket.accept(); // Wait for a client to connect
System.out.println("Client connected.");
// Streams for sending and receiving messages
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("Client: " + inputLine);
if ("exit".equalsIgnoreCase(inputLine)) {
out.println("Goodbye!");
break;
}
out.println("Server: " + inputLine);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
stop();
}
}
public void stop() {
try {
in.close();
out.close();
clientSocket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ChatServer server = new ChatServer();
server.start(6666); // Use port 6666 for communication
}
}
#### **Step 2: Create the Client**
Now, let's create the client-side of the application. The client will initiate the connection and then send and receive messages from the server.
```java
import java.io.*;
import java.net.*;
public class ChatClient {
private Socket socket;
private PrintWriter out;
private BufferedReader in;
public void start(String ip, int port) {
try {
socket = new Socket(ip, port); // Connect to the server
System.out.println("Connected to the server.");
out = new PrintWriter(socket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
String userInput;
System.out.println("Type your message (type 'exit' to quit):");
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput); // Send user input to server
System.out.println(in.readLine()); // Receive and print server's response
if ("exit".equalsIgnoreCase(userInput)) {
break;
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
stop();
}
}
public void stop() {
try {
in.close();
out.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ChatClient client = new ChatClient();
client.start("127.0.0.1", 6666); // Connect to localhost on port 6666
}
}
```
---
### **Step 3: Run the Application**
1. **Run the Server**:
- Compile and run the `ChatServer` class.
- The server will start and wait for a client to connect.
2. **Run the Client**:
- In a separate terminal or IDE instance, compile and run the `ChatClient` class.
- The client will connect to the server and begin sending messages.
3. **Exchange Messages**:
- The client and server can now exchange messages. Type a message in the client and see it appear in the server's console, and vice versa.
---
### **Key Concepts**
- **Sockets**: Provide communication between two machines using TCP/IP.
- **Input/Output Streams**: Enable reading from and writing to sockets.
- **Threading**: In a more complex version, we could use threads to handle multiple clients simultaneously, but for now, we'll stick to a single client-server setup.
---
### **Exercise: Extend the Application**
To solidify your understanding, try the following:
- **Multiple Clients**: Modify the server to handle multiple clients simultaneously using threads.
- **Enhanced Messaging**: Add features like message formatting or user nicknames.
- **Error Handling**: Improve the robustness of your application by handling various exceptions.
---
### **Conclusion**
By implementing this simple socket-based chat application, you now have a solid foundation in Java networking. In the next lesson, we will build on this concept to explore Remote Method Invocation (RMI) and eventually move towards J2EE web services.
This step-by-step approach ensures that by the time we reach the complexities of J2EE, you will have a clear understanding of how lower-level networking concepts like sockets play a role in high-level web services.
Multi-client Chat
Lab Update: Adding Multi-Client Support with User Identification
We will now extend the previous socket-based chat application to allow multiple clients to connect simultaneously.
Each client will enter a username upon connection, which will be used to identify them in the chat.
The server will manage multiple client connections by utilizing threads, allowing for concurrent communication between several clients.
Updated Objective
By the end of this lesson, you will:
Step 1: Modify the Server for Multi-Client Support
To handle multiple clients, the server needs to spawn a new thread for each incoming client connection.
This way, multiple clients can interact with the server simultaneously.
import java.io.*;
import java.net.*;
import java.util.*;
public class ChatServer {
private ServerSocket serverSocket;
private Set<ClientHandler> clientHandlers = new HashSet<>();
public void start(int port) {
try {
serverSocket = new ServerSocket(port);
System.out.println("Server started. Waiting for clients...");
while (true) {
Socket clientSocket = serverSocket.accept();
ClientHandler clientHandler = new ClientHandler(clientSocket, this);
clientHandlers.add(clientHandler);
new Thread(clientHandler).start(); // Start a new thread for each client
System.out.println("New client connected.");
}
} catch (IOException e) {
e.printStackTrace();
}
}
public synchronized void broadcastMessage(String message, ClientHandler sender) {
for (ClientHandler clientHandler : clientHandlers) {
if (clientHandler != sender) { // Send to all except the sender
clientHandler.sendMessage(message);
}
}
}
public synchronized void removeClient(ClientHandler clientHandler) {
clientHandlers.remove(clientHandler);
}
public static void main(String[] args) {
ChatServer server = new ChatServer();
server.start(6666); // Use port 6666 for communication
}
}
class ClientHandler implements Runnable {
private Socket socket;
private PrintWriter out;
private BufferedReader in;
private String username;
private ChatServer server;
public ClientHandler(Socket socket, ChatServer server) {
this.socket = socket;
this.server = server;
}
@Override
public void run() {
try {
// Setup I/O streams
out = new PrintWriter(socket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// Ask the client for a username
out.println("Enter your username:");
username = in.readLine();
System.out.println(username + " has joined the chat.");
server.broadcastMessage(username + " has joined the chat.", this);
Want to print your doc?
This is not the way.
This is not the way.
Try clicking the ··· in the right corner or using a keyboard shortcut (
CtrlP
) instead.