简单的socket程序

/**
 * 实现要求：
 * 1、根据代码片段实现一个简单的SOCKET ECHO程序；
 * 2、接受到客户端连接后，服务端返回一个欢迎消息;
 * 3、接受到"bye"消息后， 服务端返回一个结束消息，并结束当前连接;
 * 4、采用telnet作为客户端，通过telnet连接本服务端；
 * 5、服务端支持接受多个telnet客户端连接;
 * 6、服务端支持命令操作，支持查看当前连接数、断开指定客户端连接；
 * 
 */

涉及到的知识点：

1. socket客户端服务端
2. 多线程
3. 数据读写IO流

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.*;

/**
 * @author xienl
 * @description
 * @date 2022/5/18
 */

public class Solution2 {

    // 服务端启动后，运行结果示例：
    /**
     java -cp ./classes EchoApplication

     2020-03-31 16:58:44.049 - Welcome to My Echo Server.(from SERVER)
     The current connections:
     Id.   Client    LogonTime
     -----------------------------------------------------
     1   127.0.0.1:32328  2020-03-31 16:59:13
     2   127.0.0.1:43434  2020-03-31 17:03:02
     3   127.0.0.1:39823  2020-03-31 07:03:48

     Enter(h for help): h
     The commands:
     ----------------------------------------------------
     q  query current connections
     d id  disconnect client
     x  quit server
     h  help

     Enter(h for help): d 1
     2020-03-31 16:58:44.049 - The connection '127.0.0.1:32328' has been disconnected.
     The current connections:
     Id.   Client    LogonTime
     -----------------------------------------------------
     1   127.0.0.1:43434  2020-03-31 17:03:02
     2   127.0.0.1:39823  2020-03-31 07:03:48

     Enter(h for help): x
     2020-03-31 16:58:44.049 - The server has exited. Bye!
     */

    // 在telnet控制台输入，服务端直接原文返回输入信息
    // 客户端结果示例：
    /**
     2020-03-31 16:58:44.049 - Welcome to My Echo Server.(from SERVER)

     Enter: hello!
     2020-03-31 16:58:55.452 - hello!(from SERVER)

     Enter: This is KOAL.
     2020-03-31 16:59:06.565 - This is KOAL.(from SERVER)

     Enter: What can i do for you?
     2020-03-31 16:59:12.828 - What can i do for you?(from SERVER)

     Enter: bye!
     2020-03-31 16:59:16.502 - Bye bye!(from SERVER)
     */


    /**
     * 实现要求：
     * 1、根据代码片段实现一个简单的SOCKET ECHO程序；
     * 2、接受到客户端连接后，服务端返回一个欢迎消息;
     * 3、接受到"bye"消息后， 服务端返回一个结束消息，并结束当前连接;
     * 4、采用telnet作为客户端，通过telnet连接本服务端；
     * 5、服务端支持接受多个telnet客户端连接;
     * 6、服务端支持命令操作，支持查看当前连接数、断开指定客户端连接；
     * 
     */

    public static void main(String[] args) throws IOException, InterruptedException {

        final int listenPort = 12345;

        // 启动服务端
        EchoServer server = new EchoServer(listenPort);
        server.startService();

    }

}

class TestClient{
    public static void main(String[] args) {
        final int listenPort = 12345;
        EchoClient client = new EchoClient(listenPort);
        client.startClient();
    }
}


class EchoServer { // 服务器

    private int port;
    public EchoServer(int listenPort){
        this.port = listenPort;
    }

    public void startService(){
        ServerSocket serverSocket = null;
        Socket accept = null;
        BufferedReader info = null;
        Map<Integer, Thread> map = new HashMap<>();
        Scanner scanner = new Scanner(System.in);
        new Thread(() ->{
            while (true){
                // 功能支持
                System.out.println("支持功能， 1：查看连接 2：断开连接");
                int num = scanner.nextInt();
                if (num == 1){
                    System.out.println(map.keySet().toString());
                } else if (num == 2){
                    System.out.println("请输入你要断开的连接");
                    scanner.nextLine();
                    int name = scanner.nextInt();
                    if (map.containsKey(name)){
                        map.get(name).stop();
                        map.remove(name);
                        System.out.println("断开成功");
                    } else {
                        System.out.println("没有这个连接，断开失败");
                    }
                }
            }
        }, "功能线程").start();


        try {
            serverSocket = new ServerSocket(port);
            System.out.println("欢迎，客户端启动成功");


            while (true){
                accept = serverSocket.accept();
                if (!map.containsKey(accept.getPort())){
                    // 加入到数据集中
                    System.out.println("欢迎，欢迎");
                    SocketThread socketThread = new SocketThread(accept);
                    socketThread.setName(accept.getPort() +"");
                    socketThread.start();
                    map.put(accept.getPort(), socketThread);
                }

                Thread.sleep(1000);
            }

        } catch (Exception e) {
            System.out.println("连接失败，请重试");
        } finally {
            try {
                serverSocket.close();
                accept.close();
                info.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}


class EchoClient { // 客户端
    Socket socket = null;
    PrintWriter out = null;
    BufferedReader in = null;
    String serverIP = "127.0.0.1";    //服务器端ip地址
    int port ;    //服务器端端口号

    public EchoClient(int port){
        this.port = port;
    }

    public EchoClient(String serverIp, int port){
        this.port = port;
        this.serverIP = serverIp;
    }

    public void startClient(){
        try {
            Scanner scanner = new Scanner(System.in);
            socket = new Socket(serverIP, port);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(), true);
            while (true) {
                String str = scanner.nextLine();
                System.out.println("客户端正在发送的内容为：" + str);
                out.println(str);
                if (str.equals("bye")){
                    break;
                }
                Thread.sleep(1000);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class SocketThread extends Thread{
    public Socket socket;

    public SocketThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        PrintWriter pw = null;
        Calendar c;


        try {
            while(true)
            {
                Thread.sleep(1000);
                BufferedReader info = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String str = info.readLine();
                System.out.println("接收客户端发送的消息： " + str);

            }

        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        } finally {
            try {
                if (pw != null) {
                    pw.close();
                }
                if (socket != null) {
                    socket.close();
                }
            } catch (Exception ex) {
                System.out.println(ex.getMessage());
            }
        }
    }
}

可以启动客户端和服务端玩玩哈，挺有意思的。