多客户端之间的通信

不念不忘少年蓝@ 2021-11-11 16:01 360阅读 0赞

实现多个客户端之间的通信：

使用TCP协议实现的方案是：客户端的数据包通过服务器中转，发送到另一个客户端

如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70][]

![20190806085944323.png][]

![20190806092228439.png][]

![20190806134335236.png][]

package com.vince.communication;
    import java.io.Serializable;
    
    /**
     * 消息包
     */
    //传输用的是流，可以用序列化对象名进行传输 Serializable:序列化
    public class Message implements Serializable {
        private String from;//发送者
        private String to; //接收者
        private int type;//消息类型
        private String info; //消息
    
        public String getFrom() {
            return from;
        }
    
        public void setFrom(String from) {
    
            this.from = from;
        }
    
        public String getTo() {
            return to;
        }
    
        public void setTo(String to) {
            this.to = to;
        }
    
        public int getType() {
            return type;
        }
    
        public void setType(int type) {
            this.type = type;
        }
    
        public String getInfo() {
            return info;
        }
    
        public void setInfo(String info) {
            this.info = info;
        }
    
        public Message(String from, String to, int type, String info) {
            this.from = from;
            this.to = to;
            this.type = type;
            this.info = info;
        }
    
        public Message() {
        }
    
        @Override
        public String toString() {
            return "Message{" +
                    "from='" + from + '\'' +
                    ", to='" + to + '\'' +
                    ", type=" + type +
                    ", info='" + info + '\'' +
                    '}';
        }
    }

![2019080613444850.png][]

package com.vince.communication;
    //消息类型
    public final class MessageType {
      public static final int TYPE_LOGIN = 0x1;//登陆消息类型
      public static final int TYPE_SEND = 0x2;//发送消息的类型(转发给其它客户端)
    }

![20190806134531616.png][]

package com.vince.communication;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.net.Socket;
    import java.util.Scanner;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Client {
        public static void main(String[] args) {
            //客户端输入
            Scanner input = new Scanner(System.in);
            //单线程
            ExecutorService es = Executors.newSingleThreadExecutor();
    
            try {
          //1.客户端向服务器发送信息
                //创建Socket对象
                Socket socket = new Socket("localhost", 8888);
                System.out.println("服务器连接成功");
                ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                //向服务器发送登陆信息
                System.out.println("请输入名称：");
                String name = input.nextLine();
                Message msg = new Message(name, null, MessageType.TYPE_LOGIN, null);
                oos.writeObject(msg);
         //6.客户端读取，将欢迎信息输出出来
                msg = (Message) ois.readObject();
                System.out.println(msg.getInfo() + msg.getFrom());
    
           //2.启动读取消息的线程
                es.execute(new ReadInfoThread(ois));
    
           //3.使用主线程来实现发送消息
                boolean flag = true;
                while (flag) {
                    msg = new Message();
                    System.out.println("To:");
                    msg.setTo(input.nextLine());
                    msg.setFrom(name);
                    msg.setType(MessageType.TYPE_SEND);
                    System.out.println("info:");
                    msg.setInfo(input.nextLine());
                    oos.writeObject(msg);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    
    //读取信息
    class ReadInfoThread implements Runnable {
        private ObjectInputStream in;
        private boolean flag = true;
    
        public ReadInfoThread(ObjectInputStream in) {
    
            this.in = in;
        }
    
        public void setFlag(boolean flag) {
    
            this.flag = flag;
        }
    
        @Override
        public void run() {
            try {
                while (flag) {
    
                    Message message = (Message) in.readObject();
                    System.out.println("[" + message.getFrom() + "]对我说：" + message.getInfo());
                }
                if (in != null) {
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

![20190806134705303.png][]

package com.vince.communication;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.Vector;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * 服务器端
     */
    public class Server {
        public static void main(String[] args) {
      //4.集合：保存客户端处理的所有的线程(保存在服务器端产生的所有的线程/任务)
            Vector<UserThread> vector = new Vector<>();
    
            //定义线程池
            ExecutorService es = Executors.newFixedThreadPool(5);
    
            //创建服务器端的Socket
            try {
                ServerSocket server = new ServerSocket(8888);
                System.out.println("服务器已经启动，正在等待连接......");
                while (true) {
                    //每对应一个socket,就创建一个UserThread对象
                    Socket socket = server.accept();
                    //创建用户线程
                    UserThread user = new UserThread(socket, vector);
        //5.启动线程
                    es.execute(user);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    //客户端处理的线程
    class UserThread implements Runnable {
        private String name; //客户端的用户名称(唯一)
        private Socket socket;//当前socket
        Vector<UserThread> vector;//客户端处理线程的集合
        private ObjectInputStream ois;
        private ObjectOutputStream oos;
        private boolean flag = true; //循环的标记
    
        public UserThread(Socket socket, Vector<UserThread> vector) {
            this.socket = socket;
            this.vector = vector;
            //将当前的user对象添加到vector里面去
            vector.add(this);
        }
    
        //启动线程
        @Override
        public void run() {
            try {
                //构造相关的流
                System.out.println("客户端" + socket.getInetAddress().getHostAddress() + "已连接");
                ois = new ObjectInputStream(socket.getInputStream());
                oos = new ObjectOutputStream(socket.getOutputStream());
    
                while (flag) {
                    //循环读取消息对象
                    Message msg = (Message) ois.readObject();
                    //取类型进行判断
                    int type = msg.getType();
                    switch (type) {
                        case MessageType.TYPE_SEND:
                            String to = msg.getTo();
                            UserThread ut;
                            int size = vector.size();
                            for (int i = 0; i < size; i++) {
                                ut = vector.get(i);
             //7.发送者的名称跟线程里面的名称是否相同，并且不是自己
                                if (to.equals(ut.name) && ut != this) {
                                    ut.oos.writeObject(msg);//写到线程里面去
                                    break;
                                }
                            }
                            break;
                        case MessageType.TYPE_LOGIN:
                            name = msg.getFrom();
                            msg.setInfo("欢迎您：");
                            oos.writeObject(msg);
                            break;
                        }
                }
                ois.close();
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

![20190806130644673.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 2][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70]: /images/20211109/0312f47f4dd24df380d182be835126f5.png
[20190806085944323.png]: /images/20211109/b729af93c17e47bca7847e80ff4fc9d3.png
[20190806092228439.png]: /images/20211109/f79acb4317fc49d190e1a4d6f9e1cc83.png
[20190806134335236.png]: /images/20211109/0325c84992284459a854f9366dc48434.png
[2019080613444850.png]: /images/20211109/b14208b588134d12af03bcbdfbb2625c.png
[20190806134531616.png]: /images/20211109/1d4a0f54321f4004bcebfb4483e8f1fe.png
[20190806134705303.png]: /images/20211109/d1ede981b7324e23a77176b1d733a36d.png
[20190806130644673.png]: /images/20211109/40dc789316384a2ba60eff612466f8fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 1]: /images/20211109/ad7559e36e7f4055afbb526eb5dcc4f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pzMTM0MjA4NDc3Ng_size_16_color_FFFFFF_t_70 2]: /images/20211109/9ed4d5c99d41447e83b540bc440a6de3.png