Building Client-Server Applications

Client-server architecture is the foundation of modern applications like web apps, APIs, chat systems, and enterprise software. In Java, you can build powerful client-server systems using sockets and networking APIs.

This guide will help you understand how to design, implement, and handle real-world client-server communication step by step.

What is a Client-Server Application?

A client-server application is a system where:

• Client → Sends request
• Server → Processes request and sends response

In simple words: Client asks for data → Server provides data

Example: A web browser (client) requests a webpage, and the web server responds with HTML content.

Designing a Client-Server System

Before writing code, it’s important to design how your system will work.

Key Components

• Client Application
  • Sends requests
  • Receives responses
• Server Application
  • Listens for requests
  • Processes business logic
  • Sends responses
• Communication Protocol
  • TCP (reliable and ordered communication)
  • UDP (fast but less reliable)

Basic Architecture

Client  →  Server
Request → Processing → Response

Example

• Client sends: "Get user data"
• Server processes request and retrieves data
• Server responds: "User data returned"

Request-Response Flow

Understanding the flow is very important.

Step-by-Step Flow

1. Server starts and listens on a specific port
2. Client initiates connection to the server
3. Connection is established between client and server
4. Client sends request data
5. Server receives and reads the request
6. Server processes the request (business logic)
7. Server prepares and sends response
8. Client receives and processes the response
9. Connection is closed after communication completes

Flow Chart

[Start]
   ↓
[Server Starts]
   ↓
[Server Listening on Port]
   ↓
[Client Sends Connection Request]
   ↓
[Connection Established]
   ↓
[Client Sends Request]
   ↓
[Server Receives Request]
   ↓
[Server Processes Request]
   ↓
[Server Sends Response]
   ↓
[Client Receives Response]
   ↓
[Connection Closed]
   ↓
[End]

Java Implementation (Step-by-Step)

Step 1: Create Server

import java.net.*;
import java.io.*;

public class Server {
    public static void main(String[] args) throws Exception {

        ServerSocket server = new ServerSocket(5000);
        System.out.println("Server started...");

        Socket socket = server.accept();
        System.out.println("Client connected");

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

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

        String request = in.readLine();
        System.out.println("Client: " + request);

        // Business logic
        String response = "Hello Client, request received";

        out.println(response);

        socket.close();
        server.close();
    }
}

Explanation

• ServerSocket(5000) → Starts server on port 5000 and listens for connections
• accept() → Waits for client connection (blocking call)
• BufferedReader → Reads data sent by client
• PrintWriter → Sends response back to client
• Business logic → Processes request and prepares response

Step 2: Create Client

import java.net.*;
import java.io.*;

public class Client {
    public static void main(String[] args) throws Exception {

        Socket socket = new Socket("localhost", 5000);

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

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

        // Send request
        out.println("Hello Server");

        // Receive response
        String response = in.readLine();
        System.out.println("Server: " + response);

        socket.close();
    }
}

Explanation

• Socket("localhost", 5000) → Connects to server on given host and port
• out.println() → Sends request data to server
• in.readLine() → Reads response sent by server
• Communication → Client sends request and waits for server response

Output

Client: Hello Server
Server: Hello Client, request received

Example: Mini Client-Server Project

Scenario: Simple Calculator Server

Client sends:

ADD 10 20

Server responds:

Result: 30

👉 Client sends a request containing an operation (ADD) and two numbers. Server reads the request, identifies the operation, performs the calculation, and sends back the final result to the client.

Server Code

import java.net.*;
import java.io.*;

public class CalcServer {
    public static void main(String[] args) throws Exception {

        ServerSocket server = new ServerSocket(6000);
        Socket socket = server.accept();

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

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

        String input = in.readLine();

        String[] parts = input.split(" ");
        String op = parts[0];
        int a = Integer.parseInt(parts[1]);
        int b = Integer.parseInt(parts[2]);

        int result = 0;

        if (op.equals("ADD")) result = a + b;

        out.println("Result: " + result);

        socket.close();
        server.close();
    }
}

Client Code

import java.net.*;
import java.io.*;

public class CalcClient {
    public static void main(String[] args) throws Exception {

        Socket socket = new Socket("localhost", 6000);

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

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

        out.println("ADD 10 20");

        String response = in.readLine();
        System.out.println(response);

        socket.close();
    }
}

Output

Result: 30

Error Handling in Client-Server Applications

Common Issues

• Server not running
• Port already in use
• Network failure
• Invalid input from client

Example with Exception Handling

try {
    Socket socket = new Socket("localhost", 5000);
} catch (IOException e) {
    System.out.println("Connection failed: " + e.getMessage());
}

👉 This handles cases where the client is unable to connect to the server and prevents the program from crashing unexpectedly.

Important Points

• Always wrap network code in try-catch blocks
• Handle IOException properly in both client and server
• Provide meaningful error messages for debugging
• Ensure server availability before client connection

Improving the System (Real-World Practices)

1. Multithreading

To handle multiple clients at the same time:

new Thread(() -> handleClient(socket)).start();

This allows the server to serve multiple clients simultaneously instead of processing one by one.

2. Use Protocol Design

Define a proper message format for communication between client and server:

LOGIN username password
GET_DATA userId

This makes communication structured, readable, and easier to process on the server side.

3. Security Improvements

• Validate all client inputs before processing
• Avoid exposing sensitive data in responses
• Use encryption (HTTPS in real-world applications)

Real-World Use Cases

• Chat applications (WhatsApp, Messenger)
• Banking systems
• REST APIs (Spring Boot backend)
• Multiplayer games
• File transfer systems

Client-server architecture is used in almost every modern application where communication between two systems is required.

Advantages

• Scalable architecture (can handle multiple clients easily)
• Clear separation of client and server responsibilities
• Reusable backend logic across multiple applications
• Supports distributed systems (systems running on different machines)

Limitations

• Requires proper network handling
• Debugging is more complex compared to standalone applications
• Needs strong error handling for stability
• Performance tuning is required for large-scale systems

Common Mistakes to Avoid

• Not closing sockets properly
• Blocking server by handling only one client at a time
• Missing error handling in client/server code
• Hardcoding ports without flexibility
• Ignoring input validation from client requests

Conclusion

Building client-server applications in Java is a core skill for backend development.

• Uses sockets for communication between systems
• Follows a request-response model
• Can be scaled using multithreading for multiple clients
• Forms the base of modern APIs and web systems

👉 Client-server architecture is the foundation of how modern network-based applications work.