Java中的持久客户端-服务器套接字连接

Question

我正在尝试在 Java 中建立双向通信。为此，我创建了一个简单的客户端-服务器程序（我什至不确定这是否是正确的方法，因为它们都被视为客户端！）。我的要求是，一旦两个程序连接起来，它们应该保持连接，并且能够偶尔发送消息。但是，目前我的套接字在发送数据后终止（客户端的main 方法已执行）。

如何保持连接，使其持久化？

P.S：有什么方法可以让它以异步方式工作，可能更适合我的要求（我不希望服务器总是在 while 内循环）？

客户：

package test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class EchoClient2 {
    String serverHostname = new String("127.0.0.1");
    BufferedReader stdIn;
    Socket echoSocket = null;
    PrintWriter out = null;
    BufferedReader in = null;

    public void open(){
        System.out.println("Attemping to connect to host " + serverHostname
                + " on port 9999.");
        try {
            echoSocket = new Socket(serverHostname, 9999);
            out = new PrintWriter(echoSocket.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(
                    echoSocket.getInputStream()));
        } catch (UnknownHostException e) {
            System.err.println("Don't know about host: " + serverHostname);
        } catch (IOException e) {
            System.err.println("Couldn't get I/O for " + "the connection to: "
                    + serverHostname);
        }
    }

    public void send(String s){
        out.println(s);
    }

    public String receive(){
        String result = "";
        try {
            result = in.readLine();
            System.out.println("client received: "+result);
            if(result==null)
                return "0";
        } catch (IOException e) {
        }
        return result;
    }


    public static void main(String[] args) {
        EchoClient2 ec = new EchoClient2();
        ec.open();
        ec.send("1");
        ec.receive();
    }
}

服务器：

package test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class EchoServer extends Thread {
    protected Socket clientSocket;

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = null;

        try {
            serverSocket = new ServerSocket(9999);
            System.out.println("Connection Socket Created");
            try {
                while (true) {
                    System.out.println("Waiting for Connection");
                    new EchoServer(serverSocket.accept());
                }
            } catch (IOException e) {
                System.err.println("Accept failed.");
                System.exit(1);
            }
        } catch (IOException e) {
            System.err.println("Could not listen on port: 9999.");
            System.exit(1);
        } finally {
            try {
                serverSocket.close();
            } catch (IOException e) {
                System.err.println("Could not close port: 9999.");
                System.exit(1);
            }
        }
    }

    private EchoServer(Socket clientSoc) {
        clientSocket = clientSoc;
        start();
    }

    public void run() {
        System.out.println("New Communication Thread Started");

        try {
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),
                    true);
            BufferedReader in = new BufferedReader(new InputStreamReader(
                    clientSocket.getInputStream()));

            String inputLine;

            while ((inputLine = in.readLine()) != null) {
                System.out.println("Server received: " + inputLine);
                out.println(inputLine);

                if (inputLine.equals("Bye."))
                    break;
            }

//          out.close();
//          in.close();
//          clientSocket.close();
        } catch (IOException e) {
            System.err.println("Problem with Communication Server");
            System.exit(1);
        }
    }
}

Answer 1

首先对迟到的答案感到抱歉。我也被困在这个java套接字编程中。我还想打开一个套接字并保持它打开以供客户端和服务器之间进行通信。在搜索和阅读了许多书籍和文章之后，我找到了最简单的解决方案。您可以在 android 生命周期中为您的工作使用

在 onStart 方法上打开套接字

  protected void onStart() {
        super.onStart();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    client = new Socket(ip,Integer.valueOf(port) );
                    client.setKeepAlive(true);

                   dataInputStream = new DataInputStream(client.getInputStream());
                  //  readdata=readdata+" "+dataInputStream.readUTF();

                    readdata=dataInputStream.readUTF();
                }
                catch (Exception e){
                    e.printStackTrace();
                }
            }
        }).start();
    }

并在 onStop 方法上关闭套接字

 protected void onStop() {
        super.onStop();
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }