Question

我有一个有效的Java服务器（尽管边缘有点粗糙），它包含3个主要类。

第一个类运行服务器并获取套接字以侦听端口并将新连接传递给客户端处理程序。

第二个类是线程客户端处理程序

第三个是从客户端处理程序调用并处理信息的协议类。处理完信息后，协议类会将已处理或格式化的响应返回给客户端处理程序，以传递给客户端。

优点是第二类只需要加载从套接字接受的可接受数据。数据可以传递给协议处理程序，协议处理程序可以加载您希望服务器用来与客户端通信的任何协议。

在这个例子中，我加载了一个基于telnet的聊天类。

例如，如果有人离开聊天，则客户端处理程序类可以执行以下代码：

for (i = 0; i < currentClientsConnected; i++) {
    if(threads[i] != null && threads[i] != this) {
        outputLine = threads[i].serverprotocol.processInput("** " + username + " has left the room **");
        threads[i].out.printf(outputLine);

    }
}

这会将"** [username] has left the room **"传递给serverprotocol类，然后以最佳方式返回数据以将消息传输到客户端。在这种情况下，serverprotocol类使用telnet控制代码格式化消息，该代码告诉客户端重新绘制屏幕，添加新消息并向上滚动缓冲区中现有的当前消息。

我也可能只希望客户端处理程序类将消息发送到用户位于某些聊天室的套接字，例如，所以我不想总是发送到所有套接字。

在我的代码中，这是Class 1 - 接受带有：

的套接字的服务器类

while (true) {
    int i;
    // Try and accept the connection
    try {
        clientSocket = serverSocket.accept();
        // System.out.printf("Remote IP:");
        // System.out.printf(clientSocket.getRemoteSocketAddress().toString());

        // Find an unused socket if one is available
        for (i = 0; i < maxClientsAllowed; i++) {

            // If found create thread
            if (threads[i] == null) {
                (threads[i] = new clientThread(clientSocket, threads)).start();
                break;
            }
        }

        // If all sockets are taken
        if (i == maxClientsAllowed) {
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
            out.printf("Server too busy. Try later.\n");
            out.close();
            clientSocket.close();
        }
    } catch(IOException e) {
        System.out.println(e);}
}

和Class 2是一个扩展线程的类：

class clientThread extends Thread {
    private String clientName = null;
    private DataInputStream in;
    private PrintWriter out;
    private Socket clientSocket = null;
    private final clientThread[] threads;
    private int currentClientsConnected;
    private serverprotocol serverprotocol;

    public clientThread(Socket clientSocket, clientThread[] threads) {
        this.clientSocket = clientSocket;
        this.threads = threads;
        currentClientsConnected = threads.length;
    }

    public void run() {
    //stuff 
    }
}

我一直在拼命想看看我是否可以使用implements Runnable来解决这个问题，但是我没有运气来调用线程的processInput（或者可能应该阅读dataToBeProcessed ）基于线程实例编号的方法（此处代码中简称为i）。

我见过的最接近的地方：

https://github.com/ico77/chat-server-client/blob/master/src/main/java/hr/ivica/chat/server/ChatServer.java

可以利用将服务器作为线程池服务器运行。

但是，在这种情况下，sendToAll函数通过PrintWriter直接写入与套接字关联的HashMap。服务器不允许您发送到单个协议处理程序类，甚至发送到单个ChatServerWorker类实例。这意味着我不能，例如，仅向套接字1和3发送消息，然后向套接字2发送单独的消息。

我找不到一个在线的例子，可以在不使用extends Thread的情况下调用套接字处理程序的实例。

具体来说，我希望能够使用以下行：

threads[i].out.printf(outputLine);

或

if(threads[i].[class].[var] == 'something') {
// stuff
}

可以使用整数来引用线程实例，或者该线程使用的任何类变量或方法。

我错过了什么吗？

Answer 1

您最大的问题是您将线程本身直接用作Server和Client线程之间的通信层，这是您不应该做的事情。

相反，创建自己的interface Message对象，在线程之间传递不同的信息，并使用LinkedBlockingQueue来处理它们。

你可能应该：

服务器接收消息的一个队列
根据您的实现，每个客户端线程的一个队列用于接收来自服务器的消息，或者一个共享的队列（如果它被设计为任何线程可以处理任何消息）。

所以你可以这样做：

消息：

public interface Message {
  accept(Server server);
}

断开连接消息（我只想做一个）：

public class DisconnectionMessage implements Message {
  String username;

  public void accept(Server server) {
    server.handleMessage(this);
  }
}

Server Runnable：

public void run() {
  while(isServerOnline()) {
    Message clientMessage = queue.poll();
    clientMessage.accept(this);
  }
}

public void handleMessage(DisconnectionMessage msg) {
  // code
}

public void handleMessage(ConnectionMessage msg) {
  // code
}

etc.

客户端可运行：

private final Socket socket;
private final BlockingQueue<Message> queue;

public Client(BlockingQueue<Message> queue, Socket socket) {
  this.queue = queue;
  this.socket = socket;
}

public void run() {
  while(true) {
    Message msg = receiveMessage();
    queue.offer(msg);
  }
}

Answer 2

我不确定我是否理解你的问题。简短的回答：如果你想让clientThread成为Runnable，那就去做吧然后改变行

  (threads[i] = new clientThread(clientSocket, threads)).start();

进入

  (threads[i] = new Thread(new clientThread(clientSocket, threads))).start();

如果查看文档： http://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#Thread(java.lang.Runnable)

线程接受具有Runnable超类型的对象。

答案很长：你不应该直接存储线程，而是在服务器端创建一个表示客户端的抽象。这种抽象应该封装通信功能。这样，如果您想要实现不同的通信库，您可以轻松地将其子类化并避免违反开放原则。

https://en.wikipedia.org/wiki/Open/closed_principle

祝你好运。

如何使用“implements Runnable”调用特定套接字线程中的方法？

2 个答案: