feat(reverse-echo): add multithreaded TCP reverse-echo server and client example with I/O details

What
- Added ReverseEcho: a multithreaded TCP server that accepts multiple client connections on port 6000.
- Each client is handled by a dedicated Thread subclass (ReverseEcho) which:
  - uses BufferedReader(InputStreamReader(socket.getInputStream())) to read text lines from client,
  - uses PrintStream(socket.getOutputStream()) to send text responses,
  - reverses each incoming line using StringBuilder.reverse() and returns it back to the client,
  - uses a simple sentinel "dne" to terminate per-connection loop and close the socket.
- Included an inner Client example showing how to connect to the server, send keyboard input, and receive reversed responses.
- Documented why BufferedReader is used, how the server accepts connections in an infinite loop, and where to change the address/port.

Why
- Demonstrates core TCP server patterns:
  - ServerSocket.accept() to accept incoming connections,
  - per-connection thread model to enable concurrent clients,
  - use of character streams (BufferedReader) for line-oriented protocols,
  - use of PrintStream for simple line output.
- Educational example for learning blocking I/O, thread-per-connection model, and simple request/response protocols.
- Provides a minimal, clear pattern to build or test line-based services (chat bots, small REPL servers, command servers).

How to use
1. Start the server:
   - Run ReverseEcho.main(). Server listens on port 6000 and prints connection counts.
2. Start a client:
   - Replace the placeholder IP in Client.main() with server IP (for local tests use "localhost").
   - Run Client.main(). Type lines at the keyboard; the server will echo each line reversed.
3. Protocol details:
   - Client sends newline-terminated text lines.
   - Server responds with newline-terminated reversed text lines.
   - Send the exact string "dne" (without quotes) to terminate the session from either side (server closes socket on "dne").
4. Example session:
   - Client: Hello
   - Server: olleH
   - Client: world
   - Server: dlrow
   - Client: dne
   - Connection closed.

Real-life applications
- Teaching and testing TCP basics, socket programming and stream I/O.
- Lightweight text-processing backends (e.g., simple command processors, protocol simulators).
- Local development tools for debugging and learning about concurrency, timeouts and network flows.

Notes & recommendations
- BufferedReader is wrapped around InputStreamReader to efficiently read lines and handle character decoding.
- PrintStream is convenient for println() but consider using BufferedWriter/PrintWriter with explicit flushing for production code.
- Current server uses one thread per client. For many simultaneous clients, prefer a thread pool (ExecutorService) or NIO (java.nio) for scalability.
- The code currently swallows exceptions silently in run(); add proper logging and resource cleanup.
- The sentinel "dne" is a simple protocol choice for demo purposes—use formal protocol framing and validation for production systems.
- Always validate input and consider timeouts (socket read timeout) to prevent blocked threads.
- Consider graceful shutdown handling for ServerSocket (e.g., listening flag + close) instead of infinite loop.
- Security: do not trust client input; avoid exposing sensitive operations over plain TCP. Use TLS (SSLSocket) for encrypted communication in real deployments.

Possible improvements (next steps)
- Replace per-connection Thread with ExecutorService to limit max threads.
- Add socket timeouts and per-connection exception handling/logging.
- Switch to non-blocking NIO for high-concurrency use cases.
- Add graceful server shutdown hook and connection tracking.
- Replace sentinel-based termination with a formal request/response code or protocol.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section27NetworkProgramming/ReverseEchoServerMultipleClient/src/RevserseEcho.java

@@ -10,27 +10,35 @@ class ReverseEcho extends Thread {
     public ReverseEcho(Socket st) {
         stk = st;
     }
-
     public void run() {
         try {
             System.out.println("Client Handler Started for: " + stk.getInetAddress());
 
             //Waiting to accept the connection.
             //For using Readline(); we are using Buffer reader();
-            //BufferedReader to read input from client
+            //BufferedReader to read input from a client
+
             BufferedReader br = new BufferedReader(new InputStreamReader(stk.getInputStream()));
-            //Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
-            //The buffer size may be specified, or the default size may be used. The default is large enough for most purposes.
-            //In general, each read request made of a Reader causes a corresponding read request to be made of the underlying character or byte stream.
-            //It is therefore advisable to wrap a BufferedReader around any Reader whose read() operations may be costly, such as FileReaders and InputStreamReaders.
+            /*
+            Reads text from a character-input stream, buffering characters so as to provide for the efficient reading
+            of characters, arrays, and lines.
+            The buffer size may be specified, or the default size may be used. The default is large enough for most
+            purposes.
+            In general, each read request made of a Reader causes a corresponding read request to be made of the
+            underlying character or byte stream.
+            It is therefore advisable to wrap a BufferedReader around any Reader whose read()
+            operations may be costly, such as FileReaders and InputStreamReaders.
+            */
+
             PrintStream ps = new PrintStream(stk.getOutputStream());
 
             String msg;
             StringBuilder sb;
+
             //Reversing a string. Try with StringBuffer.
             do {
                 msg = br.readLine();
-                if (msg == null) break;  // In case client disconnects unexpectedly
+                if (msg == null) break;  // In case a client disconnects unexpectedly
 
                 sb = new StringBuilder(msg);
                 sb.reverse();
@@ -47,25 +55,28 @@ public void run() {
 
     // Main server method to accept multiple client connections
     public static void main(String[] args) throws Exception {
-        //Now, we want to allow server multiple client using multi threading.
-        //Client ------ Server
-        //Network --IP Add
-        //Transport layer ==Establish connection
-        //Connection-Oriented server.
-        //Client software will communicate server soft which are on other machine.
-        //Server -- PORT Number 3000.
-        //Client need Server IP and port address. to connect the server
+        /*
+        Now, we want to allow a server multiple client using multi threading.
+        Client ------ Server
+        Network --IP Add
+        Transport layer ==Establish connection
+        Connection-Oriented server.
+        Client software will communicate with server software that is on another machine.
+        Server -- PORT Number 3000.
+        Client needs Server IP and port address. to connect the server
+        */
 
         ServerSocket ss = new ServerSocket(3000);
-        //Accept the connection and it should now gave connection to the thread.
+        //Accept the connection, and it should now give a connection to the thread.
         Socket stk;
         ReverseEcho re; //references
 
         int count = 1;
         System.out.println("Server started on port 3000. Waiting for clients...");
         do {
             stk = ss.accept();
-            //Creating object of Reverse Echo class.
+            //Creating an object of Reverse Echo class.
+
             System.out.println("Client Connected: " + count++);
 
             re = new ReverseEcho(stk); //Creating an object here.
@@ -111,6 +122,6 @@ public static void main(String[] args) throws Exception {
 Client:
 Connects to the server at IP localhost on port 3000.
 Reads input from the keyboard, sends it to the server.
-Receives reversed message from the server and displays it.
+Receives a reversed message from the server and displays it.
 Continues until "dne" is entered, then closes the connection.
-*/
+*/