Server Socket in Java

In Java, ServerSocket can be defined as a type of class which is majorly utilized for providing implementation of the server-side socket connection of client or server. Also, the socket connection of the client or client is fully independent of system.

Let us understand about ServerSocket class in Java in detail.

ServerSocket Class in Java

An exception is being throwed by the ServerSocket by the constructor when it is not able to listen on the required port (For instance, when the port is already is being used). In other words, server sockets can also be considered as major components that are utilized in network programming, for enabling communication among applications of client and server through a network.

A server-side endpoint is represented by a server socket whose main purpose is to listen for connections regarding incoming connections of client. The java.net class contains the ServerSocket class and it is provided by the Java for the implementation of server sockets.

For the successful creation of a server socket connection in Java, an instance or object of the ServerSocket class must be definitely created, and a port number is specified along with a backlog parameter which is optional. The main purpose of a port number is to specify and identify the server socket which is present on the machine. The backlog parameter is majorly utilized for determining the maximum number of connections which are pending that are present in the queue of the server's connection.

Upon the successful creation of the server socket, it is eligible to enter the listening state, where it waits for the incoming requests of connection from the clients. The main purpose of accept() method of the ServerSocket class is to accept and establish a connection with the client. A new object of the Socket class is returned whenever a connection request is received. The Socket object is utilized for representing the channel of communication that occurs with the client.

After successful acceptance of the connection with the client, both input and output streams can be obtained by the server from the Socket object for communicating with the client. The mutual exchange of data between the server and client connected is done utilizing the streams of input and output.

Let's understand about ServerSocket in Java in detail with the help of a Java example program.

Example 1:

