ServerSocket java-server reads input only once?

I have written a java server and here is the code:

try 
{ 
    ss = new ServerSocket(8080); 
    while (true) 
    { 
        socket = ss.accept(); 
        System.out.println("Acess 开发者_JS百科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()); 
    } 
} 

And an iphone application is the client and there is the code for it:

- (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"];
}

I am having 2 problems here: first is that the server is only reading the input once. The second is that when ever I try to output the data it doesn't output until I have called the method twice (clicked on the uibutton twice). Not sure what is happening here. What am I doing wrong?

You are creating a new reader everytime in your while loop. Instead move the code outside the while loop and block on the readLine() call.

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;
} 

Here is an example server side program.

Since alphazero posted the pattern, I will post a brief stripped down implementation:

This is the Server:

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);
        }

The SocketThread is something like:

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;
            }
        }
}
}

Note: "DataObject" is just a custom class which could be more practical since you can read the Dataobject itself from the socket without worrying about how many bytes you are reading, etc. Only condition is that DataObject is flagged as Serializable.

Hope it helps.

Tushar,

The general pattern is this (almost java but pseudo-code):

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();
}