4

大家好

我最近正在开发一个旨在远程关闭浏览器的小程序。基本流程如下:
服务器端:

  1. 创建一个 SocketServer 来监听某个特定的端口。
  2. 接受一个连接并创建一个对应的socket对象
  3. 从创建的套接字中读取 InputStream(在此操作中被阻塞)

客户端:

  1. 创建一个套接字对象以建立与服务器的连接。
  2. 通过将字节写入 OutputStream 来发送关闭服务器端浏览器的命令。
  3. 在套接字的 InputStream 上使用 read() 从服务器读取反馈(在此操作上被阻塞)

下面的代码:

Server.java

package socket;

import java.io.IOException;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Enumeration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Server {

private static ExecutorService es = Executors.newFixedThreadPool(5);

public static void main(String[] args) throws IOException {

    InetAddress targetAddress = null;
    NetworkInterface ni = NetworkInterface.getByName("eth2");
    System.out.println(ni);
    Enumeration<InetAddress> inetAddresses = ni.getInetAddresses();
    while(inetAddresses.hasMoreElements()) {
        InetAddress inetAddress = inetAddresses.nextElement();
        if(inetAddress.toString().startsWith("/10")) {
            targetAddress = inetAddress;
            break;
        }
    }
    ServerSocket sSocket = new ServerSocket(11111, 0, targetAddress);
    while(true) {
        System.out.println("Server is running...");
        Socket client = sSocket.accept();
        System.out.println("Client at: " + client.getRemoteSocketAddress());
        es.execute(new ClientRequest(client));
    }

}
}


客户端请求.java

package socket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class ClientRequest implements Runnable {

private Socket client;

public ClientRequest(Socket client) {
    this.client = client;
}

@Override
public void run() {

    try {
        System.out.println("Handled by: " + Thread.currentThread().getName());
        // get input/output streams for client socket
        InputStream cis = client.getInputStream();
        OutputStream cos = client.getOutputStream();

        // buffer size : 1024 ?
        byte[] buffer = new byte[1024];
        int recvSize;
        int totalRecvSize = 0;
        while(-1 != (recvSize = cis.read(buffer, totalRecvSize, 1024 - totalRecvSize))) {
            totalRecvSize += recvSize;
        }

        String command = new String(buffer, "utf-8");
        System.out.println("Command from client: " + command);

        String commandNative = CommandMap.getNativeCommand(command.trim());
        if(null != commandNative) {
            Process np = Runtime.getRuntime().exec(commandNative);
            InputStream is = np.getInputStream();
            byte[] bufferProcess = new byte[1024];
            int bytesRead;
            int totalBytesRead = 0;
            while(-1 != (bytesRead = is.read(bufferProcess, totalBytesRead, 1024 - totalBytesRead))) {
                totalBytesRead += bytesRead;
            }
            // give feed back of process output
            cos.write(bufferProcess);

            // close process input stream
            is.close();
        } 
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(null != client) {
            try {
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

最后,Client.java

package socket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.Charset;

public class Client {

private static final int BUF_SIZE = 1024;

// feedback message size will not exceed 1024 bytes
private static final byte[] BUFFER = new byte[BUF_SIZE];

public static void main(String[] args) throws UnknownHostException, IOException, InterruptedException {

    Socket socket = new Socket("10.117.37.176", 11111);
    System.out.println("Connected to Server...");
    OutputStream os = socket.getOutputStream();
    InputStream is = socket.getInputStream();

    String command = "kill ie";
    byte[] commandBytes = command.getBytes(Charset.forName("utf-8"));

    System.out.println("Send: " + command);
    os.write(commandBytes);
    System.out.println("After send: " + command);

    int totalRecv = 0;
    int recvSize;

    while(-1 != (recvSize = is.read(BUFFER, totalRecv, BUF_SIZE - totalRecv))) {
        totalRecv += recvSize;
    }

    String feedback = new String(BUFFER, "utf-8");
    System.out.println("Feedback: " + feedback);

    socket.close();
}
}

重申问题:

  • 服务器端无法通过在套接字的 InputStream 对象上调用 read(buffer, offset, len) 来读取命令。它阻塞。
  • 客户端无法通过在其套接字的 InputStream 对象上调用 read(buffer, offset, len) 来读取反馈。它阻塞。
  • 但是当我注释掉Client.java中的反馈读取操作时,Server和Client都可以正常工作。

我想知道这些代码中隐藏的原因是什么?
希望有人可以帮助我,非常感谢!

4

2 回答 2

13

您的套接字读取代码正在读取直到 EOF。在关闭套接字之前,您不会收到 EOF。因此,您的代码永远不会继续。

如果您只想在套接字连接上发送单个命令,则在编写命令后关闭 OutputStream(使用Socket.shutdownOutput())。

如果您想在单个套接字连接上发送多个命令,那么您需要想出一种分隔每个命令的方法(此处为简单示例)。

于 2012-08-30T03:32:57.507 回答
2

您正在阅读直到两端的 EOS,这是一个糟糕的选择,因为您无法“发送” EOS 而不会失去在同一连接上发送更多数据的能力。你需要重新设计你的应用程序协议,这样你就可以一次读取一个命令,而不需要关闭连接来完成它。例如,发送行,或长度字前缀,或诸如 XML 或 Java 对象序列化之类的自描述协议,或者您可以通过 DataInputStream 读取的任何内容,而无需依赖 EOFException。

于 2012-08-30T09:58:28.587 回答