Java项目之畅聊系统

深碍√TFBOYSˉ_ 2024-04-17 22:11 18阅读 0赞

## 一、客户端 ##

### 1.基础DAO操作 ###

封装基础dao操作，获取数据源，连接，关闭资源等

public class BaseDao{ 
        private static DruidDataSource dataSource;
    
        static { 
            Properties properties = CommUtils.
                    loadProperties("datasource.properties");
            try { 
                dataSource = (DruidDataSource) DruidDataSourceFactory.
                        createDataSource(properties);
            } catch (Exception e) { 
                System.err.println("数据源加载失败");
                e.printStackTrace();
            }
        }
        //获取连接
        protected DruidPooledConnection getConnection(){ 
            try { 
                return (DruidPooledConnection) dataSource.getPooledConnection();
            } catch (SQLException e) { 
                System.out.println("数据库连接获取失败");
                e.printStackTrace();
            }
            return null;
        }
        //关闭资源
        protected void closeResource(Connection connection, Statement statement){ 
            if (connection != null){ 
                try { 
                    connection.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
            }
            if (statement !=null){ 
                try { 
                    statement.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
            }
        }
        protected void closeResource(Connection connection, Statement statement,
                                     ResultSet resultSet){ 
            closeResource(connection,statement);
            if (resultSet != null){ 
                try { 
                    resultSet.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
            }
        }
    }
    
    //------------------------实体类------------------------------
    public class AccountDao extends BaseDao{ 
        //注册方法 insert
        public boolean userReg(User user){ 
            Connection connection = null;
            PreparedStatement statement = null;
            try { 
                connection = getConnection();
                String sql = "insert into user(username, password, brief)"+
                        " values (?,?,?)";
                statement = connection.prepareStatement(sql,
                        Statement.RETURN_GENERATED_KEYS);
                statement.setString(1,user.getUsername());
                statement.setString(2,DigestUtils.md5Hex(user.getPassword()));
                statement.setString(3,user.getBrief());
                int row = statement.executeUpdate();
                if (row == 1)
                    return true;
            } catch (SQLException e) { 
                System.err.println("用户注册失败");
                e.printStackTrace();
            }finally { 
                closeResource(connection,statement);
            }
            return false;
        }
        //登陆
        public User userLogin(String userName,String passWord){ 
            Connection connection = null;
            PreparedStatement statement = null;
            ResultSet resultSet = null;
            try { 
                connection = getConnection();
                String sql = "select * from user where username = ? and password = ?;";
                statement = connection.prepareStatement(sql);
                statement.setString(1,userName);
                statement.setString(2,DigestUtils.md5Hex(passWord));
                resultSet = statement.executeQuery();
                if (resultSet.next()){ 
                    User user = getUser(resultSet);
                    return user;
                }
            } catch (SQLException e) { 
                System.err.println("用户登陆失败");
                e.printStackTrace();
            }finally { 
                closeResource(connection,statement,resultSet);
            }
            return null;
        }
        private User getUser(ResultSet resultSet) throws SQLException { 
            User user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUsername(resultSet.getString("username"));
            user.setPassword(resultSet.getString("password"));
            user.setBrief(resultSet.getString("brief"));
            return user;
        }
    }

### 2.用户实体类 ###

public class User { 
        private Integer id;
        private String username;
        private String password;
        private String brief;
    
        public Integer getId() { 
            return id;
        }
    
        public void setId(Integer id) { 
            this.id = id;
        }
    
        public String getUsername() { 
            return username;
        }
    
        public void setUsername(String username) { 
            this.username = username;
        }
    
        public String getPassword() { 
            return password;
        }
    
        public void setPassword(String password) { 
            this.password = password;
        }
    
        public String getBrief() { 
            return brief;
        }
    
        public void setBrief(String brief) { 
            this.brief = brief;
        }
    
        @Override
        public String toString() { 
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", brief='" + brief + '\'' +
                    '}';
        }
    }

### 3.获取与服务器连接 ###

public class ConnectToServer { 
        private static final String IP;
        private static final int PORT;
        static { 
            Properties pros = CommUtils.loadProperties("socket.properties");
            IP = pros.getProperty("address");
            PORT = Integer.parseInt(pros.getProperty("port"));
        }
        private Socket client;
        private InputStream in;
        private OutputStream out;
    
        public ConnectToServer(){ 
            try { 
                client = new Socket(IP,PORT);
                in = client.getInputStream();
                out = client.getOutputStream();
            } catch (IOException e) { 
                System.err.println("与服务器建立连接失败");
                e.printStackTrace();
            }
        }
        public InputStream getIn(){ 
            return in;
        }
    
        public OutputStream getOut(){ 
            return out;
        }
    }

### 4.界面 ###

//-------------------------注册界面------------------------------
    public class UserReg { 
        private JPanel UserReg;
        private JTextField usernameText;
        private JPasswordField passwordText;
        private JTextField briefText;
        private JButton regBtn;
        private AccountDao accountDao = new AccountDao();
    
        public UserReg(){ 
            JFrame frame = new JFrame("用户注册");
            frame.setContentPane(UserReg);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setLocationRelativeTo(null);//设置相对位置
            frame.pack();
            frame.setVisible(true);
            //点击submit按钮，将信息持久化到数据库中，成功弹出提示框
            regBtn.addActionListener(e -> { 
                //1.获取用户输入的注册信息
                String userName = usernameText.getText();
                String passWord = String.valueOf(passwordText.getPassword());
                String brief = briefText.getText();
                //2.将信息包装为User类，保存到数据库中
                User user = new User();
                user.setUsername(userName);
                user.setPassword(passWord);
                user.setBrief(brief);
                //调用Dao对象
                if (accountDao.userReg(user)){ 
                    //弹出提示框--成功
                    JOptionPane.showMessageDialog(frame,"注册成功",
                            "提示",JOptionPane.INFORMATION_MESSAGE);
                    frame.setVisible(false);//注册成功，返回登陆界面——注册界面设为不可见
                }else { 
                    //弹出提示框--失败
                    JOptionPane.showMessageDialog(frame,"注册失败","错误",JOptionPane.ERROR_MESSAGE);
                }
            });
        }
    }
    //---------------------------登陆界面--------------------------------
    public class UserReg { 
        private JPanel UserReg;
        private JTextField usernameText;
        private JPasswordField passwordText;
        private JTextField briefText;
        private JButton regBtn;
        private AccountDao accountDao = new AccountDao();
    
        public UserReg(){ 
            JFrame frame = new JFrame("用户注册");
            frame.setContentPane(UserReg);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setLocationRelativeTo(null);//设置相对位置
            frame.pack();
            frame.setVisible(true);
            //点击submit按钮，将信息持久化到数据库中，成功弹出提示框
            regBtn.addActionListener(e -> { 
                //1.获取用户输入的注册信息
                String userName = usernameText.getText();
                String passWord = String.valueOf(passwordText.getPassword());
                String brief = briefText.getText();
                //2.将信息包装为User类，保存到数据库中
                User user = new User();
                user.setUsername(userName);
                user.setPassword(passWord);
                user.setBrief(brief);
                //调用Dao对象
                if (accountDao.userReg(user)){ 
                    //弹出提示框--成功
                    JOptionPane.showMessageDialog(frame,"注册成功",
                            "提示",JOptionPane.INFORMATION_MESSAGE);
                    frame.setVisible(false);//注册成功，返回登陆界面——注册界面设为不可见
                }else { 
                    //弹出提示框--失败
                    JOptionPane.showMessageDialog(frame,"注册失败","错误",JOptionPane.ERROR_MESSAGE);
                }
            });
        }
    }
    //---------------------------好友列表界面-------------------------------------
    
    public class FriendsList { 
        private JPanel FriendsPanel;
        private JScrollPane friendsList;
        private JButton createBtn;
        private JScrollPane groupListPanel;
        private String userName;
        private Set<String> users;//存储所有在线好友
        //存储所有群名称以及群好友
        private Map<String,Set<String>> groupList = new ConcurrentHashMap<>();
        private ConnectToServer connectToServer;
        private JFrame frame;
        //缓存所有私聊界面
        private Map<String,PrivateChatGUI> privateChatGUIMap = new ConcurrentHashMap<>();
        //缓存所有群聊界面
        private Map<String,groupChatGUI> groupChatGUIMap = new ConcurrentHashMap<>();
    
        //好友列表后台任务，不断监听服务器发来的信息
        //侦听好友的上线信息、用户私聊、群聊
        private class DeamonTask implements Runnable{ 
            private Scanner in = new Scanner(connectToServer.getIn());
            @Override
            public void run() { 
                while (true){ 
                    //收到服务器发来的信息
                    if (in.hasNextLine()){ 
                        String strFromServer = in.nextLine();
                        //此时服务器发来的是json字符串
                        if (strFromServer.startsWith("{")){ 
                            //json —> Object
                            MessageVO messageVO = (MessageVO) CommUtils.jsonToObject(strFromServer,MessageVO.class);
                            if (messageVO.getType().equals("2")){ 
                                //服务器发来的私聊信息
                                String friendName = messageVO.getContent().split("-")[0];
                                String msg = messageVO.getContent().split("-")[1];
                                //判断此私聊是否是第一次创建
                                if (privateChatGUIMap.containsKey(friendName)){ 
                                    PrivateChatGUI privateChatGUI = privateChatGUIMap.get(friendName);
                                    privateChatGUI.getFrame().setVisible(true);
                                    privateChatGUI.readFromServer(friendName+"说："+msg);
                                }else { 
                                    PrivateChatGUI privateChatGUI = new PrivateChatGUI(friendName,
                                            userName,connectToServer);
                                    privateChatGUIMap.put(friendName,privateChatGUI);
                                    privateChatGUI.readFromServer(friendName+"说："+msg);
                                }
                            }else if (messageVO.getType().equals("4")){ 
                                //收到服务器发来的群聊信息
                                //type:4
                                //content:sender-msg
                                //to:groupName-[]
                                String groupName = messageVO.getTo().split("-")[0];
                                String senderName = messageVO.getContent().split("-")[0];
                                String groupMsg = messageVO.getContent().split("-")[1];
                                //若此群名称在群聊列表
                                if (groupList.containsKey(groupName)){ 
                                    if(groupChatGUIMap.containsKey(groupName)){ 
                                        //群聊界面弹出
                                        groupChatGUI groupChatGUI = groupChatGUIMap.get(groupName);
                                        groupChatGUI.getFrame().setVisible(true);
                                        groupChatGUI.ReadFromServer(senderName+"说:"+groupMsg);
                                    }else { 
                                        Set<String> names = groupList.get(groupName);
                                        groupChatGUI groupChatGUI = new groupChatGUI(groupName,names,
                                                userName,connectToServer);
                                        groupChatGUIMap.put(groupName,groupChatGUI);
                                        groupChatGUI.ReadFromServer(senderName+"说:"+groupMsg);
                                    }
                                }
                                //若群成员第一次收到群聊信息
                                //1.将群名称以及群成员保存到当前客户端群聊列表
                                Set<String> friends = (Set<String>) CommUtils.jsonToObject(
                                        messageVO.getTo().split("-")[1],Set.class);
                                groupList.put(groupName,friends);
                                loadGroupList();
                                //2.弹出群聊界面
                                groupChatGUI groupChatGUI = new groupChatGUI(groupName,friends,userName,connectToServer);
                                groupChatGUIMap.put(groupName,groupChatGUI);
                                groupChatGUI.ReadFromServer(senderName+"说："+groupMsg);
    
                            }
                        }else{ 
                            //newLogin:userName
                            if (strFromServer.startsWith("newLogin:")){ 
                                String newFriendName = strFromServer.split(":")[1];
                                users.add(newFriendName);
                                //弹框提示用户上线
                                JOptionPane.showMessageDialog(frame,newFriendName+"上线了！",
                                        "上线提醒",JOptionPane.INFORMATION_MESSAGE);
                                //刷新好友列表
                                loadUsers();
                            }
                        }
                    }
                }
            }
        }
        //私聊点击事件
        private class PrivateLabelAction implements MouseListener{ 
            private String labelName;
    
            public PrivateLabelAction(String labelName) { 
                this.labelName = labelName;
            }
    
            //鼠标点击执行事件
            @Override
            public void mouseClicked(MouseEvent e) { 
                //判断好友列表私聊界面缓存是否已经有指定标签
                if (privateChatGUIMap.containsKey(labelName)){ 
                    PrivateChatGUI privateChatGUI = privateChatGUIMap.get(labelName);
                    privateChatGUI.getFrame().setVisible(true);
                }else{ 
                    //第一次点击，创建私聊界面
                    PrivateChatGUI privateChatGUI = new PrivateChatGUI(labelName,
                            userName,connectToServer);
                    privateChatGUIMap.put(labelName,privateChatGUI);
                }
            }
            @Override
            public void mousePressed(MouseEvent e) { 
    
            }
            @Override
            public void mouseReleased(MouseEvent e) { 
    
            }
            @Override
            public void mouseEntered(MouseEvent e) { 
    
            }
            @Override
            public void mouseExited(MouseEvent e) { 
    
            }
        }
        //群聊点击事件
        private class GroupLabelAction implements MouseListener{ 
            private String groupName;
            public GroupLabelAction(String groupName){ 
                this.groupName = groupName;
            }
            @Override
            public void mouseClicked(MouseEvent e) { 
                if (groupChatGUIMap.containsKey(groupName)){ 
                    groupChatGUI groupChatGUI = groupChatGUIMap.get(groupName);
                    groupChatGUI.getFrame().setVisible(true);
                }else { 
                    //创建者第一次点击
                    Set<String> names = groupList.get(groupName);
                    groupChatGUI groupChatGUI = new groupChatGUI(groupName,names,
                            userName, connectToServer);
                    groupChatGUIMap.put(groupName,groupChatGUI);
                }
            }
    
            @Override
            public void mousePressed(MouseEvent e) { 
    
            }
    
            @Override
            public void mouseReleased(MouseEvent e) { 
    
            }
    
            @Override
            public void mouseEntered(MouseEvent e) { 
    
            }
    
            @Override
            public void mouseExited(MouseEvent e) { 
    
            }
        }
    
        public FriendsList(String userName,
                           Set<String> users,ConnectToServer connectToServer){ 
    
            this.userName = userName;
            this.users = users;
            this.connectToServer = connectToServer;
            frame = new JFrame(userName);
            frame.setContentPane(FriendsPanel);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setSize(400,300);
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
            loadUsers();
            //启动后台线程不断监听服务器发来的信息
            Thread deamonThread = new Thread(new DeamonTask());
            deamonThread.setDaemon(true);
            deamonThread.start();
            //创建群组
            createBtn.addActionListener(new ActionListener() { 
                @Override
                public void actionPerformed(ActionEvent e) { 
                    new CreateGroupGUI(userName,users,connectToServer,FriendsList.this);
                }
            });
        }
        //加载所有在线的用户信息
        public void loadUsers(){ 
            JLabel[] userLabels = new JLabel[users.size()];
            JPanel friends = new JPanel();
            friends.setLayout(new BoxLayout(friends,BoxLayout.Y_AXIS));//垂直
            //set遍历
            Iterator<String> iterator = users.iterator();
            int i = 0;
            while(iterator.hasNext()){ 
                String userName = iterator.next();
                userLabels[i] = new JLabel(userName);
                //添加标签的点击事件
                userLabels[i].addMouseListener(new PrivateLabelAction(userName));
                friends.add(userLabels[i]);
                i++;
            }
            friendsList.setViewportView(friends);
            //设置滚动条垂直滚动
            friendsList.setHorizontalScrollBarPolicy(
                    JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
            friends.revalidate();
            friendsList.revalidate();
        }
        public void loadGroupList(){ 
            //存储所有群名称标签JPanel
            JPanel groupNamePanel = new JPanel();
            groupNamePanel.setLayout(new BoxLayout(groupNamePanel,BoxLayout.Y_AXIS));
            JLabel[] labels = new JLabel[groupList.size()];
            //Map遍历
            Set<Map.Entry<String,Set<String>>> entries = groupList.entrySet();
            Iterator<Map.Entry<String,Set<String>>> iterator = entries.iterator();
            int i = 0;
            while(iterator.hasNext()){ 
                Map.Entry<String,Set<String>> entry = iterator.next();
                labels[i] = new JLabel(entry.getKey());
                labels[i].addMouseListener(new GroupLabelAction(entry.getKey()));
                groupNamePanel.add(labels[i]);
                i++;
            }
            groupListPanel.setViewportView(groupNamePanel);
            groupListPanel.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
            groupListPanel.revalidate();
        }
        public void addGroup(String groupName,Set<String> friends){ 
            groupList.put(groupName,friends);
        }
    }
    
    //----------------------------私聊界面-----------------------------------
    public class PrivateChatGUI { 
        private JTextArea readFromServer;
        private JTextField sendToServer;
        private JPanel privateChatPanel;
        private String friendName;
        private String myName;
        private ConnectToServer connectToServer;
        private JFrame frame;
        private PrintStream out;
    
        public PrivateChatGUI(String friendName,String myName,ConnectToServer connectToServer){ 
            this.friendName = friendName;
            this.myName = myName;
            this.connectToServer = connectToServer;
            try { 
                this.out = new PrintStream(connectToServer.getOut(),true,"UTF-8");
            } catch (UnsupportedEncodingException e) { 
                e.printStackTrace();
            }
            frame = new JFrame("与"+friendName+"私聊中");
            frame.setContentPane(privateChatPanel);
            //设置窗口关闭操作，将其设置为隐藏
            frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
            frame.setSize(400,400);
            frame.setVisible(true);
    
            //捕捉输入框的键盘输入
            sendToServer.addKeyListener(new KeyAdapter() { 
                @Override
                public void keyPressed(KeyEvent e) { 
                   StringBuilder sb = new StringBuilder();
                   sb.append(sendToServer.getText());
                   //1.当捕捉到按下Enter键
                    if (e.getKeyCode() == KeyEvent.VK_ENTER){ 
                        //将当前信息发送到服务端
                        String msg = sb.toString();
                        MessageVO messageVO = new MessageVO();
                        messageVO.setType("2");
                        messageVO.setContent(myName+"-"+msg);
                        messageVO.setTo(friendName);
                        PrivateChatGUI.this.out.println(CommUtils.objectToJson(messageVO));
                        //将自己发送的信息展示到当前私聊界面
                        readFromServer(myName+"说："+msg);
                        sendToServer.setText("");
                    }
    
                }
            });
        }
        public void readFromServer(String msg){ 
            readFromServer.append(msg+"\n");
        }
    
        JFrame getFrame(){ 
            return frame;
        }
    }
    
    //创建群聊界面
    public class CreateGroupGUI { 
        private JPanel createGroupPanel;
        private JPanel friendLabelPanel;
        private JTextField groupNameText;
        private JButton confirmBtn;
        private JFrame frame;
        private String myName;
        private Set<String> friends;
        private ConnectToServer connectToServer;
        private FriendsList friendsList;
    
        public CreateGroupGUI(String myName, Set<String> friends,
                              ConnectToServer connectToServer, FriendsList friendsList) { 
            this.myName = myName;
            this.friends = friends;
            this.connectToServer = connectToServer;
            this.friendsList = friendsList;
            frame = new JFrame("创建群组");
            frame.setContentPane(createGroupPanel);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setSize(400,300);
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
            //1.将在线好友以checkBox展示到界面
            friendLabelPanel.setLayout(new BoxLayout(friendLabelPanel,BoxLayout.Y_AXIS));//纵向展示
            JCheckBox[] checkBoxes = new JCheckBox[friends.size()];
            Iterator<String> iterator = friends.iterator();
            int i = 0;
            while(iterator.hasNext()){ 
                String labelName = iterator.next();
                checkBoxes[i] = new JCheckBox(labelName);
                friendLabelPanel.add(checkBoxes[i]);
                i++;
            }
            friendLabelPanel.revalidate();
            //点击提交按钮提交信息到服务端
            confirmBtn.addActionListener(e -> { 
                //1.判断哪些好友被选中加入群聊
                Set<String> selectedFriends = new HashSet<>();
                Component[] comps = friendLabelPanel.getComponents();
                for (Component comp:comps){ 
                    JCheckBox checkBox = (JCheckBox)comp;
                    if (checkBox.isSelected()){ 
                        String labelName = checkBox.getText();
                        selectedFriends.add(labelName);
                    }
                }
                selectedFriends.add(myName);
                //2.获取群名输入框输入的群名称
                String groupName = groupNameText.getText();
                //3.将群名+选中好友信息发送到服务端
                /*type:3 * content:groupName * to:[user1,user2,user3...]*/
                MessageVO messageVO = new MessageVO();
                messageVO.setType("3");
                messageVO.setContent(groupName);
                messageVO.setTo(CommUtils.objectToJson(selectedFriends));
                try { 
                    PrintStream out = new PrintStream(connectToServer.getOut(),
                            true,"UTF-8");
                    out.println(CommUtils.objectToJson(messageVO));
                } catch (UnsupportedEncodingException e1) { 
                    e1.printStackTrace();
                }
                //4.将当前创建群的界面隐藏，刷新好友列表界面的群列表
                frame.setVisible(false);
                //addGroupInfo
                //loadGroup
                friendsList.addGroup(groupName,selectedFriends);
                friendsList.loadGroupList();
            });
        }
    
    }
    //---------------------------群聊界面-----------------------------
        public groupChatGUI(String groupName,Set<String> friends,String myName,ConnectToServer connectToServer){ 
            this.groupName = groupName;
            this.friends = friends;
            this.myName = myName;
            this.connectToServer = connectToServer;
            frame = new JFrame(groupName);
            frame.setContentPane(groupPanel);
            frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
            frame.setLocationRelativeTo(null);
            frame.setSize(400,400);
            frame.setVisible(true);
            friendsPanel.setLayout(new BoxLayout(friendsPanel,BoxLayout.Y_AXIS));
            Iterator<String> iterator = friends.iterator();
            //加载群中好友列表
            while(iterator.hasNext()){ 
                String labelName = iterator.next();
                JLabel jLabel = new JLabel(labelName);
                friendsPanel.add(jLabel);
            }
            sendToServer.addKeyListener(new KeyAdapter() { 
                @Override
                public void keyPressed(KeyEvent e) { 
                    StringBuilder sb = new StringBuilder();
                    sb.append(sendToServer.getText());
                    //捕捉回车按钮
                    if (e.getKeyCode() == KeyEvent.VK_ENTER){ 
                        String strToServer = sb.toString();
                        //type:"4"
                        //content:myName-msg
                        //to:groupName
                        MessageVO messageVO = new MessageVO();
                        messageVO.setType("4");
                        messageVO.setContent(myName+"-"+strToServer);
                        messageVO.setTo(groupName);
                        try { 
                            PrintStream out = new PrintStream(connectToServer.getOut(),
                                    true,"UTF-8");
                            out.println(CommUtils.objectToJson(messageVO));
                        } catch (UnsupportedEncodingException e1) { 
                            e1.printStackTrace();
                        }
    
                    }
                }
            });
        }
        //从服务器读取信息
        public void ReadFromServer(String msg){ 
            readFromServer.append(msg+"\n");
        }
    
        public JFrame getFrame() { 
            return frame;
        }
    }

## 二、服务器端 ##

public class Server { 
        private static final String IP;
        private static final int PORT;
        //缓存当前服务器所有在线的客户端信息
        private static Map<String,Socket> clients = new ConcurrentHashMap<>();
        //缓存当前服务器注册的所有群名称以及群好友
        private static Map<String,Set<String>> groups = new ConcurrentHashMap<>();
        static { 
            //加载配置文件
            Properties properties = CommUtils.loadProperties("socket.properties");
            IP = properties.getProperty("address");
            PORT = Integer.parseInt(properties.getProperty("port"));
        }
    
        private static class ExecuteClient implements Runnable{ 
            private Socket client;
            private Scanner in;
            private PrintStream out;
            public ExecuteClient(Socket client){ 
    
                this.client = client;
                try { 
                    this.in = new Scanner(client.getInputStream());
                    this.out = new PrintStream(client.getOutputStream(),true,"UTF-8");
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
    
            @Override
            public void run() { 
                while(true) { 
                    if (in.hasNext()) { 
                        String jsonStrFromClient = in.nextLine();
                        MessageVO msgFromClient = (MessageVO) CommUtils.jsonToObject(jsonStrFromClient,
                                MessageVO.class);
                        if (msgFromClient.getType().equals("1")) { 
                            //新用户注册到服务端
                            String userName = msgFromClient.getContent();
                            //将当前在线的所有用户名发回客户端
                            MessageVO msgToClient = new MessageVO();
                            msgToClient.setType("1");
                            msgToClient.setContent(CommUtils.objectToJson(clients.keySet()));
                            out.println(CommUtils.objectToJson(msgToClient));
                            //将新上线的用户信息发回给当前已上线的所有用户
                            sendUserLogin("newLogin:"+userName);
                            //将当前新用户注册到服务端缓存
                            clients.put(userName,client);
                            System.out.println(userName+"上线了！");
                            System.out.println("当前聊天室共有"+clients.size()+"人");
    
                        }else if (msgFromClient.getType().equals("2")){ 
                            //用户私聊
                            //type:2
                            //Content:myName-msg
                            //to:friendName
                            String friendName = msgFromClient.getTo();
                            Socket clientSocket = clients.get(friendName);
                            try { 
                                PrintStream out = new PrintStream(clientSocket.getOutputStream(),
                                        true,"UTF-8");
                                MessageVO msgToClient = new MessageVO();
                                msgToClient.setType("2");
                                msgToClient.setContent(msgFromClient.getContent());
                                System.out.println("收到私聊信息，内容为："+msgFromClient.getContent());
                                out.println(CommUtils.objectToJson(msgToClient));
    
                            } catch (IOException e) { 
                                e.printStackTrace();
                            }
                        }else if(msgFromClient.getType().equals("3")){ 
                            //注册群
                            String groupName = msgFromClient.getContent();
                            //该群的所有群成员
                            Set<String> friends = (Set<String>) CommUtils.jsonToObject(msgFromClient.getTo(),Set.class);
                            groups.put(groupName,friends);
                            System.out.println("有新的群注册成功，群名称为："+groupName+
                                    ",一共有"+groups.size()+"个群");
                        }else if (msgFromClient.getType().equals("4")){ 
                            //群聊信息
                            String groupName = msgFromClient.getTo();
                            Set<String> names = groups.get(groupName);
                            Iterator<String> iterator = names.iterator();
                            while (iterator.hasNext()){ 
                                String socketName = iterator.next();
                                Socket client = clients.get(socketName);
                                try { 
                                    PrintStream out = new PrintStream(client.getOutputStream(),
                                            true,"UTF-8");
                                    MessageVO messageVO = new MessageVO();
                                    messageVO.setType("4");
                                    messageVO.setContent(msgFromClient.getContent());
                                    //群名-
                                    messageVO.setTo(groupName+"-"+CommUtils.objectToJson(names));
                                    out.println(CommUtils.objectToJson(messageVO));
                                } catch (IOException e) { 
                                    e.printStackTrace();
                                }
                            }
                        }
                    }
                }
            }
            //向所有在线用户发送新用户上线信息
            private void sendUserLogin(String msg){ 
                for(Map.Entry<String,Socket> entry : clients.entrySet()){ 
                    Socket socket = entry.getValue();
                    try { 
                        PrintStream out = new PrintStream(socket.getOutputStream(),
                                true,"UTF-8");
                        out.println(msg);
                    } catch (IOException e) { 
                        e.printStackTrace();
                    }
                }
            }
        }
    
        public static void main(String[] args) throws IOException { 
            ServerSocket serverSocket = new ServerSocket(PORT);
            ExecutorService executors = Executors.newFixedThreadPool(50);
            for(int i=0;i<50;i++){ 
                System.out.println("等待客户端连接");
                Socket client = serverSocket.accept();
                System.out.println("有新的连接，端口号为："+client.getPort());
                executors.submit(new ExecuteClient(client));
            }
        }
    }

## 三、公共类 ##

public class CommUtils { 
        private static final Gson GSON = new GsonBuilder().create();
    
        //加载配置文件，fileName为要加载的配置文件名称
        public static Properties  loadProperties(String fileName){ 
            Properties properties = new Properties();
            InputStream in = CommUtils.class.getClassLoader().
                    getResourceAsStream(fileName);
            try { 
                properties.load(in);
            } catch (IOException e) { 
               return null;
            }
            return properties;
        }
        /* * 将任意对象序列化为json字符串 * */
        public static String objectToJson(Object object){ 
            return GSON.toJson(object);
        }
    
        /* * 将任意对象反序列化为对象 * objClass：反序列化的反射对象 * */
        public static Object jsonToObject(String jsonStr,Class objClass){ 
            return GSON.fromJson(jsonStr,objClass);
        }
    }

## 四、VO ##

public class MessageVO { 
    	//业务层之间的数据传递
    
        // 表示告知服务器要进行的动作 1.表示用户注册 2.表示私聊
        private String type;
        // 发送到服务器的具体内容
        private String content;
        //私聊告知服务器要将信息发给哪个用户
        private String to;
    
        public String getType() { 
            return type;
        }
    
        public void setType(String type) { 
            this.type = type;
        }
    
        public String getContent() { 
            return content;
        }
    
        public void setContent(String content) { 
            this.content = content;
        }
    
        public String getTo() { 
            return to;
        }
    
        public void setTo(String to) { 
            this.to = to;
        }
    }

## 五、效果展示 ##

![登录界面][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70]  
![注册界面][20190902102250834.png]  
![好友列表界面][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70 1]  
![创建群聊][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70 2]  
![群聊][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/1e03939bef914a119e284960c4c7e499.png
[20190902102250834.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/cb299fb1b88a4c57a0982a017e78f57a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/585495b01ef14ed5b5ed644105ffed71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/878609f446a341468fd0a4d97e499cf9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/7eb8bbaaa5b64b4d889d6009df92e435.png