Java 中的服务器套接字

2024 年 9 月 10 日 | 阅读 8 分钟

在 Java 中，ServerSocket 可以被定义为一种类，主要用于提供客户端或服务器的服务器端套接字连接实现。此外，客户端或服务器的套接字连接完全独立于系统。

让我们详细了解 Java 中的 ServerSocket 类。

Java 中的 ServerSocket 类

当 ServerSocket 无法在所需端口上监听时（例如，端口已被占用），它会由构造函数抛出一个异常。换句话说，服务器套接字也可以被认为是网络编程中的主要组件，用于实现客户端和服务器应用程序通过网络进行通信。

服务器套接字代表服务器端的一个端点，其主要目的是监听客户端的传入连接请求。**java.net** 包包含 **ServerSocket** 类，Java 为服务器套接字的实现提供了该类。

为了成功创建 Java 中的服务器套接字连接，必须创建一个 **ServerSocket** 类的实例或对象，并指定一个端口号以及一个可选的 backlog 参数。端口号的主要作用是指定和识别机器上的服务器套接字。backlog 参数主要用于确定服务器连接队列中待处理连接的最大数量。

成功创建服务器套接字后，它就可以进入监听状态，等待来自客户端的连接请求。**ServerSocket** 类的 **accept()** 方法的主要目的是接受并建立与客户端的连接。每当收到连接请求时，都会返回一个新的 Socket 类对象。Socket 对象用于表示与客户端之间发生的通信通道。

在成功接受与客户端的连接后，服务器可以从 **Socket** 对象获取输入和输出流，以便与客户端进行通信。服务器和客户端之间的双向数据交换是通过输入和输出流完成的。

让我们通过一个 Java 示例程序来详细了解 Java 中的 ServerSocket。

示例 1

文件名: 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();
                }
            }
        }
    }
}

输出

Server is listening on port 5555

示例 2

文件名: 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();
        }
    }
}

输出

Server is listening on port 5555

示例 3

文件名: 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();
                }
            }
        }
    }
} 

输出

Server is listening on port 5555

让我们详细了解 Java 中 Server Socket 的方法及其功能。

Java 中 Server Socket 的方法

Java 中的 Server Socket 有各种方法，让我们详细了解它们的功能、目的和用法。

方法	描述
ServerSocket (int i)	此方法用于在所需且指定的端口上构造一个新的 ServerSocket。
ServerSocket( int I , int B)	此方法用于在所需端口上创建一个新的 ServerSocket，并带有表示排队的最大连接数的 required backlog。
accept()	此方法用于侦听需要为此套接字建立的连接并接受它。在建立新连接之前，该方法会阻塞。
bind( SocketAddress S)	此方法用于将 ServerSocket 绑定到所需的网络地址。
close()	此方法用于关闭 ServerSocket。任何被阻塞的 accept 操作都会抛出 SocketException。
getInetAddress()	此方法获取套接字当前绑定的本地地址。
getLocalPort()	此方法获取套接字绑定的本地端口。
setSoTimeout( int i)	此方法设置 Socket.accept() 方法调用的最大阻塞时间。如果超时，则不会建立连接。
getReceiveBufferSize()	此方法获取并返回缓冲区大小。
serReceiveBufferSize( int i)	此方法更改接收缓冲区的大小。

让我们通过几个 Java 示例程序来详细了解 ServerSocket 类的方法。

示例 1

文件名: 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'.";
            }
        }
    }
}

输出

Server is listening on port 8080

下一主题Java 中检查字符串是否为彼此排列

Java 中的服务器套接字

Java 中的 ServerSocket 类

示例 1

示例 2

示例 3

Java 中 Server Socket 的方法

示例 1

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的服务器套接字

Java 中的 ServerSocket 类

示例 1

示例 2

示例 3

Java 中 Server Socket 的方法

示例 1

相关帖子

如何在 Java 中获取环境变量

Java 中数组中最长可整除子集的大小

Java 中的多任务处理

How to print the Next N Leap years in Java

Java 中局部变量、实例变量和静态变量的区别

Spy Number in Java

Java 泛型 Jenkov

Java 中的 java.util.IntSummaryStatistics 类及示例

Evil Number Java

Tech Number in Java

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器