TCP通信

Question

我试图建立我的Java应用程序和相对（进展）的iOS应用程序之间的通信。 插座被打开后，iOS的应用程序（客户端）写一个“握手”字符串转换成流，然后等待读取数据流（我认为）。 当代的Java应用程序（服务器，iOS的应用程序之前启动）成功打开插座和等待的BufferedReader读为“握手”，在这一点上这两个应用程序将被阻止。 我不明白它是如何可能？

按照iOS的代码部分：

public class Client: NSObject, NSStreamDelegate { 

var serverAddress: CFString 
let serverPort: UInt32 = 50000 

private var inputStream: NSInputStream! 
private var outputStream: NSOutputStream! 
private var connecting:Bool 

init(ip:String) { 
    serverAddress = ip 
    connecting = false 

    super.init() 

    connect() 
} 

func connect() { 
    connecting = true 

    while connecting { 
     print("connecting...") 

     var readStream: Unmanaged<CFReadStream>? 
     var writeStream: Unmanaged<CFWriteStream>? 

     CFStreamCreatePairWithSocketToHost(nil, self.serverAddress, self.serverPort, &readStream, &writeStream) 

     // Documentation suggests readStream and writeStream can be assumed to 
     // be non-nil. If you believe otherwise, you can test if either is nil 
     // and implement whatever error-handling you wish. 

     self.inputStream = readStream!.takeRetainedValue() 
     self.outputStream = writeStream!.takeRetainedValue() 

     self.inputStream.delegate = self 
     self.outputStream.delegate = self 

     self.inputStream.scheduleInRunLoop(NSRunLoop.currentRunLoop(), forMode: NSDefaultRunLoopMode) 
     self.outputStream.scheduleInRunLoop(NSRunLoop.currentRunLoop(), forMode: NSDefaultRunLoopMode) 

     self.inputStream.open() 
     self.outputStream.open() 

     // send handshake 

     let handshake: NSData = "handshake".dataUsingEncoding(NSUTF8StringEncoding)! 
     let returnVal = self.outputStream.write(UnsafePointer<UInt8>(handshake.bytes), maxLength: handshake.length) 
     print("written: \(returnVal)") 


     // wait to receive handshake 

     let bufferSize = 1024 
     var buffer = Array<UInt8>(count: bufferSize, repeatedValue: 0) 

     print("waintig for handshake...") 

     let bytesRead = inputStream.read(&buffer, maxLength: bufferSize) 
     if bytesRead >= 0 { 
      var output = NSString(bytes: &buffer, length: bytesRead, encoding: NSUTF8StringEncoding) 
      print("received from host \(serverAddress): \(output)") 
     } else { 
      // Handle error 
     } 

     connecting = false 

     self.inputStream.close() 
     self.outputStream.close() 
    } 


} 

public func stream(stream: NSStream, handleEvent eventCode: NSStreamEvent) { 
    print("stream event") 

    if stream === inputStream { 
     switch eventCode { 
     case NSStreamEvent.ErrorOccurred: 
      print("input: ErrorOccurred: \(stream.streamError?.description)") 
     case NSStreamEvent.OpenCompleted: 
      print("input: OpenCompleted") 
     case NSStreamEvent.HasBytesAvailable: 
      print("input: HasBytesAvailable") 

      // Here you can `read()` from `inputStream` 

     default: 
      break 
     } 
    } 
    else if stream === outputStream { 
     switch eventCode { 
     case NSStreamEvent.ErrorOccurred: 
      print("output: ErrorOccurred: \(stream.streamError?.description)") 
     case NSStreamEvent.OpenCompleted: 
      print("output: OpenCompleted") 
     case NSStreamEvent.HasSpaceAvailable: 
      print("output: HasSpaceAvailable") 

      // Here you can write() to `outputStream` 
      break 

     default: 
      break 
     } 
    } 

} 

}

遵循Java代码的部分（它的其他计算机之间的工作完全使用相同的Java应用程序）：

public void run() 
{ 
    System.out.println("Server.java: waiting for connection"); 

    //accept 
    try 
    { 
     serverSocket = new ServerSocket(portNumber); 
     clientSocket = serverSocket.accept(); 
     reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); 
     writer = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream())); 

     System.out.println("Server.java: connected to " + clientSocket.getInetAddress()); 

     // check for input request type 
     String line = reader.readLine(); // <----BLOCKED HERE! 

     if(line.equals("handshake")) 
     { 
      connected = true; 

      // send acceptation 
      System.out.println("Server.java: Sending handshake, waiting response"); 
      writer.write("handshake"); 
      writer.newLine(); 
      writer.flush(); 

      // .... and the rest of code... 

当我关闭了iOS应用程序从读Java应用程序解锁，打印正确接收到的握手，然后继续自己的工作。 有人可以帮我吗？

Answer 1

我觉得你的问题是，你永远不会结束在斯威夫特程序就行了。

什么的readLine确实根据BufferReader的文档：

“读取一行的文本行被认为是由一个 换行中的任何一个（‘\ n’）被终止，回车（”。 \ r'），或回车后立即换行。“

这意味着它期望换行符或通信结束。由于你的Swift应用程序不会发送任何新行字符，也不会关闭流，客户端只是在等待。

尝试换行（'\ n'）或回车（'\ r'）并查看结果如何。