Socket Programming in Java

Socket programming is the foundation of network communication in Java. It allows applications to communicate over a network using the client-server model.

It is widely used in real-world applications like chat systems, file transfer, and web communication.

In this guide, you will learn how TCP sockets work, how to build a client-server application, and how data is exchanged between systems.

What is Socket Programming?

A socket is an endpoint of communication between two systems over a network.

In simple words: It is like a connection between two computers through which data is sent and received.

Conceptual Example

• Client sends request
• Server receives request
• Server processes and sends response
• Client receives response

👉 Example: Chat application (real-time messaging)

Code Example (Basic Connection)

import java.net.Socket;

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

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

        System.out.println("Connection established");

        socket.close();
    }
}

👉 Shows how a client connects to a server

TCP Communication Flow

TCP (Transmission Control Protocol) is a reliable, connection-oriented protocol used for communication between client and server over a network.

In simple words: TCP ensures that data is sent safely, in order, and without loss between two systems.

Flow

Client → Request Connection → Server Accepts
Client → Send Data → Server
Server → Process → Respond
Connection Closed

Key Features

• Ensures data delivery
• Maintains order of data packets
• Detects and handles errors
• Provides reliable communication

👉 Used in web apps, APIs, file transfer, email

ServerSocket vs Socket

Creating TCP Server

Steps

1. Create ServerSocket
2. Wait for client
3. Get streams
4. Read & send data
5. Close connection

Server Code

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

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

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

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

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

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

            String msg = br.readLine();
            System.out.println("Client: " + msg);

            pw.println("Hello from Server");

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

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Explanation

• ServerSocket(5000) → Server starts and listens on port 5000
• accept() → Waits until a client connects (blocking call)
• getInputStream() → Receives data from client
• getOutputStream() → Sends data to client
• readLine() → Reads message sent by client
• println() → Sends response back to client
• socket.close() → Closes client connection
• server.close() → Stops the server

👉 The server waits for a client, reads a message, sends a response, and then closes the connection

Creating TCP Client

Steps

1. Create Socket
2. Connect to server
3. Get streams
4. Send & receive data
5. Close connection

Client Code

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

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

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

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

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

            pw.println("Hello Server");

            String response = br.readLine();
            System.out.println("Server: " + response);

            socket.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Explanation

• Socket("localhost", 5000) → Connects to server running on port 5000
• getOutputStream() → Used to send data to server
• println() → Sends message to server
• getInputStream() → Receives data from server
• readLine() → Reads response sent by server
• socket.close() → Closes the connection

👉 The client connects to the server, sends a message, receives a response, and then closes the connection

Data Streams (InputStream / OutputStream)

Sockets use streams to exchange data between client and server.

InputStream

• Used to read data coming from socket
• Example: getInputStream()

In simple words: It receives data sent by the other side.

OutputStream

• Used to send data to socket
• Example: getOutputStream()

In simple words: It sends data to the other side.

Common Wrappers

• BufferedReader → Reads text efficiently (line by line)
• PrintWriter → Sends text easily
• DataInputStream → Reads binary data (like int, float, etc.)

👉 These wrappers make socket communication simple and readable

Example

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

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

Example: Simple Client-Server Chat Application

This example enables continuous two-way communication.

Server

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

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

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

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

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

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

        String msg;

        while ((msg = in.readLine()) != null) {
            System.out.println("Client: " + msg);

            String reply = userInput.readLine();
            out.println(reply);
        }

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

Explanation (Server)

• ServerSocket(5000) → Server starts on port 5000
• accept() → Waits for client connection
• in.readLine() → Reads message from client
• userInput.readLine() → Takes input from server console
• out.println() → Sends response to client
• Loop runs until client disconnects

Client

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

public class ChatClient {
    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);

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

        while (true) {
            String msg = userInput.readLine();
            out.println(msg);

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

Explanation (Client)

• Connects to server using Socket("localhost", 5000)
• Reads user input from console
• Sends message using out.println()
• Receives server response using in.readLine()
• Runs continuously for real-time chat

Real-World Use Cases

• Chat applications
• File transfer systems
• Client-server applications
• Online gaming (reliable parts like login, scoring, matchmaking)
• Web servers

👉 TCP sockets are used wherever reliable and structured communication is required between systems.

Advantages of TCP Sockets

• Reliable communication (data loss is handled)
• Ordered data transfer (data arrives in correct sequence)
• Error detection & recovery (corrupted packets are re-sent)
• Data integrity (ensures complete and correct data delivery)

Limitations

• Slower than UDP due to reliability checks
• Requires connection setup before communication starts
• Higher overhead because it maintains connection state and ensures delivery

Conclusion

Socket programming is a core concept in Java networking.

• Uses TCP for reliable communication
• Based on client-server architecture
• Uses streams for data exchange

👉 Socket programming enables two systems to communicate over a network by sending and receiving data in a structured way.