Filename: ServerSocketExample.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerSocketExample {
    public static void main(String[] args) {
        // The port number on which the server will listen for connections
        final int portNumber = 5555;
        try {
            // Create a ServerSocket that will listen on the specified port
            ServerSocket serverSocket = new ServerSocket(portNumber);
            System.out.println("Server is listening on port " + portNumber);
            // Infinite loop to keep the server running and accepting connections
            while (true) {
                // Accept a client connection and get the corresponding Socket object
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress().getHostAddress());
                // Create a new thread (ServerClientHandler) for each client to handle communication
                ServerClientHandler clientHandler = new ServerClientHandler(clientSocket);
                new Thread(clientHandler).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private static class ServerClientHandler implements Runnable {
        private Socket clientSocket;
        // Constructor to initialize the clientSocket
        public ServerClientHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }
        // The run method that is executed when the thread starts
        @Override
        public void run() {
            try (
                    // Create a BufferedReader to read data from the client
                    BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                    // Create a PrintWriter to send data to the client
                    PrintWriter writer = new PrintWriter(clientSocket.getOutputStream(), true)) {
                String inputLine;
                // Read messages from the client as long as they are not null
                while ((inputLine = reader.readLine()) != null) {
                    System.out.println("Received from client: " + inputLine);
                    // Echo the message back to the client with a "Server:" prefix
                    writer.println("Server: " + inputLine);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    // Close the client socket when the communication is finished
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Output:

Server is listening on port 5555

Example 2:

Filename: AdvancedJavaServerSocket.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class AdvancedJavaServerSocket {
    private static final int PORT = 5555;
    private static final int MAX_THREADS = 10;
    private static ExecutorService threadPool = Executors.newFixedThreadPool(MAX_THREADS);
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("Server is listening on port " + PORT);
            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress().getHostAddress());
                // Use a thread from the pool to handle each client
                threadPool.execute(new ClientHandler(clientSocket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private static class ClientHandler implements Runnable {
        private Socket clientSocket;
        public ClientHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }
        @Override
        public void run() {
            try (
                    BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                    PrintWriter writer = new PrintWriter(clientSocket.getOutputStream(), true)
            ) {
                String inputLine;
                // Perform authentication (e.g., a simple username/password check)
                writer.println("Server: Please enter your username:");
                String username = reader.readLine();
                // In a real-world scenario, you'd validate the username and password securely
                if (isValidUser(username)) {
                    writer.println("Server: Authentication successful. Welcome, " + username + "!");
                } else {
                    writer.println("Server: Authentication failed. Disconnecting...");
                    return;
                }
                // Read messages from the client as long as they are not null
                while ((inputLine = reader.readLine()) != null) {
                    System.out.println("Received from " + username + ": " + inputLine);
                    // Process commands or echo the message back to the client
                    if (inputLine.equalsIgnoreCase("exit")) {
                        writer.println("Server: Goodbye, " + username + "!");
                        break;
                    } else {
                        writer.println("Server: You said: " + inputLine);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        private boolean isValidUser(String username) {
            // In a real-world scenario, you'd check against a database or some secure mechanism
            return username != null && !username.trim().isEmpty();
        }
    }
}

Output:

Server is listening on port 5555

Example 3:

Filename: ServerSocketExample.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ServerSocketExample {
    private static final int PORT = 5555;
    private static final int MAX_THREADS = 10;
    private static ExecutorService threadPool = Executors.newFixedThreadPool(MAX_THREADS);
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("Server is listening on port " + PORT);
            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress().getHostAddress());
                // Use a thread from the pool to handle each client
                threadPool.execute(new ClientHandler(clientSocket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private static class ClientHandler implements Runnable {
        private Socket clientSocket;
        public ClientHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }
        @Override
        public void run() {
            try (
                    BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                    PrintWriter writer = new PrintWriter(clientSocket.getOutputStream(), true)) {
                String inputLine;
                // Read messages from the client as long as they are not null
                while ((inputLine = reader.readLine()) != null) {
                    System.out.println("Received from client: " + inputLine);
                    // Process commands or echo the message back to the client
                    if (inputLine.equalsIgnoreCase("exit")) {
                        writer.println("Server: Goodbye!");
                        break;
                    } else {
                        writer.println("Server: You said: " + inputLine);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    clientSocket.close();
                    System.out.println("Client disconnected");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
} 

Output:

Server is listening on port 5555

Let's understand about the methods of Server socket in Java and their functionalities in detail.

Methods of Server Socket in Java

There are various methods of Server Socket in Java and let us understand about their features, purpose and functionality in detail.

Method	Description
ServerSocket (int i)	This method is used for constructing a new ServerSocket on the required and specific port.
ServerSocket( int I , int B)	This method is used for creating a new ServerSocket on the required port with the required backlog which is used for representing the maximum number of connections queued.
accept()	This method is used for listening for a connection that needs to be made for this socket and accepts that. Until a new connection is made, the method blocks.
bind( SocketAddress S)	This method is used for binding the ServerSocket to a required network address.
close()	This method is used for closing the ServerSocket. Any accept operations that are blocked will be thrown a SocketException.
getInetAddress()	This method gets the local address where the socket is bound currently.
getLocalPort()	This method fetches the local port where the socket is bound.
setSoTimeout( int i)	This method sets the maximum time as Socket.accept() method call which will block. If the time period expires, then no connection will be made.
getReceiveBufferSize()	This method fetches the buffer size and returns it.
serReceiveBufferSize( int i)	This method changes the size of the buffer received.

Let's understand in detail about the methods of the ServerSocket class with the help of few Java example programs.

Example 1:

Filename: ProtocolServer.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class ProtocolServer {
    private static boolean serverRunning = true;
    public static void main(String[] args) {
        int portNumber = 8080;
        try (ServerSocket serverSocket = new ServerSocket(portNumber)) {
            System.out.println("Server is listening on port " + portNumber);
            // Shutdown hook to gracefully stop the server on termination
            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                serverRunning = false;
                System.out.println("Server shutting down...");
            }));
            // Accept incoming connections in a loop
            while (serverRunning) {
                try {
                    // Wait for a client to connect
                    Socket clientSocket = serverSocket.accept();
                    System.out.println("Accepted connection from " + clientSocket.getInetAddress());
                    // Create a new thread to handle the client
                    ClientHandler clientHandler = new ClientHandler(clientSocket);
                    Thread thread = new Thread(clientHandler);
                    thread.start();
                } catch (IOException e) {
                    // Handle IOException when accepting a connection
                    System.err.println("Error accepting connection: " + e.getMessage());
                }
            }
        } catch (IOException e) {
            // Handle IOException when creating the ServerSocket
            System.err.println("Error creating ServerSocket: " + e.getMessage());
        }
    }
    // ClientHandler class to handle each connected client in a separate thread
    static class ClientHandler implements Runnable {
        private Socket clientSocket;
        public ClientHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }
        @Override
        public void run() {
            try (
                    BufferedReader inputReader = new BufferedReader(
                            new InputStreamReader(clientSocket.getInputStream()));
                    PrintWriter outputWriter = new PrintWriter(clientSocket.getOutputStream(), true)) {
                outputWriter.println("Welcome to the Server! Type 'BYE' to exit.");
                // Read data from the client
                String clientData;
                while ((clientData = inputReader.readLine()) != null) {
                    System.out.println(
                            "Received command from client " + clientSocket.getInetAddress() + ": " + clientData);
                    // Process the client command
                    String response = processCommand(clientData);
                    outputWriter.println(response);
                    System.out.println("Sent response to client " + clientSocket.getInetAddress() + ": " + response);
                    // Check if the client wants to exit
                    if (clientData.equalsIgnoreCase("BYE")) {
                        break;
                    }
                }
            } catch (IOException e) {
                // Handle IOException when reading/writing data
                System.err.println("Error handling client " + clientSocket.getInetAddress() + ": " + e.getMessage());
            } finally {
                try {
                    // Close the client socket when the client disconnects
                    clientSocket.close();
                    System.out.println("Closed connection with client " + clientSocket.getInetAddress());
                } catch (IOException e) {
                    // Handle IOException when closing the client socket
                    System.err.println("Error closing client socket: " + e.getMessage());
                }
            }
        }
        private String processCommand(String command) {
            // Simple command processing logic
            if (command.equalsIgnoreCase("TIME")) {
                return "Current time: " + System.currentTimeMillis();
            } else if (command.equalsIgnoreCase("HELLO")) {
                return "Hello, client!";
            } else {
                return "Unknown command. Type 'TIME' or 'HELLO'.";
            }
        }
    }
}

Output: