18.3.1. TCP Server Example

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

This code begins by importing the necessary Java networking and input-output classes.

In this chunk, we start off by importing two key Java packages: java.net.* and java.io.*. The java.net package is essential for networking operations, like creating sockets for server-client communication. The java.io package allows us to work with input and output, essential for reading and writing data to and from a client.

Think of this step as gathering your tools and materials before starting to build a project. Just as you need the right tools to effectively build something, we need these imports to set up our network communication.

public class TCPServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(5000);
        System.out.println("Server started...");

This part creates a TCP server socket that listens on port 5000.

Here, we define a public class named TCPServer containing the main method, which is the entry point of our Java application. Inside this method, we create a ServerSocket that binds to port 5000. This means our server will listen for incoming client connections on this port. The System.out.println line is for feedback, confirming the server has started.

Imagine you’re setting up a shop in a building. The ServerSocket here is like the shop door, allowing customers (clients) to enter when they arrive at your location (port 5000).

        Socket clientSocket = serverSocket.accept();
        System.out.println("Client connected.");

The server waits for a client to connect and then accepts the connection.

In this chunk, the accept() method on serverSocket blocks until a client connects. Once a connection is made, it creates a Socket object clientSocket, representing the connection between the server and the client. The message confirms that the client has successfully connected.

This is similar to a shopkeeper waiting at the door for customers. Once a customer enters the shop, the shopkeeper can begin serving them. Here, the server is ready to interact with the connected client.

        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
        String message = in.readLine();
        System.out.println("Received: " + message);

This chunk sets up streams for input and output, reads a message from the client, and prints it.

This part creates a BufferedReader for reading data from the clientSocket input stream and a PrintWriter for sending data back to the client. The program reads a line of text from the client using in.readLine() and stores it in the message variable. It then prints that message to the server console.

Consider this step as having a conversation in a café. You (the server) are listening to what your friend (the client) is saying, and once they finish a sentence, you note down what they said before responding.

        out.println("Echo: " + message);
        in.close();
        out.close();
        clientSocket.close();
        serverSocket.close();
    }
}

The server sends an echo response back to the client and closes all connections.

In this final part of the TCP server example, the server sends the received message back to the client prefixed with 'Echo: '. After sending the response, it closes the input and output streams, as well as the client and server sockets. Properly closing these resources is critical to prevent memory leaks.

In our café analogy, this is like finishing the conversation by echoing back what your friend said. You confirm their message before wrapping up and ensuring the café is clean for the next customer (closing connections).

--