Java Socket 全双工通信

最开始接触TCP编程是想测试一下服务器的一些端口有没有开，阿里云的服务器，公司的服务器，我也不知道他开了那些端口，于是写个小程序测试一下，反正就是能连上就是开了，

虽然晓得nmap这些东西，但服务器不监听开放的端口，他也检测不到开没开

后来前几天写了个程序，接受TCP请求并解析字节流写入数据库，这其实不难，整个程序就是个半双工模式，就是设备给我发一条消息，我给他回一条

然后就像写个类似QQ这类聊天软件的东西玩玩，百度了半天没找到全双工的例子，那就自己写吧，两天写完了，好开心，有新玩具可以玩了

不解释，直接放代码，感觉注释写的很清楚了

这是服务器的代码

补充一点，可能忘写了，服务器可以主动断开与客户端的连接，例如连接的id是1号，那么输入1:exit，就会断开与id为1的连接

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Set;
import java.util.Map;
import java.util.HashMap;
import java.util.LinkedList;

/**
 * 服务器，全双工，支持单播和广播
 *
 * 注意是全双工，全双工，全双工
 * 
 * 就是像QQ一样
 */
public class Server{
    // 分配给socket连接的id，用于区分不同的socket连接
    private static int id = 0;
    // 存储socket连接，发送消息的时候从这里取出对应的socket连接
    private HashMap<Integer,ServerThread> socketList = new HashMap<>();
    // 服务器对象，用于监听TCP端口
    private ServerSocket server;

