在服务器套接字上接受来自客户端的多个连接

Question

我刚刚开始使用Sockets，对于我当前的项目，我需要能够从客户端控制我的程序，但是如果我的项目合作伙伴想同时使用他的客户端，服务器不会向他发送“您已连接”消息，如连接类所示。所以我假设服务器不同时接受多个客户端。我尝试过使用类Connection的Thread，但这也不会向第二个客户端发送消息“您已连接”。我在这里做错了什么？

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Listener extends Thread{

private ServerSocket server;
private int PORT;
public boolean running;

public Listener(int port){
    try{
        this.PORT = port;
        this.server = new ServerSocket(PORT,10);
    }catch (IOException e) {
        System.out.println("Could not create serverSocket...");
    }
}

@Override
public void run() {
    this.running = true;
    try{
        waitForConnection();
    }catch(IOException e){
        System.out.println("Could not accept connection request..");
        run();
    }


}
public void dispose(){
    try{
        System.out.println("DISPOSE");
        running = false;
        server.close();
    } catch (IOException i) {
        System.out.println("Could not close ServerSocket");
    }
}
private void waitForConnection() throws IOException{
    while(running){
        System.out.println("Waiting for connection");
        Socket client = server.accept();
        Runnable connection = new Connection(client);
        new Thread(connection).start();
    }
}       
}

这是我用来同时连接多个用户的线程：

 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.net.Socket;

public class Connection extends Thread {
     Socket connection;
     private ObjectOutputStream output;
     private ObjectInputStream input;
     private boolean running;

     public Connection(Socket connect){
          this.connection = connect;
          try {
              setupStreams();
              whileListening();
          } catch (IOException e) {
                System.out.println("could not connect to: "+ connection.getInetAddress().getHostName());
    }
}

public void dispose(){
    try{
        output.close();
        input.close();
        connection.close();
        running = false;
    }catch(IOException ioException){
        ioException.printStackTrace();
    }
}   

private void whileListening(){
    String message = "You are connected! ";
    sendMessage(message);
    do{
        try{
            message = (String) input.readObject();
            checkMessage(message);
        }catch(ClassNotFoundException classNotFoundException){
            sendMessage("tf did you send? ");
        }catch (IOException e) {
            dispose();
            run();
        }
    }while(!message.equals("Client - END") && running == true);
}

private void setupStreams() throws IOException{
    output = new ObjectOutputStream(connection.getOutputStream());
    output.flush();
    input = new ObjectInputStream(connection.getInputStream());
}

private  void sendMessage(String message){
    try {
        output.writeObject("Server - " + message+"\n");
        output.flush();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

private void checkMessage(String text){
        //check the message
}
}     

编辑：附加信息

在第一个客户端连接之前，服务器控制台说“等待连接”，然后当第一个客户端连接时，客户端控制台说“您已连接”，当第二个客户端连接时，控制台是黑色的，当我关闭第一个客户端时，第二个客户端控制台说“您已连接”，服务器控制台说“等待连接”，然后如果我也关闭第二个客户端，服务器控制台再次说“等待连接”。

Answer 1

我想你必须先接受，然后你开始线程。

例如，让我们假设这样的事情

1. 在主类中，您得到了ServerSocketFactory，然后是ServerSocket

这是一个来自SSLServerSocket的示例，它几乎是相同的逻辑（将其视为伪代码）

    SSLContext sc = SSLContext.getInstance("TLS");
    (...)
    SSLServerSocketFactory ssf = sc.getServerSocketFactory();
    SSLServerSocket s = (SSLServerSocket) ssf.createServerSocket(portNumber);
    while (listening) {
        SSLSocket c = (SSLSocket) s.accept();
        log.info("Serving");
        new SimpleSSLServerSocketThread(c).start();
    }

Answer 2

在公共类连接扩展线程的构造函数中，您可以在Listening（）时执行此操作，因此构造函数永远不会结束，您需要重写run（）函数并在那里执行此操作

@Override
public void run() {
    while(true) {
        try {
            whileListening();
        } catch(Exception e) {}
    }
}

像这样，它应该做到这一点。