Java版——一个简易的QQ聊天室程序

介绍

该程序是基于C/S架构模式，即服务端/客户端模式（这种架构模式维护起来既耗时又耗人力物力，不过也不是绝对的哈），其中使用了Java多线程中的一些常用API，例如ConcurrentHashMap（并发HashMap）、还有javax.swing包和java.awt包中的一些GUI组件，因为这是一个基于Java的GUI图形界面聊天室，虽然说现在已经很少有人用GUI来开发软件了。

其实有两大因素：

1、开发周期长，图形界面的绘制太耗时，而且移植性也不太好

2、布局繁琐，样式不太美观，如果非要调整的好看，那也要花很大功夫，不利于现代软件的快速开发，因为现在的软件更新迭代太快

 

程序中涉及的功能

1、登录：登录聊天室，每次登录只需填写一个昵称即可

2、群聊：所有登录的用户处于一个聊天室内，大家可以群聊，即每个人发送的消息都会被所有人可见，后续会增加私聊功能和@指定用户

3、服务器端可以看到每个用户登录之后的信息，还可以看到每个人发送的群消息

 

这个程序包含了六个类，分别是：Server.java、ClientState.java、Message.java、Type.java、UserThread.java、Client.java

 

源代码

 Server.java

package chat;

import static java.util.concurrent.Executors.newFixedThreadPool;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import javax.swing.BorderFactory;
import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;

/**
 * 单例服务器
 *
 * 需求：实现服务器与客户端互发消息
 * 步骤：
 *       1.开启服务器
 *       2.监听客户端连接
 *       3.提示客户端连接成功
 *       4.开启线程给每个连接该服务器的用户
 *       5.转发各个用户的消息
 *
 * 服务器主要功能：
 *         1.广播所有在线客户端
 *         2.群聊（转发一个客户端的消息到其他有客户端上）
 *         3.私聊（暂时未写）
 *
 * @author 14715
 *
 */
public class Server {

    // 服务器套接字
    private ServerSocket server = null;

    private static Map<String,UserThread> onlineUsers = new ConcurrentHashMap<>();;

    private static JFrame f = null;

    private JButton startBtn = null;

    private JButton stopBtn = null;

    private static JTextArea msgTa = null;

    private static DefaultListModel<String> dlm = null;

    private static JList<?> onlineList = null;

    private static JTextField sendTf = null;

    private JScrollPane spMsg = null;

    private JScrollPane spOnline = null;

    private JButton sendBtn = null;

    private ExecutorService es = newFixedThreadPool(5);

    //标识服务器的状态，为false表示关闭状态，反之，则开启状态
    private boolean state = false;

    /**
     * 启动服务器
     */
    private void startServer() {
        try {
            // 开启服务
            server = new ServerSocket(12345);
            //打印信息到控制台
            System.out.println("QQ服务器已启动------------正在等待客户端连接！！！");
            //刷新UI
            SwingUtilities.invokeLater(() -> {
                Server.flushUI(null, Type.SERVERSTART, null);
            });
            //开启线程，监听客户端
            //修改标识
            state = true;
            es.execute(() -> {
                acceptClient();
            });
            //将启动服务器按钮设置为不可用
            startBtn.setEnabled(false);
            //将关闭服务器按钮设置为可用
            stopBtn.setEnabled(true);
        } catch (IOException e) {
            JOptionPane.showMessageDialog(f,"服务器已经启动过了，不可重复启动","温馨提示",1);
        }
    }

