ServerSocket java-server只读取输入一次？

Question

我已经编写了一个java服务器，代码如下：

try 
{ 
    ss = new ServerSocket(8080); 
    while (true) 
    { 
        socket = ss.accept(); 
        System.out.println("Acess given");

        in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 

        //out = new PrintWriter(socket.getOutputStream(),true); 

        line = in.readLine(); 
        System.out.println("you input is :" + in.readLine()); 
    } 
} 

iphone应用程序就是客户端，下面是它的代码：

- (void)viewDidLoad {
    [super viewDidLoad];

    socket = [[LXSocket alloc]init];

    if ([socket connect:@"10.211.55.2" port:8080]) {
        NSLog(@"socket has been created");
    }
    else {
        NSLog(@"socket couldn't be created created");
    }

    @try {


    }@catch (NSException * e) {
        NSLog(@"Unable to send data");
    }

    [super viewDidLoad];
}

-(IBAction)sendData{
    [socket sendString:@"A\n"];
}

我这里有两个问题:第一个问题是服务器只读取输入一次。第二个问题是，当我试图输出数据时，它直到我调用该方法两次(点击on按钮两次)后才会输出。不确定这里发生了什么。我做错了什么？

Answer 1

每次在while循环中都会创建一个新的阅读器。相反，将代码移到while循环之外，并阻塞readLine()调用。

socket = ss.accept();
in = new BufferedReader(new InputStreamReader(socket.getInputStream());
String line = "";
while ( true) { 
    line = in.readLine();
    System.out.println("you input is :" + line); 
    if ( "Bye".equals(line) ) 
        break;
} 

下面是一个example服务器端程序。

Answer 2

由于alphazero发布了这个模式，我将发布一个简短的简化实现：

这是服务器：

try {
            ServerSocket ss = new ServerSocket(portNumber);
            logger.info("Server successfully started on port " + portNumber);
            // infinite loop that waits for connections
            while (true) {
                SocketThread rst = new SocketThread(ss.accept());
                rst.start();

            }
        } catch (IOException e) {
            logger.info("Error: unable to bind to port " + portNumber);
            System.exit(-1);
        }

SocketThread类似于：

public class SocketThread extends Thread {
private Socket communicationSocket = null;
public SocketThread(Socket clientSocket) {
communicationSocket = clientSocket;
try {
            input = new ObjectInputStream(communicationSocket.getInputStream());

        } catch (IOException e) {
            logger.info("Error getting communication streams to transfer data.");
            try {
                communicationSocket.close();
            } catch (IOException e1) {

                e1.printStackTrace();
            }
        }
}

public void run() {
boolean listening=true;
        DataObject command = null;
        while (listening) {
            try {
                Object currentObject = input.readObject();
                if (currentObject != null
                        && currentObject instanceof DataObject) {
                    command = (DataObject) currentObject;
                }
            } catch (IOException e) {
                e.printStackTrace();

            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } finally {
// If we got to this point is because we received a request from
// the client
// we can exit the loop 
                listening = false;
            }
        }
}
}

注意：" Dataobject“只是一个自定义类，它可能更实用，因为您可以从套接字读取数据对象本身，而不必担心正在读取的字节数等。唯一的条件是DataObject被标记为可序列化的。

希望能有所帮助。

Answer 3

图沙尔

一般的模式是这样的(几乎是java，但是是伪代码)：

while (server-socket is accepting new connections) 
{
    // The server-socket's job is to listen for connection requests
    // It does this typically in a loop (until you issue server-shutdown)
    // on accept the server-socket returns a Socket to the newly connected client
    //
    socket s = server-socket.accept-connection();

    // various options here:
    //
    // typically fire off a dedicated thread to servie this client
    // but also review NIO or (home-grown) connection-map/handler patterns
    // the general pattern:
    // create a dedicated thread per connection accepted.
    // pass Socket (s) to the handler method (a Runnable) and start it off
    // and that is it.

    // Here we use the general pattern and create a dedicated 
    // handler thread and pass of the new connections' socket reference
    //
    Thread handler-thread = new Thread (handler-routine-as-runnable, s);
    handler-thread.start();
}