socket实现服务端与客户端的长连接

客户端

package util.socket;


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

/**
 * 客户端
 *
 * @author allron
 * @date 2019-01-23
 */
public class Client {
    /*public static void main(String[] args) {
        Client client = new Client();
        client.startAction();
    }*/

    private void readSocketInfo(BufferedReader reader) {
        new Thread(new MyRuns(reader)).start();
    }

    class MyRuns implements Runnable {

        BufferedReader reader;

        MyRuns(BufferedReader reader) {
            super();
            this.reader = reader;
        }

        public void run() {
            try {
                String lineString;
                while ((lineString = reader.readLine()) != null) {
                    System.out.println(lineString);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }

    public void startAction() {
        Socket socket = null;
        BufferedReader reader = null;
        BufferedWriter writer = null;
        BufferedReader reader2;
        try {
            socket = new Socket("127.0.0.1", 2222);
            reader = new BufferedReader(new InputStreamReader(System.in));
            reader2 = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            readSocketInfo(reader2);
            String lineString;
            while (!(lineString = reader.readLine()).equals("exit")) {
                writer.write(lineString + "\n");
                writer.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
                if (writer != null) {
                    writer.close();
                }
                if (socket != null) {
                    socket.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }
}

服务端

package util.socket;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;


/**
 * 服务端
 *
 * @author allron
 * @date 2019-01-23
 */
public class SocketServer {
    private final static Logger LOGGER = LoggerFactory.getLogger(SocketServer.class);

    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(2222);  //端口号
            LOGGER.info("服务端服务启动监听：");
            //通过死循环开启长连接，开启线程去处理消息
            while (true) {
                Socket socket = serverSocket.accept();//线程阻塞
                new Thread(new MyRuns(socket)).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (serverSocket != null) {
                    serverSocket.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }


    static class MyRuns implements Runnable {

        Socket socket;
        BufferedReader reader;
        BufferedWriter writer;

        public MyRuns(Socket socket) {
            super();
            this.socket = socket;
        }

        public void run() {
            try {
                reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));//读取客户端消息
                writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));//向客户端写消息
                String lineString;

                while (!(lineString = reader.readLine()).equals("bye")) {
                    LOGGER.info("收到来自客户端的发送的消息是：" + lineString);
                    writer.write("服务器返回：" + lineString + "\n");
                    writer.flush();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (reader != null) {
                        reader.close();
                    }
                    if (writer != null) {
                        writer.close();
                    }
                    if (socket != null) {
                        socket.close();
                    }
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
        }
    }
}

注意：此代码会造成线程阻塞，必须等待客户端发送信息才能继续运行。