如何使客户端服务器Java应用程序在一个端口上发送消息，而在另一个端口上接收消息？

Question

I am currently trying to make an application that will send messages to a server using one port, but will receive messages on another port. However, based on tutorials I have followed, it looks like the act of connecting to the server is where ports come into play and my client is receiving and sending messages on the same port. How do I make it so it sends on one port but receives on the other?

Here is the code that I think is relevant from the client side (I put some stuff that seems unrelated because I think they are things that would be altered by receiving on one port but sending on another, and ignore the comment about replacing inetaddress, that is just me working on implementing this in a gui):

public void startRunning(){
    try{
        connectToServer();
        setupStreams();
        whileChatting();

    }catch(EOFException eofException){
        showMessage("\n Client terminated connection");

    }catch(IOException ioException){
        ioException.printStackTrace();
    }finally{
        closeStuff();
    }

}



//connect to server
private void connectToServer() throws IOException{
    showMessage("Attempting connection... \n");
    connection = new Socket(InetAddress.getByName(serverIP), 480);//replace serverIP with ipTextField.getText or set serverIP to equal ipTextField.getText? Same with port number.
    showMessage("Connected to:  " + connection.getInetAddress().getHostName() );
}


//set up streams to send and receive messages
private void setupStreams() throws IOException{
    output = new ObjectOutputStream(connection.getOutputStream());
    output.flush();
    input = new ObjectInputStream(connection.getInputStream());
    showMessage("\n Streams are good!  \n");
}


//while talking with server
private void whileChatting() throws IOException{
    ableToType(true);
    do{
        try{
            message = (String) input.readObject();
            showMessage("\n" + message);
        }catch(ClassNotFoundException classNotfoundException){
            showMessage("\n Don't know that object type");
        }

    }while(!message.equals("SERVER - END"));
}

//send messages to server
private void sendMessage(String message){
    try{
        output.writeObject("CLIENT - " + message);
        output.flush();
        showMessage("\nCLIENT - " + message);
    }catch(IOException ioException){
        messageWindow.append("\n something messed up ");
    }

}


//change/update message window
private void showMessage(final String m){
    SwingUtilities.invokeLater(
        new Runnable(){
            public void run(){
                messageWindow.append(m);
            }
        }
    );

}

EDIT/UPDATE: To help clarify some things, here is some more information. The device that sends the first message is connected to a sensor, and it sends information when that sensor detects something to the other device. The receiving device sends a message back on a different port telling the original sending device how to respond. Lets name these two devices the "reporter-action taker" and the "decision maker-commander".

Answer 1

If you want to use TCP/IP sockets you can't use aa socket to send and another to read. That's not what they are for.

If you use a centralized distributed algorithm (server/client communication) you have to set the server to listen on a single socket port with the ServerSocket class: then the server tries to accept clients through that socket.

Example:

ServerSocket listener = new ServerSocket(Port)
While (true) {
    new Clienthandler(listener.accept());
}

The server will listen on that port, and when a client tries to connect to that port if it is accepted the server launches its handler. On this handler constructor the Socket object used on the client is received on an argument and can then be used to get the writers and the readers. The reader on this handler class will be the writer on the client class and vice-versa, maybe that's what you were looking for.

Answer 2

Your question about using two ports in this manner is a bit strange. You state that you have a client and a server and that they should communicate on different ports.

Just to clarify picture the server as a hanging rack for jackets with several hooks in a row. Each port the server listened on represents a hook. When it comes to the client server relationship the client or jacket knows where to find its hook, however the hook is blind and have no idea where to find jackets.

Now, the client selects a port or a hook and connects to it. The connection is like a pipeline with two pipes. One for the client to deliver data to the server with and the other to send data from the server back to the client. When the connection is established data can be transferred both ways. This means that we only need one port open on the server to send data both from the client to the server and in the opposite direction.

The reason for only having one open port open on the server for the clients to connect to is that holding an open port for connections is hard to do on a regular client computer. The normal desktop user will be behind several firewalls blocking incoming connections. If that wasn't the case the client would probably be hacked senseless from malicious viruses.

Moving on with the two port solution we could not call this a client server connection per say. It would be more like a peer to peer connection or something like that. But if this is what you want to do, the application connecting first would have to start by telling the other application what ip and port to use for connecting back, it should probably also want to give some kind of token that are to be used to pair the new incoming connection when connecting back.

You should take note that making such an implementation is not a good idea most of the time as it complicates things a whole lot for simple data transfer between a client and server application.