feat(udp): add DatagramClient and Server with explicit port binding and string reversal response

What
- Added two classes demonstrating UDP communication:
  - DatagramClient:
    - Creates a DatagramSocket bound to port 2001 (client-side port explicitly set).
    - Sends "Hello Server:" as a UDP datagram to server on localhost:2000.
    - Allocates a 1024-byte buffer for response, receives datagram from server, trims, and prints result.
    - Closes socket after exchange.
  - Server:
    - Opens a DatagramSocket bound to port 2000 (server port).
    - Waits for a datagram from a client, reads content into a String.
    - Reverses the received string using StringBuilder.reverse().
    - Sends reversed string back to the client at localhost:2001.
    - Closes socket after reply.

Why
- Demonstrates core concepts of UDP in Java:
  - DatagramSockets for connectionless communication.
  - DatagramPackets for message encapsulation.
  - Explicit port binding (server on 2000, client on 2001) to illustrate bidirectional communication.
- Helps understand message boundaries, client-server request/response pattern, and string manipulation in network programming.
- Serves as a foundation for building lightweight, low-latency communication systems.

How
- Client side:
  - Binds socket to a fixed port (2001) → useful for ensuring server knows where to reply.
  - Constructs DatagramPacket with msg.getBytes(), message length, server address (InetAddress.getByName("localhost")), and server port (2000).
  - Sends the packet via ds.send(dp).
  - Prepares buffer (byte[1024]), wraps in a DatagramPacket, blocks on receive().
  - Converts bytes into String using new String(dp.getData()).trim() (trimming trailing nulls).
  - Prints "From Server Hello: <response>" and closes socket.
- Server side:
  - Creates DatagramSocket on port 2000 to listen for packets.
  - Receives packet into a fixed buffer, extracts String with new String(dp.getData()).trim().
  - Uses StringBuilder.reverse() to reverse the message.
  - Constructs reply packet with reversed message, sets destination to localhost:2001 (client port).
  - Sends reply, closes socket.

Key considerations / notes
- Explicit port binding:
  - Client uses port 2001 → ensures server knows where to send reply.
  - In contrast to ephemeral port allocation, this approach is deterministic.
- Buffer management:
  - new String(dp.getData()) reads entire buffer, but .trim() removes trailing whitespace. Better practice: new String(dp.getData(), 0, dp.getLength()).
- Character encoding:
  - Currently uses platform default encoding via getBytes() and new String(byte[]). For portability, specify StandardCharsets.UTF_8.
- Single exchange:
  - Server handles only one packet then exits. To build a persistent service, wrap receive() in a loop.
- Blocking I/O:
  - Both client and server block until data arrives. For timeout handling, configure ds.setSoTimeout(ms) and catch SocketTimeoutException.
- Threading:
  - Current implementation is single-threaded; production-grade servers often handle multiple clients concurrently.
- Resource management:
  - Uses manual socket closing (ds.close()). For safety, prefer try-with-resources or explicit shutdown logic.

How to test
1. Run Server (binds to port 2000).
   java Server
   Expected output:
   From Client: Hello Server:

2. Run DatagramClient (binds to port 2001, sends message).
   java DatagramClient
   Expected client output:
   From Server Hello: :revreS olleH
   Server additionally prints reversed message was sent.

Real-life applications
- Simple request/response protocols over UDP (e.g., DNS-style queries).
- Quick-and-lightweight text-based message exchange for demos.
- Learning environment to understand connectionless datagram transport.

Future improvements
- Replace .trim() with new String(dp.getData(), 0, dp.getLength(), UTF_8).
- Convert server to loop for continuous service.
- Add logging, configurable host/port, and better error handling.
- Extend to handle multiple message types or structured payloads.
- Implement retry/ACK mechanism for reliability in lossy networks.

Files added
- DatagramClient.java — sends and receives UDP packets via explicit client port.
- Server.java — listens on fixed server port, reverses client message, replies.

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

Author: Someshdiwan

Section27NetworkProgramming/DataGramReverseEchoServer/src/DatagramClient.java

@@ -7,16 +7,17 @@ public static void main(String[] args)throws Exception{
 
         String msg = "Hello Server: ";
 
-        //Array of Bytes. That you want to send using a datagram packets.
+        //Array of Bytes. That you want to send using a datagram packet.
         DatagramPacket dp = new DatagramPacket(msg.getBytes(),msg.length(),InetAddress.getByName("localHost"),2000);
         //msg.length = What is the length of the array of the bytes that is msg.length.
         //Inet = Ip address you want to send.
 
-        //Now lets the this above packets to the server.
+        //Now lets this above packet to the server.
         ds.send(dp);
-        //Client has send the packet.
+        //Client has sent the packet.
 
-        byte b[]=new byte[1024]; //receiving the size of the packets from the Server.
+        byte b[]=new byte[1024];
+        //receiving the size of the packets from the Server.
         //For received the packets and display it from the server.
         dp=new DatagramPacket(b,1024);
 
@@ -29,32 +30,34 @@ public static void main(String[] args)throws Exception{
         ds.close();
     }
 }
+
 class Server{
     public static void main(String[] args)throws Exception {
         //Server Address and port number needed.
         DatagramSocket ds = new DatagramSocket(2000);
 
-        //First done. next what server has to do receiving a packet.
+        //First done. next what the server has to do is receive a packet.
         byte b[]=new byte[1024];
         //Packet is received
         DatagramPacket dp = new DatagramPacket(b,1024);
 
         ds.receive(dp);
 
         //Now it has to create a string and reverse the string from
-        //that receiving the packets from client.
+        //that receiving the packets from a client.
 
         String msg = new String(dp.getData()).trim();
         System.out.println("From Client: "+msg);
 
-        //Reverse
+        //Reverse.
         StringBuilder sb = new StringBuilder(msg);
         sb.reverse();
-        msg = sb.toString(); //getting a string.
+        msg = sb.toString();
+        //getting a string.
 
-        //This msg it sending it to the Client using a datagram packets.
+        //This msg it sending it to the Client using a datagram packet.
         dp = new DatagramPacket(msg.getBytes(),msg.length(),InetAddress.getByName("localHost"),2001);
         ds.send(dp);
         ds.close();
     }
-}
+}