    /**
     * 关闭服务器
     * 注意：关闭服务器必须将所有除了绘制UI界面的线程都停止，才停止了服务
     */
    public void closeServer() {
        try {
            //修改状态
            state = false;
            //关闭服务器套接字
            server.close();
            server = null;
            //将启动服务器按钮设置为可用
            startBtn.setEnabled(true);
            //将关闭服务器按钮设置为不可用
            stopBtn.setEnabled(false);
            //遍历HashMap
            Set<String> keys = onlineUsers.keySet();
            // 关闭所有用户线程
            // 不要在遍历集合的时候去删除该集合，这样程序会抛出java.util.ConcurrentModificationException并发修改异常
            // 注意：这里我们一定不能使用以前的HashMap了，而是要使用jdk中为我们提供的juc并发包下的ConcurrentHashMap
            for (String s : keys) {
                UserThread ut = (UserThread) onlineUsers.get(s);
                //此处要特别注意：绝对不能用线程来判断为null，因为调用这个方法时，线程还没结束。
                if (ut != null) {
                    // 注意：修改标志一定要首先执行，不然该用户线程又会继续等待客户端发送消息
                    ut.setStop(true);
                    // 关闭该线程对应的客户端套接字
                    Socket client = ut.getClient();
                    try {
                        if (client != null) {
                            client.close();
                            System.out.println(client + "已断开");
                            ut.setClient(null);
                        }
                    } catch (IOException e) {
                        System.out.println("2222222222222222");
                        e.printStackTrace();
                    }
                    System.out.println(ut.getNickName() + "用户线程正在被关闭!");
                }
            }
            // 移除Map集合中的所有用户线程
            for (String s : keys) {
                onlineUsers.remove(s);
            }
            System.out.println("服务器正在关闭-----");
            //刷新UI
            SwingUtilities.invokeLater(() -> {
                Server.flushUI(null, Type.SERVERCLOSE, null);
            });
            System.out.println("服务器已关闭-----");
        } catch (IOException e) {
            System.out.println("111111");
            e.printStackTrace();
        }
    }
    /**
     * 监听客户端连接
     */
    private void acceptClient() {
        while (state) {
            Socket client = null;
            try {
                if (server != null) {
                    client = server.accept();
                    // 新一个客户端进来
                    // 开启线程
                    es.execute(new UserThread(client,onlineUsers));
                }
            } catch (IOException e) {
                continue;
            }
        }
    }

    /**
     * 初始化界面
     */
    public void init() {
        // 创建JFrame对象
        f = new JFrame();

        // 设置窗体基本属性
        f.setTitle("QQ服务器");
        f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        f.setBounds(300, 150, 580, 400);
        f.setResizable(false);
        f.setLayout(null);
        f.setVisible(true);

        //实例化启动服务器和关闭服务器按钮
        startBtn = new JButton("开启服务器");
        startBtn.setBounds(50,10,100,35);

        stopBtn = new JButton("关闭服务器");
        stopBtn.setBounds(260,10,100,35);
        stopBtn.setEnabled(false);

        msgTa = new JTextArea();
        msgTa.setEditable(false);
        msgTa.setFont(new Font("微软雅黑", Font.CENTER_BASELINE, 13));

        spMsg = new JScrollPane(msgTa);
        spMsg.setBounds(5, 45, 405, 260);
        //设置标题边框
        spMsg.setBorder(BorderFactory.createTitledBorder("消息列表"));

        dlm = new DefaultListModel<>();

        onlineList = new JList<>(dlm);

        spOnline = new JScrollPane(onlineList);
        spOnline.setBounds(425, 5, 145, 300);
        //设置标题边框
        spOnline.setBorder(BorderFactory.createTitledBorder("在线列表"));

        sendTf = new JTextField();
        sendTf.setBounds(20, 320, 380, 35);
        sendTf.setFont(new Font("宋体", Font.BOLD, 20));

        sendBtn = new JButton("发送");
        sendBtn.setBounds(445, 320, 100, 35);

        f.add(startBtn);
        f.add(stopBtn);
        f.add(spMsg);
        f.add(spOnline);
        f.add(sendTf);
        f.add(sendBtn);

        //注册事件
        regEvent();
    }

