ServerSocket in Java: Building Scalable TCP Servers
ServerSocket in Java: Building Scalable TCP Servers
जब भी हम Java में network communication की बात करते हैं, तो ServerSocket एक बहुत important class होती है। यह server-side socket programming का main हिस्सा है, जो TCP (Transmission Control Protocol) पर आधारित communication को handle करता है। आज हम step-by-step समझेंगे कि ServerSocket in Java क्या होता है, कैसे काम करता है, और scalable TCP servers कैसे बनाए जाते हैं।
What is ServerSocket in Java?
ServerSocket एक Java class है जो server application को client connections सुनने (listen) और accept करने की सुविधा देती है। यह server को एक specific port पर bind करती है और आने वाले client requests को handle करती है।
सीधे शब्दों में कहें तो, ServerSocket server के लिए "door" की तरह काम करती है, जहाँ से clients request भेजते हैं और server उन requests का जवाब देता है।
Key Functions of ServerSocket
- Listening: ServerSocket एक specific port पर clients के connection requests सुनती है।
- Accepting: जब कोई client connect करता है, तो यह connection accept करती है और एक dedicated
Socketobject return करती है। - Communication: इस socket के ज़रिए client और server के बीच data transfer होता है।
How ServerSocket Works Internally
ServerSocket internally OS-level TCP/IP stack पर काम करती है। यह नीचे दिए गए steps में काम करती है:
- Server एक
ServerSocketobject create करता है और किसी port number (जैसे 8080) पर bind करता है। - यह continuously clients की requests के लिए listen करता है।
- जब कोई client connect करता है, तो
accept()method एक नयाSocketobject create करता है। - Server अब उस socket के ज़रिए client से read/write operations कर सकता है।
Example: Basic ServerSocket Code
import java.io.*;
import java.net.*;
public class SimpleServer {
public static void main(String[] args) {
try {
ServerSocket server = new ServerSocket(5000);
System.out.println("Server started, waiting for clients...");
Socket socket = server.accept();
System.out.println("Client connected!");
BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter output = new PrintWriter(socket.getOutputStream(), true);
String message = input.readLine();
System.out.println("Received: " + message);
output.println("Hello from server!");
socket.close();
server.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
यह example एक simple TCP server बनाता है जो client से message receive करता है और reply भेजता है।
ServerSocket Constructors
ServerSocket class में कई constructors available हैं जो अलग-अलग configurations के लिए use होते हैं:
| Constructor | Description |
|---|---|
ServerSocket(int port) | यह specific port पर server socket bind करता है। |
ServerSocket(int port, int backlog) | यह backlog parameter से pending connections की limit set करता है। |
ServerSocket(int port, int backlog, InetAddress bindAddr) | यह specific IP address और port दोनों पर bind करता है। |
Important Methods of ServerSocket
| Method | Purpose |
|---|---|
accept() | Client connection accept करता है और नया socket return करता है। |
close() | Server socket बंद करता है। |
getInetAddress() | Server का IP address return करता है। |
getLocalPort() | Server जिस port पर चल रहा है उसे return करता है। |
setSoTimeout(int timeout) | Accept call के लिए timeout set करता है। |
Building a Multi-threaded TCP Server
अगर हम चाहते हैं कि server एक साथ कई clients को handle कर सके, तो हमें multi-threading का use करना होगा। हर client के लिए एक separate thread create किया जाता है, ताकि server parallel connections manage कर सके।
Example: Multi-threaded Server
import java.io.*;
import java.net.*;
public class MultiThreadServer {
public static void main(String[] args) {
try {
ServerSocket server = new ServerSocket(6000);
System.out.println("Server started on port 6000");
while(true) {
Socket socket = server.accept();
System.out.println("Client connected!");
new ClientHandler(socket).start();
}
} catch(IOException e) {
e.printStackTrace();
}
}
}
class ClientHandler extends Thread {
Socket socket;
ClientHandler(Socket s) { this.socket = s; }
public void run() {
try {
BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter output = new PrintWriter(socket.getOutputStream(), true);
String line;
while((line = input.readLine()) != null) {
System.out.println("Client says: " + line);
output.println("Echo: " + line);
}
socket.close();
} catch(IOException e) { e.printStackTrace(); }
}
}
इस example में हर client के लिए एक नया thread बनता है, जिससे server एक साथ multiple clients को efficiently handle कर सकता है।
Scalability Concepts
एक scalable TCP server वह होता है जो बड़ी संख्या में clients को efficiently handle कर सके। नीचे कुछ tips दिए गए हैं जिससे scalability improve होती है:
- Thread Pooling: हर बार नया thread बनाने की बजाय fixed thread pool use करें।
- Non-blocking I/O (NIO): Java NIO package का use करें ताकि threads block न हों।
- Load Balancing: Multiple servers पर connections distribute करें।
- Asynchronous Communication: Async APIs का use करें ताकि performance बढ़े।
Implementing Scalable Server using NIO
Java NIO (New Input/Output) asynchronous model पर काम करता है। इससे एक single thread multiple connections handle कर सकता है, जो scalability के लिए बहुत जरूरी है।
Example: NIO Server (Conceptual)
Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(7000));
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
selector.select();
Set<SelectionKey> keys = selector.selectedKeys();
for (SelectionKey key : keys) {
if (key.isAcceptable()) {
SocketChannel client = serverChannel.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
}
}
}
यह code दिखाता है कि कैसे एक single thread multiple client connections handle कर सकता है बिना blocking के।
Real-World Usage of ServerSocket
ServerSocket का use कई real-world applications में होता है जैसे:
- Chat servers
- HTTP servers
- File transfer systems
- IoT device communication
- Game servers
Error Handling and Timeout
ServerSocket में timeout और error handling बहुत जरूरी है ताकि server crash न हो।
ServerSocket server = new ServerSocket(8080);
server.setSoTimeout(10000); // 10 seconds timeout
try {
Socket s = server.accept();
} catch (SocketTimeoutException e) {
System.out.println("No client connected within timeout!");
}
यह approach production servers में बहुत useful होती है ताकि resources waste न हों।
Exam-Oriented Notes (Quick Revision)
- ServerSocket class server-side connection handling के लिए use होती है।
- accept() method client connection establish करता है।
- Multi-threaded servers parallel client connections handle करते हैं।
- Backlog parameter pending client requests limit करता है।
- NIO model scalable, non-blocking server बनाने के लिए use होता है।
- ServerSocket mostly TCP-based communication के लिए use होती है।
- Port Number uniquely identify करता है कि server कौन सी service provide कर रहा है।
- Always close sockets after use to prevent memory leaks.
- Use thread pools for better scalability.
- Set timeout to avoid indefinite blocking on accept().
Summary
तो अब आपने समझ लिया कि ServerSocket in Java एक powerful class है जो TCP-based communication को manage करती है। यह scalable, multi-threaded, और efficient network applications बनाने का foundation है। अगर आप Java network programming सीख रहे हैं या college exam की तैयारी कर रहे हैं, तो यह concept बहुत important है।
