客戶端程序可以具有服務器套接字以與其他客戶端程序進行通信嗎？

Question

我正在嘗試實現一個多線程套接字程序，該程序可模擬五台計算機和一個通過套接字相互通信的控制器。 控制器具有一個服務器套接字，該套接字可以接受來自計算機的傳入套接字。 一旦達到系統的最大容量（比方說五個），它將使用接受傳入套接字時創建的線程向這些計算機發送啟動消息。

當每台計算機從控制器接收到“開始”消息時，我希望每台計算機都能夠與其他計算機通信（無需依賴控制器（從計算機到控制器到另一台計算機的中繼消息）。我認為可行的是讓每台計算機實例化一個服務器套接字，以便它可以接受來自計算機的傳入套接字；還可以實例化另一個客戶端套接字，以便來自其他計算機的其他服務器套接字可以接受它。

我知道這聽起來很混亂，但是基本上我想在每個客戶端程序（計算機）上使用服務器套接字，以便它可以在不依賴控制器的情況下偵聽其他客戶端（計算機）。

這可能嗎？ 我可以實例化服務器程序套接字的每個客戶端程序（計算機），以便它可以偵聽其他計算機嗎？ 它是否需要與控制器的服務器插槽不同的IP地址和/或端口號？ 我是否需要為x數量的計算機實例化x數量的套接字？

也許我的Java代碼可以解決這個問題。

Controller.java

    package timetableexchange;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class Controller {

final int MAX_SYSTEMS = 2;

static ArrayList<ServerConnection> conns = new ArrayList<ServerConnection>();   // connections to computer
static int finishedCount = 0;                                                   // number of finished computers

ServerSocket ss;            // server socket

public static void main(String[] args) throws IOException {
    // Instantiate controller
    new Controller(8000);
}

public Controller(int port) throws IOException {
    // Instantiate server socket
    ss = new ServerSocket(8000);
    int i = 0;
    // Listen and accept clients (1 for testing)
    while (i < MAX_SYSTEMS) {
        Socket s = ss.accept();
        // add to list
        ServerConnection conn = new ServerConnection(i++, s);
        conns.add(conn);
    }
    // start server connection thread
    for (i = 0; i < conns.size(); ++i) {
        conns.get(i).start();
    }
    ss.close();
}

// Thread for communicating between controller and computer
private class ServerConnection extends Thread {

    Socket socket;
    BufferedReader in;
    PrintWriter out;
    int identifier;

    // constructor
    public ServerConnection(int i, Socket s) throws IOException {
        this.identifier = i;
        this.socket = s;
        this.in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        this.out = new PrintWriter(socket.getOutputStream(), true);
        System.out.println("Client Connected");
    }

    @Override
    public void run() {
        System.out.println("ServerConnection started");
        // send ID to computers
        sendAll(identifier + "");
        // send Start message to computers
        sendAll("Start");
        // Check if a computer sent back a Finish message
        // If all computers are finished, then send out Tear Down message.
        while (true) {
            try {
                String clientInput = in.readLine();
                if (clientInput.equals("Finish")) {
                    finishedCount += 1;
                    if (finishedCount == conns.size()) {
                        sendAll("Tear Down");
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
                break;
            }
        }
    }

    private void sendAll(String text) {
        for (int i = 0; i < conns.size(); ++i) {
            ServerConnection conn = conns.get(i);
            conn.out.println(text);
        }
    }
}

}

Computer.java

package timetableexchange;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Vector;

public class Computer {

final int MAX_SYSTEMS = 2;

int identifier;                                         // Computer ID
int eventCount;                                         // Number of Generated Events
ArrayList<Socket> sockets = new ArrayList<Socket>();    // List of (client) sockets
Vector<Integer> timestamp = new Vector<Integer>();      // Time-stamp vector

Socket socketToServer;                                  // Socket to Connect to Controller
BufferedReader inputFromServer;                         // Input Stream from Controller
PrintWriter outputToServer;                             // Output Stream to Controller
String textFromServer;                                  // String sent from Controller

ServerSocket ss;                                        // Server Socket to communicate with other clients (computers)
Socket socketToClient;                                  // Socket to Connect to Computer
BufferedReader inputFromClient;                         // Input Stream from Computer
PrintWriter outputToClient;                             // Output Stream to Computer

public static void main(String[] args) throws IOException {
    // Instantiate Computer
    new Computer("127.0.0.1", 8000);
}

// Constructor
public Computer(String hostname, int port) throws IOException {
    // Instantiate Socket (to Controller) and Streams (to Controller)
    socketToServer = new Socket(hostname, port);
    inputFromServer = new BufferedReader(new InputStreamReader(socketToServer.getInputStream()));
    outputToServer = new PrintWriter(socketToServer.getOutputStream(), true);

    // Check if Controller sent the computer its ID
    while (true) {
        try {
            textFromServer = inputFromServer.readLine();
            // set identifier
            identifier = Integer.parseInt(textFromServer);
            System.out.println(identifier);
            break;  // break loop
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }
    }

    // Check if Controller sent the start message
    while (true) {
        textFromServer = inputFromServer.readLine();
        if (textFromServer.equals("Start"))
            System.out.println("Start message received");
            break;  // break loop
    }

    // Instantiate Server Socket (for Clients)
    ss = new ServerSocket(port + identifier + 1);

    // Instantiate Client Socket for Other Clients to Hear
    socketToClient = new Socket();
    inputFromClient = new BufferedReader(new InputStreamReader(socketToClient.getInputStream()));
    outputToClient = new PrintWriter(socketToClient.getOutputStream());

    // listen to server socket and add accepted socket to list  
    for (int i = 0; i < MAX_SYSTEMS - 1; ++i) {
        Socket s = ss.accept();
        System.out.println("Client accepted");
        sockets.add(s);
    }

    Thread readEvent = new Thread(new Runnable() {
        @Override
        public void run() {
            /**
             * Read from input stream
             * Read the vector inside the input stream
             * Compare vectors and choose the largest integer (synchronized)
             * Add 1 to the corresponding socket. (synchronized)
             */
        }
    });

    Thread writeEvent = new Thread(new Runnable() {
        @Override
        public void run() {
            /**
             * Generate random number between 0 and 4.
             * If zero, then add 1 to its own socket in vector.
             * Else, send vector to random socket via output stream
             */
        }
    });

    readEvent.start();
    writeEvent.start();
}

}

感謝您的幫助！

Answer 1

簡而言之：

這可能嗎？

是的，為什么不？

我可以實例化服務器程序套接字的每個客戶端程序（計算機），以便它可以偵聽其他計算機嗎？

是的-您可以做任何您想要或需要的事情

它是否需要與控制器的服務器插槽不同的IP地址和/或端口號？

IP地址屬於“物理計算機” /網絡接口，與您嘗試執行的操作無關緊要-所有地址都可以在一台計算機上運行，​​並且都可以在同一IP地址上運行（例如127.0.0.1）。 您必須為要打開的每個服務器套接字都具有專用端口，並且客戶端套接字必須知道要與之通信的IP和端口號。 對於客戶端套接字，您無需關心IP或端口號。

我是否需要為x數量的計算機實例化x數量的套接字？

問題對我來說意義不大-這是您的設計決策，您需要實例化多少個服務器套接字-一個端口一個服務器套接字，就是這樣。