Question

情境：
a）持续的联系
b）单独管理每个服务器 - 客户端通信 c）保护系统不传播异常/错误

我尝试使用以下代码创建两个服务器套接字侦听器实例：

SimpleSocketServers.java

public class SimpleSocketServers {

    public static void main(String[] args) throws Exception {
        int port1 = 9876;
        SimpleSocketServer server1 = new SimpleSocketServer(port1);
        server1.startAndRunServer();
        System.out.println("Servers : server1 Listening on port: " + port1);

        int port2 = 9875;
        SimpleSocketServer server2 = new SimpleSocketServer(port2);
        server2.startAndRunServer();
        System.out.println("Servers : server2 Listening on port: " + port2);
    }
}

和

SimpleSocketServer.java

    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.ServerSocket;
    import java.net.Socket;

    public class SimpleSocketServer {

        private ServerSocket serverSocket;
        private int port;

        public SimpleSocketServer(int port) {
            this.port = port;
        }

        public void startAndRunServer() {
            try {
                System.out.println("Starting Server at port " + port + " ...");
                serverSocket = new ServerSocket(port);
                System.out.println("Listening for client connection ...");
                Socket socket = serverSocket.accept();
                RequestHandler requestHandler = new RequestHandler(socket);
                requestHandler.start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

class RequestHandler extends Thread {

    private Socket socket;

    RequestHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            System.out.println("Client Request Response being processed...");
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream());


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

但是，它只创建一个实例，因为控件没有从第一个实例的构造函数返回。是否有可能同时取回控制并运行服务器套接字侦听器的两个实例？（ps：原谅我，如果它是错误的或琐碎的！）

Answer 1

您需要SimpleSocketServer实施Runnable;在构造函数中创建一个自身为Runnable的线程;并在accept()方法中运行run() 循环。目前你在构造函数中阻塞等待连接，你的服务器也只处理一个连接。

更有趣的问题是为什么要在两个端口上提供相同的服务。

Answer 2

使用2个不同的线程，聆听2个不同的端口。

Thread ServerThread1 = new Thread(new Runnable() {

    @Override
    public void run() {
        ServerSocket ServerSocketObject = null;
        while(true)
        {
        try {
            ServerSocketObject  = new ServerSocket(Your_Port_Number1);

                Socket SocketObject = ServerSocketObject.accept();
                // Your Code Here
                SocketObject.close();

        } catch (IOException e) {
                try {
                    ServerSocketObject.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            e.printStackTrace();
        }
        }
    }
});

Thread ServerThread2 = new Thread(new Runnable() {

    @Override
    public void run() {
        ServerSocket ServerSocketObject = null;
        while(true)
        {
        try {
            ServerSocketObject  = new ServerSocket(Your_Port_Number2);

                Socket SocketObject = ServerSocketObject.accept();
                // Your Code Here
                SocketObject.close();

        } catch (IOException e) {
                try {
                    ServerSocketObject.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            e.printStackTrace();
        }
        }
    }
});

ServerThread1.start();
ServerThread2.start();

如何在两个不同的端口上运行两个java套接字服务器实例？

2 个答案: