Question

我有一个用java编写的TCP服务器。我试图通过用dartlang编写的TCP客户端套接字来连接它，但是在初始连接之后几乎立即用dartlang编写的客户端（我在java代码中设置了五秒的超时）。我能够在连接后立即在测试中向dart客户端发送消息，但很快就会超时。但是，dartlang '{"packet_id":1}'中的数据永远不会被服务器接收。

我尝试在dartlang中编写测试服务器，它能够毫无问题地连接和发送/接收消息。

Dart客户：

import 'dart:io';
import 'dart:async';

main(List<String> arguments) {


  Future<Socket> future = Socket.connect('localhost', 12345);
  future.then((client) {
    print('connected to server!');
    client.handleError((data){
      print(data);
    });
    client.listen(
            (data) {
              print(new String.fromCharCodes(data));
            },
            onDone:(){
              print("Done");},
            onError: (error) {
              print(error);
            }
          );
    String requestHalls = '{"packet_id":1}';
    client.write(requestHalls);
  }).catchError(() {print('Error connecting');});
  print('Hello world: ${dart_test.calculate()}!');
}

我的Java客户端很好地连接到Java Server套接字。

编辑：添加java代码

创建serversocket。

@Override
    public void run() {
        // Create Server Socket for clients to connect to
        try {
            // load data from config manager
            ConfigManager config = HDAServer.getConfigManager();
            int port = config.getServerPort();
            String ip = config.getServerURL();
            Inet4Address inet4 = (Inet4Address) Inet4Address.getByName(ip); // this allows for binding to domain name or ipv4 address
            HDAServer.getLogger().info(String.format("Opening Server Socket at address(%s)=  %s:%s", ip, inet4.getHostAddress(), port));
            // attempt to bind
            serverSocket = new ServerSocket(config.getServerPort(), 50, inet4);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // wait for incoming client connections
        waitForConnections();

    }

    /**
     * Method that waits for incoming connections, adds the connection to a new pool, and creates a
     * new thread for the connection to run on.
     */
    private void waitForConnections() {
        // loop through waiting for incoming connections until server shuts down
        while (!shutdown) {
            Socket socket = null;
            try {
                // blocks thread waiting for a connection
                socket = serverSocket.accept();
            } catch (IOException e) {
                if (e.getMessage().equals("socket closed")) {
                    HDAServer.getLogger().info("Shutting Down Server Socket");
                    continue;// skip to while check
                } else {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            // create our connection class, start it in a new thread, and add it to our connection list
            HDAServerConnection newConn = new HDAServerConnection(socket);
            new Thread(newConn).start();
            connections.add(newConn);
            HDAServer.getLogger().info(String.format("Client connected from: %1s", newConn.getRemoteIP()));
            // reap dead connections
            this.reapDeadConnections();
        }
    }

服务器“客户端”HDAConnection类：

protected Socket socket;
protected DataInputStream inputStream;
protected DataOutputStream outputStream;
private boolean shutdown = false;

public HDAConnection(Socket socket) {
    this.socket = socket;

    // configure socket
    try {
        socket.setKeepAlive(true);
        socket.setSoTimeout(5000);
        socket.setTcpNoDelay(true);
    } catch (SocketException ex) {
        AbstractHDALogger.get().severe("Error configuring Socket Connection.", ex);
    }

    // create input/output stream for handling data
    try {
        inputStream = new DataInputStream(socket.getInputStream());
        outputStream = new DataOutputStream(socket.getOutputStream());
    } catch (IOException ex) {
        AbstractHDALogger.get().severe("Error creating input/output streams.", ex);
    }
}

通过流侦听消息的代码。

String response = null;
try {
    response = new BufferedReader(new InputStreamReader(inputStream)).readLine();
} catch(SocketTimeoutException ste) {
    shutdown();
    AbstractHDALogger.get().severe(String.format("Socket Timed out(%s), closing Connection", this.getRemoteIP()), ste);
    // TODO: handle exception
} catch (IOException e) {
    // TODO Make this better?
    // IO Exception probably means client disconnected, so we should terminate.
    if (e.getMessage().equals("Connection reset")) {
        shutdown();
        AbstractHDALogger.get().info(String.format("Client Connection Disconnected(%s). Closing connection.", this.getRemoteIP()));
    } else {
        shutdown();
        AbstractHDALogger.get().severe(String.format("Connection Error(%s), closing Connection", this.getRemoteIP()), e);
    }   
    return null;
}

Answer 1

套接字在Java服务器上超时，因为dartlang客户端永远不会在其消息末尾写入换行符，并且Java Server正在使用readline方法进行读取。此函数仅在读取新行字符时返回。从dartlang客户端读取初始消息后，Java服务器等待五秒钟以发送更多数据，但是会因为没有更多数据发送而超时。

dartlang客户端应使用writeln函数或在其消息末尾添加换行符，以便Java服务器BufferedReader返回。

如何从Dartlang套接字连接到Java套接字

1 个答案: