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

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

main

方法已经执行）

如何维护连接，使其持久化

附言：有没有什么方法可以让它以一种异步的方式工作，更适合我的要求（我不希望服务器总是在

中循环而
）

客户：

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

首先，很抱歉回答得太晚。我也被困在这个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();
    }

并在顶部方法上关闭套接字

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

一旦其中一个程序退出，连接将被清理并关闭。这是一件好事，但只是意味着您需要同时运行这两个程序。让服务器坐在循环中等待
accept（）
返回是简单服务器的标准工作方式。更高级的服务器将使用线程在其自己的线程上处理每个请求，并将具有复杂的线程池等，但在底部，它只是永远循环，位于
accept（）
。查看AsynchronousSocketChannel@SleimanJneidi我查看了它，但找不到简单的工作示例。你能帮我写一个简单的双向交流吗？看看这个@SleimanJneidi看看
异步socketchannel
为什么？