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

Feature	ServerSocket	Socket
Usage Side	Used on server side	Used on client side
Role	Waits for and accepts client connections	Connects to server and communicates
Main Purpose	Listens for incoming connection requests	Sends and receives data
Key Method	accept()	connect(), getInputStream(), getOutputStream()
Connection Start	Passively waits for client	Actively initiates connection
Data Transfer	Does not transfer data directly	Handles data transmission

---

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.