    /**
     * 注册事件
     */
    private void regEvent() {
        //注册启动服务器事件
        startBtn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                startServer();
            }
        });

        //关闭服务器事件
        stopBtn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                closeServer();
            }
        });

        //按钮动作事件
        sendBtn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //获取文本框中的即将要发送的消息内容
                String content = sendTf.getText().trim();
                if (!("".equals(content))) {
                    serverInform(content);
                    //清空文本框
                    sendTf.setText("");
                } else {
                    JOptionPane.showMessageDialog(f, "发送内容不能为空", "提示", 1);
                }
            }
        });

        //文本框键盘事件
        sendTf.addKeyListener(new KeyAdapter()
        {
            @Override
            public void keyPressed(KeyEvent e) {
                if (e.getKeyCode() == KeyEvent.VK_ENTER) {
                    //获取文本框中的即将要发送的消息内容
                    String content = sendTf.getText();
                    if (!("".equals(content))) {
                        serverInform(content);
                          //清空文本框
                        sendTf.setText("");
                    } else {
                        JOptionPane.showMessageDialog(f, "发送内容不能为空", "提示", 1);
                    }
                }
            }
        });
    }

    /**
     * 服务器通知所有客户端消息
     */
    private void serverInform(final String msg) {
        ObjectOutputStream oos = null;
        try {
            //判断服务器是否已启动
            if (state) {
                if (onlineUsers.size() > 0) {
                    //遍历HashMap
                    Set<String> keys = onlineUsers.keySet();
                    for (String s : keys) {
                        UserThread ut = (UserThread)onlineUsers.get(s);
                        Socket client = ut.getClient();
                        if (client != null) {
                            oos = new ObjectOutputStream(client.getOutputStream());
                            //创建Message对象
                            Message m = new Message();
                            m.setInfo("服务器：" + msg);
                            m.setType(Type.SERVERINFORM);
                            oos.writeObject(m);
                            oos.flush();
                        }
                    }
                    SwingUtilities.invokeLater(new Runnable() {
                        @Override
                        public void run() {
                            //刷新UI
                            flushUI(null, Type.SERVERINFORM, msg);
                        }
                    });
                } else {
                    //此时没有客户端在线
                    //弹出提示框提示服务器
                    SwingUtilities.invokeLater(new Runnable() {
                        @Override
                        public void run() {
                            JOptionPane.showMessageDialog(f, "当前无客户端在线", "提示", 3);
                        }
                    });
                }
            } else {
                //弹出提示框提示服务器未启动
                SwingUtilities.invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        JOptionPane.showMessageDialog(f, "服务器未启动", "提示", 2);
                    }
                });
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 发送在线用户集合给每个在线的客户端
     */
    public static void sendMap() {
        ObjectOutputStream oos = null;
        try {
            //遍历Map，响应其他客户端
            Set<String> keys = onlineUsers.keySet();
            for (String s : keys) {
                UserThread temp = (UserThread)onlineUsers.get(s);
                if (temp != null) {
                    oos = new ObjectOutputStream(temp.getClient().getOutputStream());
                    oos.writeObject(onlineUsers);
                    oos.flush();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 群发消息
     * @param from
     * @param msg
     */
    public static void groupSend(final UserThread from,final String msg) {
        ObjectOutputStream oos = null;
        try {
            //遍历HashMap
            Set<String> keys = onlineUsers.keySet();
            for (String s : keys) {
                UserThread ut = (UserThread) onlineUsers.get(s);
                if (ut != null && ut != from) {
                    oos = new ObjectOutputStream(ut.getClient().getOutputStream());
                    //创建Message对象
                    Message m = new Message();
                    m.setInfo(from.getNickName() + "：" + msg);
                    m.setType(Type.GROUPRECEIVE);
                    oos.writeObject(m);
                    oos.flush();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 刷新UI控件
     * 注意：服务器关闭属于特殊情况，这时候必须将List控件中的所有用户信息全部移除
     */
    public static void flushUI(UserThread u,int state,String msg) {
        //判断客户端的连接状态
        switch (state) {
            case Type.SERVERSTART :
                // 显示服务器启动提示信息
                msgTa.append("QQ服务器已启动----------正在等待客户端连接！！！\n");
                break;
            case Type.SERVERCLOSE :
                // 移除List控件中的所有用户信息
                onlineList.removeAll();
                // 显示服务器启动提示信息
                msgTa.append("QQ服务器已关闭------稍后再为您服务！！！\n");
                break;
            case Type.CONNECT :
                msgTa.append("客户端【" + u.getLocalHost() + "】已连接\n");
                break;
            case Type.LOGIN :
                msgTa.append("客户端" + u.getLocalHost() + "【 " + u.getNickName() + "】已登录\n");
                dlm.addElement(u.getLocalHost() + "/" + u.getNickName());
                break;
            case Type.GROUPSEND :
                msgTa.append("客户端" + u.getLocalHost() + "【 " + u.getNickName() + "】群发了一条消息：" + msg + "\n");
                break;
            case Type.PRIVATESEND :
                break;
            case Type.SERVERINFORM :
                msgTa.append("服务器向所有客户端发送了一条消息：" + msg + "\n");
                break;
            case Type.CLIENTEXIT :
                msgTa.append("客户端【" + u.getLocalHost() + "】已断开连接\n");
                dlm.removeElement(u.getLocalHost() + "/" + u.getNickName());
                break;
        }
        //1.刷新消息面板
        msgTa.updateUI();
        //2.更新List面板
        onlineList.updateUI();
    }

    /**
     * 主方法
     * @param args
     */
    public static void main(String[] args) {
        Server server = new Server();
        server.init();
    }
}

ClientState.java

package chat;

/**
 * 客户端消息常量类
 * @author Administrator
 *
 */
public class ClientState {
    
    //发送的消息
    public static final int SEND = 0x001;
    
    //接收的消息
    public static final int RECEIVE = 0x002;

}

Message.java

package chat;

import java.io.Serializable;


@SuppressWarnings("serial")
public class Message implements Serializable{
    
    private String from;
    
    private String to;
    
    private String info;
    
    private int type;
    
    public Message() {
        
    }

    public Message(String from, String to, String info, int type) {
        this.from = from;
        this.to = to;
        this.info = info;
        this.type = type;
    }

    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 String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }
    
    

}

Type.java

package chat;

import java.io.Serializable;

/**
 * @author Administrator
 *
 */
@SuppressWarnings("serial")
public class Type implements Serializable{

    public static final int LOGIN = 0x001;
    
    public static final int GROUPSEND = 0x002;
    
    public static final int GROUPRECEIVE = 0x003;
    
    public static final int PRIVATESEND = 0x004;
    
    public static final int PRIVATERECEIVE = 0x005;
    
    public static final int SERVERINFORM = 0x006;
    
    public static final int CLIENTEXIT = 0x007;

    public static final int CONNECT = 0x008;

    public static final int SERVERCLOSE = 0x009;

    public static final int SERVERSTART = 0;
    
}

UserThread.java

package chat;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.net.Socket;
import java.util.Map;
import javax.swing.SwingUtilities;

/**
 * 用户处理线程
 * 功能一：接受用户的消息
 * 功能二：回复用户的消息
 * 功能三：刷新UI控件
 * 
 * 用ObjectOutputStream和ObjectInputStream这两个流对象传输时，一定要注意哪些对象是没有实现Serializable接口，
 * 所以在传输过程中，不能被传输，会抛异常NotSerilizableException
 * 
 * 解决办法：将不能被序列化的对象加上transient关键字
 * 
 * 此次用ObjectOutputStream和ObjectInputStream对象输入输出流注意事项：socket对象是不能被序列化得,自身可以作为传输的工具，但是自身不能被序列化，
 * 所以在此特别要注意。本人在这个地方困惑了将近两天，最后在一篇博客上才看到有人说socket对象是不能被序列化的，
 * 
 * 注意：GUI网络编程的两个关键步骤：
 *         1、一定要记得时时更新集合中的数据
 *         2、一定要记得刷新UI控件，做到及时响应客户端
 * @author Administrator
 *
 */
@SuppressWarnings("serial")
public class UserThread implements Runnable,Serializable{

    private transient Socket client;
    
    private String localHost = null;
    
    private UserThread user = this;
    
    private Map<String,UserThread> onlineUsers;
    
    private String nickName;
    
    private boolean isStop = false;
    
    public boolean isStop() {
        return isStop;
    }

    public void setStop(boolean isStop) {
        this.isStop = isStop;
    }

    /**
     * 处理客户端线程的构造方法
     * @param client
     * @param onlineUsers
     */
    public UserThread(Socket client,Map<String,UserThread> onlineUsers) {
        //连接成功      
        this.client = client;
        this.localHost = client.getInetAddress().getHostAddress() + "::" + client.getPort();
        this.onlineUsers = onlineUsers; 
        // 刷新List
        Server.flushUI(this, Type.CONNECT, null);
    }
    
    /**
     * 线程方法
     */
    @Override
    public void run() {
        while (!isStop) {
            if (!hear()) {
                // 进入，表示客户端自己退出
                // 如果返回false，则跳出循环
                onlineUsers.remove(nickName);
                break;
            }
        }
        // 连接断开原因 ：可能是客户端自己断开，也可能是服务器关闭
        // 通过该线程的昵称键名来从Map集合中移除 该键值对
        // 发送存储在线用户的Map集合给每个在线的客户端
        // 响应客户端
        if (!isStop) {
            Server.sendMap();
        }
        // 响应服务端
        SwingUtilities.invokeLater(() -> {
            Server.flushUI(user, Type.CLIENTEXIT, null);
        });
    }
    
    /**
     * 负责接收客户端发来的所有类型消息
     * @return 返回的boolean值标识这客户端的连接状态
     * 如果返回false则标识客户端已断开连接
     * 反之，则标识客户端没断开连接
     */
    private boolean hear() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(client.getInputStream());
            Object obj = ois.readObject();
            if (obj instanceof Message) {
                Message msg = (Message) obj;
                //判断消息类型
                switch (msg.getType()) {
                    case Type.LOGIN :
                        String nickName = msg.getInfo();
                        this.nickName = nickName;
                        onlineUsers.put(this.nickName, this);
                        //发送存储在线用户的HashMap集合给每个在线的客户端
                        Server.sendMap();
                        SwingUtilities.invokeLater(() -> {
                            Server.flushUI(user, Type.LOGIN, null);
                        });
                        break;
                    case Type.GROUPSEND :
                        final String info = msg.getInfo();
                        Server.groupSend(this, info);
                        SwingUtilities.invokeLater(new Runnable() {            
                            @Override
                            public void run() {
                                Server.flushUI(user, Type.GROUPSEND, info);
                            }
                        });
                        break;
                    case Type.PRIVATESEND :
                        break;              
                }
            }
        } catch (ClassNotFoundException e) {
            //此时表示客户端断开连接
            return false;
        } catch (IOException e) {
            //此时表示客户端断开连接
            return false;
        }
        return true;
    }
    
    public Socket getClient() {
        return client;
    }
   
    public void setClient(Socket client) {
        this.client = client;
    }
    
    public String getLocalHost() {
        return localHost;
    }
    
    public String getNickName() {
        return nickName;
    }
}

Client.java

package chat;

import static java.util.concurrent.Executors.newFixedThreadPool;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
import javax.swing.WindowConstants;

/**
 * 客户端
 *
 * 需求：多客户端互发消息
 * 步骤：
 *       1.连接服务器
 *       2.尝试连接，接收服务器的提示消息
 *       3.若成功连接，则开始与好友进行聊天
 *         若失败，则尝试重连
 *       4.这里我采用Socket对象来区分多个客户端，而没有连接数据库像QQ一样每个客户端都能用QQ唯一标识，
 *           我先做个简便的聊天工具。实现群聊
 *       5.注意：客户端刷新UI控件是必须要通过服务器的响应才能实时刷新的。
 *
 * @author 14715
 *
 */
public class Client implements Runnable{

    // 客户端套接字
    private Socket client = null;

    private JFrame f = null;
    
    public static JTextArea msgTa = null;

    private JScrollPane sp = null;

    private JLabel onlineLa = null;
    
    private DefaultComboBoxModel<String> dcmbModel = null;
    
    private JComboBox<String> cmbFriends = null;
    
    private JTextField sendTf = null;

    private JButton sendBtn = null;

    private ExecutorService es = newFixedThreadPool(4);
    
    private String nickName = null;

    /**
     * 开启客户端
     */
    public void startClient() {
        try {
            // 开启服务
            client = new Socket("127.0.0.1",12345);
            String input = null;
            while (true) {
                //只有连接上服务器，才弹出JOPtionPane的输入框模式
                input = JOptionPane.showInputDialog("请输入您的昵称");
                //判断用户输入
                if (input != null) {
                    if (input.equals("")) {
                        JOptionPane.showMessageDialog(f, "昵称不能为空");
                    } else {
                        break;
                    }
                } else {
                    System.exit(0);
                }
            }
            //开始登录
            login(input);
            //初始化界面
            init();
            //打印信息到控制台
            System.out.println("已成功连接上服务器\n");
            // 显示服务器启动提示信息
            msgTa.append("已成功连接上服务器，可以开始与好友聊天啦！\n");
            //开启线程接收服务器端消息的线程
            es.execute(this);         
        } catch (IOException e) {
            JOptionPane.showMessageDialog(f,"未连接到远程服务器","黄色警告",2);
            //未连接到服务器，则退出程序
            System.exit(0);
        }
    }

    /**
     * 初始化界面
     */
    public void init() {
        // 创建JFrame对象
        f = new JFrame();

        // 设置窗体基本属性
        f.setTitle("QQ客户端--------昵称：" + nickName);
        f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        f.setBounds(700, 100, 570, 400);
        f.setResizable(false);
        f.setLayout(null);
        f.setVisible(true);

        msgTa = new JTextArea();
        msgTa.setEditable(false);
        msgTa.setFont(new Font("微软雅黑", Font.BOLD, 20));

        sp = new JScrollPane(msgTa);
        sp.setBounds(5, 5, 440, 300);
        
        onlineLa = new JLabel("在线用户");
        onlineLa.setBounds(475,5,60,15);
        
        dcmbModel = new DefaultComboBoxModel<String>();
        
        cmbFriends = new JComboBox<String>(dcmbModel);
        cmbFriends.setBounds(450,30,110,20);
        
        sendTf = new JTextField();
        sendTf.setBounds(20, 320, 390, 35);
        sendTf.setFont(new Font("宋体", Font.BOLD, 20));

        sendBtn = new JButton("发送");
        sendBtn.setBounds(450, 320, 110, 35);

        f.add(sp);
        f.add(onlineLa);
        f.add(cmbFriends);
        f.add(sendTf);
        f.add(sendBtn);

        //注册事件监听
        regEvent();
    }

    /**
     * 注册事件
     */
    private void regEvent() {
        sendBtn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //判断是否成功连接上服务器
                if (client != null) {
                    //获取文本框中的即将要发送的消息内容
                    String content = sendTf.getText().trim();
                    if (!("".equals(content))) {               
                        sendGroupMessage(content);
                        //清空文本框
                        sendTf.setText("");
                    } else {
                        JOptionPane.showMessageDialog(f, "发送内容不能为空", "提示", 1);
                    }
                } else {
                    JOptionPane.showMessageDialog(f,"请先连接QQ服务器再与好友聊天吧","警告",2);
                }
            }
        });
        
        sendTf.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                //判断是否成功连接上服务器
                if (client != null) {
                    if (e.getKeyCode() == KeyEvent.VK_ENTER) {
                        //获取文本框中的即将要发送的消息内容
                        String content = sendTf.getText().trim();
                        if (!("".equals(content))) {               
                            sendGroupMessage(content);
                            //清空文本框
                            sendTf.setText("");
                        } else {
                            JOptionPane.showMessageDialog(f, "发送内容不能为空", "提示", 1);
                        }
                    }
                } else {
                    JOptionPane.showMessageDialog(f,"请先连接QQ服务器再与好友聊天吧","警告",2);
                }
            }
        });
    }

    /**
     * QQ登录
     * @param nickName 登录昵称
     */
    private void login(String nickName) {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(client.getOutputStream());
            //创建Message对象
            Message m = new Message();
            m.setInfo(nickName);
            m.setType(Type.LOGIN);
            //发送登录数据
            oos.writeObject(m);
            oos.flush();
            this.nickName = nickName;
        } catch (IOException e) {
            e.printStackTrace();
        }      
    }
    
    /**
     * 群发消息给服务器
     */
    private void sendGroupMessage(final String msg) {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(client.getOutputStream());
            //创建Message对象
            Message m = new Message();
            m.setInfo(msg);
            m.setType(Type.GROUPSEND);
            oos.writeObject(m);
            oos.flush();
            //刷新UI
            SwingUtilities.invokeLater(new Runnable() {            
                @Override
                public void run() {
                    flushUI(msg, Type.GROUPSEND);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 接收在线客户的Map集合
     */
    @SuppressWarnings({ "unchecked" })
    private void receiveMap(Object obj) {
        //读取ArrayList集合
        Map<String, UserThread> onlineUsers = (Map<String, UserThread>) obj;
        //先将之前的JComboBox控件中的内容全部清空
        dcmbModel.removeAllElements();
        //遍历HashMap
        Set<String> keys = onlineUsers.keySet();
        for (String s : keys) {
            dcmbModel.addElement(s);
        }
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                cmbFriends.updateUI();
            }
        });
    }
    
    /**
     * 接收到服务器发送来的群消息
     * @param obj
     */
    private void receiveMessage(Object obj) {
        Message m = (Message) obj;
        //获取消息内容
        final String info = m.getInfo();
        //判断是群发还是服务器的通知消息
        switch (m.getType()) {
            case Type.GROUPRECEIVE :             
                //刷新UI
                SwingUtilities.invokeLater(new Runnable() {            
                    @Override
                    public void run() {
                        flushUI(info, Type.GROUPRECEIVE);
                    }
                });
                break;
            case Type.SERVERINFORM : 
                //刷新UI
                SwingUtilities.invokeLater(new Runnable() {            
                    @Override
                    public void run() {
                        flushUI(info, Type.SERVERINFORM);
                    }
                });
                break;
        }
    }
    
    /**
     * 读
     * @return 返回的boolean值标识这客户端的连接状态
     * 如果返回false则标识客户端已断开连接
     * 反之，则标识客户端没断开连接
     */
    private boolean hear() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(client.getInputStream());
            //readObject()该方法是个阻塞式方法，如果没有读取到对象，就会一直等到，不需要考虑其出现null的情况
            Object obj = ois.readObject();
            if (obj instanceof Map) {
                //如果接收到的是Map对象
                receiveMap(obj);
            } else if (obj instanceof Message) {
                //群发消息
                receiveMessage(obj);
            }
        } catch (IOException e) {
            //此时表示服务器断开连接
            return false;    
        } catch (ClassNotFoundException e) {
            //此时表示服务器断开连接
            return false;
        }
        return true;
    }
    
    /**
     * 线程方法
     */
    @Override
    public void run() {
        while (hear()) {
        }
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                flushUI(null,Type.CLIENTEXIT);
            }
        });
    }

    /**
     * 刷新UI控件
     */
    private void flushUI(String msg, int state) {
        switch (state) {
            case Type.GROUPSEND :
                msgTa.append("我：" + msg + "\n");
                break;
            case Type.GROUPRECEIVE :
                msgTa.append(msg + "\n");
                break;
            case Type.SERVERINFORM :
                msgTa.append(msg + "\n");
                break;
            case Type.CLIENTEXIT :
                JOptionPane.showMessageDialog(f, "服务器已断开", "提示", 0);
                //强制退出程序
                System.exit(0);
                break;
        } 
        //刷新消息面板
        msgTa.updateUI();
    }
    
    /**
     * 主方法
     * @param args
     */
    public static void main(String[] args) {
        //创建客户端对象
        Client client = new Client();
        //启动客户端，连接服务器
        client.startClient();
    }
}