    /**
     * 构造函数，必须输入端口号
     */
    public Server(int port) {
        try {
            this.server = new ServerSocket(port);
            System.out.println("服务器启动完成 使用端口: "+port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 启动服务器，先让Writer对象启动等待键盘输入，然后不断等待客户端接入
     * 如果有客户端接入就开一个服务线程，并把这个线程放到Map中管理
     */
    public void start() {
        new Writer().start();
        try {
            while (true) {
                Socket socket = server.accept();
                System.out.println(++id + ":客户端接入:"+socket.getInetAddress() + ":" + socket.getPort());
                ServerThread thread = new ServerThread(id,socket);
                socketList.put(id,thread);
                thread.run();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 回收资源啦，虽然不广播关闭也没问题，但总觉得通知一下客户端比较好
     */
    public void close(){
        sendAll("exit");
        try{
            if(server!=null){
                server.close();
            }
        }catch(IOException e){
            e.printStackTrace();
        }
        System.exit(0);
    }

    /**
     * 遍历存放连接的Map，把他们的id全部取出来，注意这里不能直接遍历Map，不然可能报错
     * 报错的情况是，当试图发送 `*:exit` 时，这段代码会遍历Map中所有的连接对象，关闭并从Map中移除
     * java的集合类在遍历的过程中进行修改会抛出异常
     */
    public void sendAll(String data){ 
        LinkedList<Integer> list = new LinkedList<>();
        Set<Map.Entry<Integer,ServerThread>> set = socketList.entrySet();
        for(Map.Entry<Integer,ServerThread> entry : set){
            list.add(entry.getKey());
        }
        for(Integer id : list){
            send(id,data);
        }
    }

    /**
     * 单播
     */
    public void send(int id,String data){
        ServerThread thread = socketList.get(id);
        thread.send(data);
        if("exit".equals(data)){
            thread.close();
        }
    }

    // 服务线程，当收到一个TCP连接请求时新建一个服务线程
    private class ServerThread implements Runnable {
        private int id;
        private Socket socket;
        private InputStream in;
        private OutputStream out;
        private PrintWriter writer;

        /**
         * 构造函数
         * @param id 分配给该连接对象的id
         * @param socket 将socket连接交给该服务线程
        */
        ServerThread(int id,Socket socket) {
            try{
                this.id = id;
                this.socket = socket;
                this.in = socket.getInputStream();
                this.out = socket.getOutputStream();
                this.writer = new PrintWriter(out);
            }catch(IOException e){
                e.printStackTrace();
            }
        }

        /**
         * 因为设计为全双工模式，所以读写不能阻塞，新开线程进行读操作
        */
        @Override
        public void run() {
            new Reader().start();
        }

        /**
         * 因为同时只能有一个键盘输入，所以输入交给服务器管理而不是服务线程
         * 服务器负责选择socket连接和发送的消息内容，然后调用服务线程的write方法发送数据
         */
        public void send(String data){
            if(!socket.isClosed() && data!=null && !"exit".equals(data)){
                writer.println(data);
                writer.flush();
            }
        }

        /**
         * 关闭所有资源
         */
        public void close(){
            try{
                if(writer!=null){
                    writer.close();
                }
                if(in!=null){
                    in.close();
                }
                if(out!=null){
                    out.close();
                }
                if(socket!=null){
                    socket.close();
                }
                socketList.remove(id);
            }catch(IOException e){
                e.printStackTrace();
            }
        }

        /**
         * 因为全双工模式所以将读操作单独设计为一个类，然后开个线程执行
         */
        private class Reader extends Thread{
            private InputStreamReader streamReader = new InputStreamReader(in);
            private BufferedReader reader = new BufferedReader(streamReader);

            @Override
            public void run(){
                try{
                    String line = "";
                    // 只要连接没有关闭，而且读到的行不为空，为空说明连接异常断开，而且客户端发送的不是exit，那么就一直从连接中读
                    while(!socket.isClosed() && line!=null && !"exit".equals(line)){
                        line=reader.readLine();
                        if(line!=null){
                            System.out.println(id+":client: "+line);
                        }
                    }
                    // 如果循环中断说明连接已断开
                    System.out.println(id+":客户端主动断开连接");
                    close();
                }catch(IOException e) {
                    System.out.println(id+":连接已断开");
                }finally{
                    try{
                        if(streamReader!=null){
                            streamReader.close();
                        }
                        if(reader!=null){
                            reader.close();
                        }
                        close();
                    }catch(IOException e){
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 因为发送的时候必须指明发送目的地，所以不能交给服务线程管理写操作，不然就无法选择向哪个连接发送消息
     * 如果交给服务线程管理的话，Writer对象的会争夺键盘这一资源，谁抢到是谁的，就无法控制消息的发送对象了
     */
    private class Writer extends Thread{
        // 我们要从键盘获取发送的消息
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        
        @Override
        public void run(){
            String line = "";
            // 先来个死循环，除非主动输入exit关闭服务器，否则一直等待键盘写入
            while(true){
                try{
                    line = reader.readLine();
                    if("exit".equals(line)){
                        break;
                    }
                }catch(IOException e){
                    e.printStackTrace();
                }
                // 输入是有规则的 [连接id]:[要发送的内容]
                // 连接id可以为*，代表所有的连接对象，也就是广播
                // 要发送的内容不能为空，发空内容没意义，而且浪费流量
                // 连接id和要发送的消息之间用分号分割，注意是半角的分号
                // 例如： 1:你好    ==>客户端看到的是 server:你好
                //       *:吃饭了  ==>所有客户端都能看到 server:吃饭了
                if(line!=null){
                    try{
                        String[] data = line.split(":");
                        if("*".equals(data[0])){
                            // 这里是广播
                            sendAll(data[1]);
                        }else{
                            // 这里是单播
                            send(Integer.parseInt(data[0]),data[1]);
                        }
                        // 有可能发生的异常
                    }catch(NumberFormatException e){
                        System.out.print("必须输入连接id号");
                    }catch(ArrayIndexOutOfBoundsException e){
                        System.out.print("发送的消息不能为空");
                    }catch(NullPointerException e){
                        System.out.print("连接不存在或已经断开");
                    }
                }
            }
            // 循环中断说明服务器退出运行
            System.out.println("服务器退出");
            close();
        }
    }

    public static void main(String[] args) {
        int port = Integer.parseInt(args[0]);
        new Server(port).start();
    }
}

这是客户端的代码

import java.io.*;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * 客户端 全双工 但同时只能连接一台服务器
 */
public class Client {
    private Socket socket;
    private InputStream in;
    private OutputStream out;

    /**
     * 启动客户端需要指定地址和端口号
     */
    private Client(String address, int port) {
        try {
            socket = new Socket(address, port);
            this.in = socket.getInputStream();
            this.out = socket.getOutputStream();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("客户端启动成功");
    }

    public void start(){
        // 和服务器不一样，客户端只有一条连接，能省很多事
        Reader reader = new Reader();
        Writer writer = new Writer();
        reader.start();
        writer.start();
    }

    public void close(){
        try{
            if(in!=null){
                in.close();
            }
            if(out!=null){
                out.close();
            }
            if(socket!=null){
                socket.close();
            }
            System.exit(0);
        }catch(IOException e){
            e.printStackTrace();
        }
    }

    private class Reader extends Thread{
        private InputStreamReader streamReader = new InputStreamReader(in);
        private BufferedReader reader = new BufferedReader(streamReader);

        @Override
        public void run(){
            try{
                String line="";
                while(!socket.isClosed() && line!=null && !"exit".equals(line)){
                    line=reader.readLine();
                    if(line!=null){
                        System.out.println("Server: "+line);
                    }
                }
                System.out.println("服务器主动断开连接");
                close();
            }catch(IOException e){
                System.out.println("连接已断开");
            }finally{
                try{
                    if(streamReader!=null){
                        streamReader.close();
                    }
                    if(reader!=null){
                        reader.close();
                    }
                    close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

    private class Writer extends Thread{
        private PrintWriter writer = new PrintWriter(out);
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        @Override
        public void run(){
            try{
                String line = "";
                while(!socket.isClosed() && line!=null && !"exit".equals(line)){
                    line = reader.readLine();
                    if("".equals(line)){
                        System.out.print("发送的消息不能为空");
                    }else{
                        writer.println(line);
                        writer.flush();
                    }
                }
                System.out.println("客户端退出");
                close();
            }catch(IOException e){
                System.out.println("error:连接已关闭");
            }finally{
                try{
                    if(writer!=null){
                        writer.close();
                    }
                    if(reader!=null){
                        reader.close();
                    }
                    close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
       String address = args[0];
       int port = Integer.parseInt(args[1]);
       new Client(address, port).start();
    }
}

无聊的时候就自己和自己聊天吧

感觉在这基础上可以搭个http服务器什么的了

 

然后就可以输入要返回的信息了，输入完断开客户端连接就好了，就是 2:exit，然后浏览器就能看到返回的信息了，不过貌似没有响应头，只有响应正文

/*

这里什么都没写

还有服务器或者客户端添加个执行远程命令什么的方法。。。。。。

别老想坏事，没开SSH的服务器远程执行个运维脚本什么的也不错啊，尤其是Win的服务器

其实我一直想弄个远程部署Tomcat项目的东西，最好是热部署，不然每次都要用FTP上传war

但是Windows服务器不会玩

*/

目前已知Bug:

当一方（不论是客户端还是服务器）输入消息后但没有发出，但此时接受到另一方发来的消息，显示会出现问题

因为输入的字符还在缓冲区中，所以会看到自己正在写的字符和发来的字符拼到了一行

左边是服务器，右边是客户端

客户端输入了 `测试一下` 但没有发出，服务器此时发送一条消息 `这里是服务器` 于是就发生了右图的情况

然后客户端发送消息，服务器收到 `测试一下`，发送前再输入字符不会影响到服务器接受到的消息，

例如在上述情况下，客户端收到服务器的消息后，在输入`我还没说完` 然后再发送，服务器会收到 `测试一下我还没说完`

也就是说只是客户端要发送的消息，显示上会与服务器发来的消息显示在一行，而且再输入字符会折行

如果谁知道怎么弄请告诉我一下