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

Server starts and listens on a specific port
Client initiates connection to the server
Connection is established between client and server
Client sends request data
Server receives and reads the request
Server processes the request (business logic)
Server prepares and sends response
Client receives and processes the response
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.