java学习之即时通信项目实战

 项目总结：这次项目主要是根据视频来的，结果跟到一半感觉跟不上，慢慢自己有了自己的想法，决定自己先不看学习视频，自己先试着写。

　　总结写前面，算是写的第一个项目吧。项目中遇到几点问题，首先Scoket对象创建后，服务器端和客户端不能同时创建输入流，否者会引起堵塞。

　　然后，读入流应该重新创建个线程做等待写入服务，因为读入流会引起当前线程进入阻塞状态。

     还有一个用户线程对应一个服务线程，不是多个用户线程对应一个服务线程。

     对对象的操作应该由那个对象本身提供操作方法，比如操作UI界面的变化应该由界面本身提拱。

　　最后最重要的是写代码之前应该先画个流程图，写代码时参数乱传的，哪里需要就调参数过来。导致思路不清.

首先是需求分析：

　　本次项目是模拟及时通信中最基本的功能，类似QQ的应用.

　　项目分为：

　　 (1)服务器端：

　　　　服务器端主要负责用户管理，消息转发功能

　　 (2) 客户端：

　　　　客户端主要负责用户间的消息发送

详细设计

服务器端

　　1、登录服务器后，进行客户端的监听，如有客户端连接，启动用户服务线程，与客户端进行交互。

　　2、如客户端向所有人发送消息，服务器将向所有在线用户广播该消息。

      3、如客户端向指定人发送消息，服务器将查找接收人用户线程后转发消息。

      4、用户登录后，向所有人更新用户列表。

客户端：

1、用户登录功能。

2、登录后用户可以看到在线用户列表

3 、向指定人发送消息

4、向所有人发送消息

代码的实现

首先，先构建界面图形出来

 

上面左边是用户界面（服务器界面和用户界面一样），右边是登录界面

由于全用手写代码比较麻烦，我用了可视化UI插件；

画出来如下图

界面做出来了，然后构建对象模型，

这里主要需要信息对象，和用户对象；

信息对象又分，登录信息，发送信息和退出信息。这里我把登录信息单独用一个对象构建，因为保存了帐号密码，以后好增加登录验证功能。

然后就是逻辑功能的实现了。

这里我发现看似简单的功能，实现起来还是有点麻烦的。学会了一点就是要模块化。不然自己很容易搞迷糊。

直接上代码：

客户端代码

package com.gh.Client;

import java.awt.Toolkit;

public class ClientFrame {

    private JFrame Clientframe;
    private JTextField textField;
    private String username;
    private JTextArea textArea = null;
    private JList<String> list = null;
    private DefaultListModel<String> model = null;
    private UserService us;

    // 初始化用户列表
    public void InitUserList() {
        model = new DefaultListModel<String>();
        model.addElement("所有人");
        list.setModel(model);
    }

    // 添加用户到在线列表
    public void AddUserToList(String username) {
        // 拆了东墙补西墙。。。之前添加的要全删了，再添加一次
        model.removeAllElements();
        model.addElement("所有人");
        String[] str = username.split(",");
        for (String s : str) {
            model.addElement(s);
        }
        //list.setModel(model);
    }

    public void updateText(String text) {
        StringBuffer sb = new StringBuffer();
        sb.append(textArea.getText()).append(DateUtil.getTime() + "\n").append(text).append("\n");
        textArea.setText(sb.toString());
    }
    public void DelUser(String username){
        model.removeElement(username);
    }

    /**
     * Create the application.
     */
    public ClientFrame(String username,UserService us) {
        this.username = username;
        this.us=us;
        initialize();
        // 初始化用户列表
        InitUserList();
    }

    /**
     * Initialize the contents of the frame.
     */
    private void initialize() {
        Clientframe = new JFrame();
        Clientframe.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                Info info=new Info();
                info.setFromUser(username);
                info.setInfoType(EnumInfoType.EXIT);
                us.send(info);
                us.setFlag(false);
                Clientframe.dispose();
            }
        });
        Clientframe.setVisible(true);
        Clientframe
                .setIconImage(Toolkit.getDefaultToolkit().getImage(ClientFrame.class.getResource("/com/gh/res/1.png")));
        Clientframe.setTitle("\u804A\u804A-\u5BA2\u6237\u7AEF");
        Toolkit tk = Toolkit.getDefaultToolkit();
        Dimension d = tk.getScreenSize();
        int x = (int) (d.getWidth() - 534) / 2;
        int y = (int) (d.getHeight() - 383) / 2;
        Clientframe.setBounds(x, y, 534, 383);
        Clientframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Clientframe.getContentPane().setLayout(new BorderLayout(0, 0));

        JLabel label = new JLabel("当前用户是:" + username);
        Clientframe.getContentPane().add(label, BorderLayout.NORTH);

        JPanel jpanel = new JPanel();
        Clientframe.getContentPane().add(jpanel, BorderLayout.EAST);
        jpanel.setLayout(new BorderLayout(0, 0));

        JLabel lblNewLabel = new JLabel("--\u5728\u7EBF\u7528\u6237\u5217\u8868--");
        jpanel.add(lblNewLabel, BorderLayout.NORTH);

        list = new JList<String>();
        jpanel.add(list, BorderLayout.CENTER);

        JScrollPane scrollPane = new JScrollPane();
        Clientframe.getContentPane().add(scrollPane, BorderLayout.CENTER);

        textArea = new JTextArea();
        scrollPane.setViewportView(textArea);

        JPanel panel = new JPanel();
        Clientframe.getContentPane().add(panel, BorderLayout.SOUTH);
        panel.setLayout(new BorderLayout(0, 0));

        JLabel lblNewLabel_1 = new JLabel("\u8BF7\u8F93\u5165\uFF1A");
        panel.add(lblNewLabel_1, BorderLayout.WEST);

        textField = new JTextField();
        panel.add(textField, BorderLayout.CENTER);
        textField.setColumns(10);

        JButton button = new JButton("\u53D1\u9001");
        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // 获取发送信息
                String sendContent = textField.getText().trim();
                // 获取发送对象
                Info info = new Info();
                info.setFromUser(username);
                info.setToUser((String) list.getSelectedValue());
                info.setContent(sendContent);
                info.setInfoType(EnumInfoType.SEND_INFO);
                System.out.println(info.getToUser());
                // 首先判断发送对象是否为空
                if ("".equals(info.getToUser()) || info.getToUser() == null) {
                    JOptionPane.showMessageDialog(Clientframe, "请选择发送对象");
                    return;
                } else if (info.getToUser().equals(username)) {
                    JOptionPane.showMessageDialog(Clientframe, "不能对自己发送");
                    return;
                } else if (info.getContent().equals("") || info.getContent() == null) {
                    JOptionPane.showMessageDialog(Clientframe, "内容不能为空");
                    return;
                } else
                    us.send(info);
                textField.setText("");
            }
        });
        panel.add(button, BorderLayout.EAST);
    }

}

package com.gh.Client;

import java.awt.Dimension;

@SuppressWarnings("unused")
public class LoginFrame {

    private JFrame frame;
    private JTextField id;
    private JPasswordField pwd;


    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    LoginFrame window = new LoginFrame();
                    window.frame.setVisible(true);
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the application.
     */
    public LoginFrame() {
        initialize();
    }

    /**
     * Initialize the contents of the frame.
     */
    private void initialize() {
        frame =  new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
        frame.setIconImage(Toolkit.getDefaultToolkit().getImage(LoginFrame.class.getResource("/com/gh/res/1.png")));
        Toolkit tk=Toolkit.getDefaultToolkit();
        Dimension d=tk.getScreenSize();
        int x=(int)(d.getWidth()-379)/2;
        int y=(int)(d.getHeight()-171)/2;
        frame.setResizable(false);
        frame.setTitle("\u767B\u5F55");
        frame.setBounds(x, y, 379, 171);
        frame.getContentPane().setLayout(new GridLayout(3, 1, 20, 5));
        
        JPanel panel = new JPanel();
        frame.getContentPane().add(panel);
        FlowLayout fl_panel = new FlowLayout(FlowLayout.CENTER, 5, 10);
        fl_panel.setAlignOnBaseline(true);
        panel.setLayout(fl_panel);
        
        JLabel label = new JLabel("\u7528\u6237\u5E10\u53F7\uFF1A");
        label.setFont(new Font("微软雅黑", Font.PLAIN, 15));
        panel.add(label);
        
        id = new JTextField();
        panel.add(id);
        id.setColumns(15);
        
        
        JPanel panel_1 = new JPanel();
        FlowLayout flowLayout = (FlowLayout) panel_1.getLayout();
        flowLayout.setAlignOnBaseline(true);
        flowLayout.setVgap(10);
        frame.getContentPane().add(panel_1);
        
        JLabel label_1 = new JLabel("\u7528\u6237\u5BC6\u7801\uFF1A");
        label_1.setFont(new Font("微软雅黑", Font.PLAIN, 15));
        panel_1.add(label_1);
        
        pwd = new JPasswordField();
        pwd.setColumns(15);
        panel_1.add(pwd);
        
        JPanel panel_2 = new JPanel();
        FlowLayout flowLayout_1 = (FlowLayout) panel_2.getLayout();
        flowLayout_1.setVgap(6);
        frame.getContentPane().add(panel_2);
        
        JButton button = new JButton("\u767B\u5F55");
        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                String username=id.getText().trim();
                String password=new String(pwd.getPassword());
                if("".equals(username)||username==null||"".equals(password)||password==null){
                    JOptionPane.showMessageDialog(frame, "用户名和密码不能为空");
                    return;
                }
                new UserService().login(username, password,frame);
            }
        });
        button.setFont(new Font("微软雅黑", Font.PLAIN, 15));
        panel_2.add(button);
        
        JButton button_1 = new JButton("\u9000\u51FA");
        button_1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                int v=JOptionPane.showConfirmDialog(frame, "真的要退出吗", "退出", JOptionPane.YES_NO_OPTION);
                if(v==JOptionPane.YES_OPTION)System.exit(0);
            }
        });
        button_1.setFont(new Font("微软雅黑", Font.PLAIN, 15));
        panel_2.add(button_1);
    }

    
}

package com.gh.Client;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

import javax.swing.JFrame;
import javax.swing.JOptionPane;

import com.gh.model.Info;
import com.gh.model.LoginInfo;

public class UserService {
    private LoginInfo logininfo = null;
    private ClientFrame clientframe = null;
    private boolean flag = true;
    private Info getInfo = null;
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    private ObjectOutputStream bw;
    private ObjectInputStream br;
    public void login(final String username, final String password, final JFrame frame) {
        //接收消息线程
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Socket sk = new Socket("192.168.1.102", 8000);
                    //这里被堵了好久，必须要先创建bw再创建br,因为scoket不许客户端和服务端同时创建输入流否者会堵塞Scoket通道
                    bw =new ObjectOutputStream(sk.getOutputStream());
                    br = new ObjectInputStream(sk.getInputStream());
                    logininfo = new LoginInfo(username, password);
                    bw.writeObject(logininfo);//向服务器发送登录信息
                    bw.flush();
                    //从服务接收登录信息
                    LoginInfo objflag = (LoginInfo) br.readObject();
                    if (objflag.isFlag()) {// 如果可以登录
                        // 创建聊天界面
                        clientframe = new ClientFrame(logininfo.getName(),UserService.this);
                        // 聊天界面显示欢迎信息
                        clientframe.updateText("服务器：欢迎登录！");
                        frame.dispose();
                        // 等待接收消息 
                        while (isFlag()) {
                            getInfo = new Info();
                            getInfo = (Info) br.readObject();
                            switch (getInfo.getInfoType()) {
                            case SEND_INFO:
                                clientframe.updateText("用户："+getInfo.getFromUser()+"说："+getInfo.getContent());
                                break;
                            case ADD_USER:
                                clientframe.AddUserToList(getInfo.getContent());
                                break;
                            case EXIT:
                                clientframe.DelUser(getInfo.getFromUser());
                                clientframe.updateText("服务器：用户"+getInfo.getFromUser()+"下线了");
                                break;
                            default:
                                break;
                            }

                        }
                    } else {
                        JOptionPane.showMessageDialog(frame, "用户名或密码错误");
                    }
                } catch (Exception e) {
                    JOptionPane.showMessageDialog(frame, "服务器连接异常");
                     //e.printStackTrace();
                }
            }
        });
        t.start();
    }
    //发送消息线程
    public void send(Info info){
        try {
            bw.writeObject(info);
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务端代码

package com.gh.Sever;

import java.awt.EventQueue;

public class ServerFrame {

    private JFrame Severframe;
    private JTextField textField;
    private JTextArea textArea = null;
    private DefaultListModel<String> model=null;
    private JList<String> list=null;
    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    ServerFrame window = new ServerFrame();
                    window.Severframe.setVisible(true);
                    // 设置UI风格为系统默认的风格
                    //UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

    }
    //初始化用户列表
    public void InitUserList(){
        model=new DefaultListModel<String>();
        model.addElement("所有人");
        list.setModel(model);
    }
    //添加用户到在线列表
    public void AddUserToList(String username){
        model.addElement(username);
        list.setModel(model);
    }
    public void updateText(String text) {
        StringBuffer sb = new StringBuffer();
        sb.append(textArea.getText()).append("\n").append(DateUtil.getTime()+"--")
            .append(text);
        textArea.setText(sb.toString());
    }
    public void DelUser(String username){
        model.removeElement(username);
    }
    /**
     * Create the application.
     */
    public ServerFrame() {
        initialize();
        // 启动服务
        startSever();
        //初始化用户列表
        InitUserList();
    }

    private void startSever() {
        textArea.setText("服务器已经启动，正在监听8000端口...");
        new Thread(new Runnable() {
            @Override
            public void run() {
                new ServerService(ServerFrame.this).startSever();
            }
        }).start();
    }

    /**
     * Initialize the contents of the frame.
     */
    private void initialize() {
        Severframe = new JFrame();
        Severframe
                .setIconImage(Toolkit.getDefaultToolkit().getImage(ServerFrame.class.getResource("/com/gh/res/1.png")));
        Severframe.setTitle("\u804A\u804A-\u670D\u52A1\u7AEF");
        Toolkit tk = Toolkit.getDefaultToolkit();
        Dimension d = tk.getScreenSize();
        int x = (int) (d.getWidth() - 534) / 2;
        int y = (int) (d.getHeight() - 383) / 2;
        Severframe.setBounds(x, y, 534, 383);
        Severframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Severframe.getContentPane().setLayout(new BorderLayout(0, 0));

        JLabel label = new JLabel("\u670D\u52A1\u5668\u7AEF");
        Severframe.getContentPane().add(label, BorderLayout.NORTH);

        JPanel jpanel = new JPanel();
        Severframe.getContentPane().add(jpanel, BorderLayout.EAST);
        jpanel.setLayout(new BorderLayout(0, 0));

        JLabel lblNewLabel = new JLabel("--\u5728\u7EBF\u7528\u6237\u5217\u8868--");
        jpanel.add(lblNewLabel, BorderLayout.NORTH);

        list = new JList<String>();
        jpanel.add(list, BorderLayout.CENTER);

        JScrollPane scrollPane = new JScrollPane();
        Severframe.getContentPane().add(scrollPane, BorderLayout.CENTER);

        textArea = new JTextArea();
        scrollPane.setViewportView(textArea);

        JPanel panel = new JPanel();
        Severframe.getContentPane().add(panel, BorderLayout.SOUTH);
        panel.setLayout(new BorderLayout(0, 0));

        JLabel lblNewLabel_1 = new JLabel("\u8BF7\u8F93\u5165\uFF1A");
        panel.add(lblNewLabel_1, BorderLayout.WEST);

        textField = new JTextField();
        panel.add(textField, BorderLayout.CENTER);
        textField.setColumns(10);

        JButton button = new JButton("\u53D1\u9001");
        panel.add(button, BorderLayout.EAST);
    }

}

package com.gh.Sever;

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;

import com.gh.model.Info;
import com.gh.model.LoginInfo;
import com.gh.util.EnumInfoType;

/**
 * 服务器客户端监听
 * 
 * @author ganhang
 */
public class ServerService {
    private Info currInfo = null;
    private ServerFrame serFrame;
    private boolean flag;
    private UserServerThread ust;
    ExecutorService es = Executors.newScheduledThreadPool(1);
    // 保存所有在线用户服务线程
    private Vector<UserServerThread> userThreads;

    public ServerService(ServerFrame serFrame) {
        this.serFrame = serFrame;
    }

    public void startSever() {
        flag = true;
        try {
            ServerSocket server = new ServerSocket(8000);
            userThreads = new Vector<UserServerThread>();
            while (flag) {
                Socket client = server.accept();
                System.out.println("Server：有用户连接");
                ObjectInputStream ois = new ObjectInputStream(client.getInputStream());
                ObjectOutputStream oos = new ObjectOutputStream(client.getOutputStream());
                LoginInfo logininfo = (LoginInfo) ois.readObject();// 获取用户帐号密码
                System.out.println(logininfo);
                // 登录验证
                if (UserLogin.islogin(logininfo.getName(), logininfo.getPwd())) {
                    logininfo.setFlag(true);
                    oos.writeObject(logininfo);// 发送确认登录信息
                    oos.flush();
                    // 保存当前用户信息
                    currInfo = new Info();
                    currInfo.setFromUser(logininfo.getName());
                    // 在服务器端显示用户登录信息
                    serFrame.updateText("用户" + logininfo.getName() + "--已上线！");
                    // 创建用户服务线程
                    UserServerThread ust = new UserServerThread(currInfo, ois, oos);// 创建用户服务进程
                    userThreads.add(ust);// 添加到进程池
                    es.execute(ust);// 启动线程
                } else
                    oos.writeObject(logininfo);
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 用户服务线程
     * 
     * @author ganhang
     */
    class UserServerThread implements Runnable {
        private Info info = null;
        private ObjectOutputStream oos;
        private ObjectInputStream ois;

        public UserServerThread(Info info, ObjectInputStream ois, ObjectOutputStream oos) {
            this.info = info;
            this.oos = oos;
            this.ois = ois;
        }

        @Override
        public void run() {
            // 更新服务器的在线用户列表
            serFrame.AddUserToList(currInfo.getFromUser());
            // 先获得在线用户的列表
            StringBuffer sb = new StringBuffer();
            for (UserServerThread u : userThreads) {
                sb.append(u.info.getFromUser()).append(",");
            }
            System.out.println(sb.toString());
            // 首先向线程池里每个用户发送一个自己的在线用户列表
            for (UserServerThread usts : userThreads) {
                try {
                    currInfo.setInfoType(EnumInfoType.ADD_USER);
                    currInfo.setContent(sb.toString());
                    usts.oos.writeObject(currInfo);// 注意要写那个线程的输出流
                    usts.oos.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 等待接收用户信息
            System.out.println(flag);
            new Thread(new Wait(ois, oos)).start();

        }

        public void send(Info sendinfo) throws IOException {
            oos.writeObject(sendinfo);
            oos.flush();
        }
    }

    // 接收信息
    class Wait implements Runnable {
        private ObjectOutputStream oos;
        private ObjectInputStream ois;
        private boolean wait = true;

        public Wait(ObjectInputStream ois, ObjectOutputStream oos) {
            this.oos = oos;
            this.ois = ois;
        }

        @Override
        public void run() {
            while (wait) {
                try {
                    // 接收信息必须重开线程因为会把当前线程阻塞
                    Info info = (Info) ois.readObject();
                    System.out.println(Thread.currentThread().getName() + "收到一个send信息");
                    System.out.println(info);
                    switch (info.getInfoType()) {
                    case SEND_INFO:
                        if (info.getToUser().equals("所有人")) {
                            for (UserServerThread user : userThreads) {
                                //这里容易发错人，注意每个用户都有一个服务线程，哪个用户要接收信息就由它的服务线程去发给它，其他用户的服务线程发不了。
                                if (!info.getFromUser().equals(user.info.getFromUser()))
                                    user.send(info);
                                System.out.print(user.info.getFromUser() + "/");
                            }
                            System.out.println("消息发送名单");
                        } else {
                            for (UserServerThread user : userThreads) {
                                if (info.getToUser().equals(user.info.getFromUser())) {
                                    user.send(info);
                                }
                            }
                        }
                        break;
                    case EXIT:
                        serFrame.DelUser(info.getFromUser());
                        serFrame.updateText("用户" + info.getFromUser() + "下线了");
                        for (UserServerThread user : userThreads) {
                            if (!info.getFromUser().equals(user.info.getFromUser())) {
                                user.send(info);
                            } 
                            //这里ust保存的是最后登录的用户的线程因为一直在被覆盖，
                            //需要重新写如当前要删的
                            else ust = user;
                            System.out.print(user.info.getFromUser() + ",");
                        }
                        System.out.println("退出发送名单");
                        // 删除服务器上的该在线用户
                        wait = false;
                        System.out.println("移除的用户：" + ust.info.getFromUser());
                        //这里容易删错用户线程
                        userThreads.remove(ust);
                        break;
                    default:
                        break;
                    }
                } catch (ClassNotFoundException | IOException e) {
                     e.printStackTrace();
                }

            }
        }
    }

}

package com.gh.Sever;
/**
 * 登录验证，以后加数据库在写
 * @author ganhang
 */
public class UserLogin {
    public static  boolean islogin(String name ,String pwd){
        return true;
    }
}

对象模型

package com.gh.model;

import java.io.Serializable;

import com.gh.util.EnumInfoType;
/**
 * 消息对象
 * @author ganhang
 *
 */
public class Info implements Serializable{
    private String fromUser;//信息来自哪
    private String toUser;//发给谁
    private String content;//内容
    private EnumInfoType infoType;//信息类型
    public String getFromUser() {
        return fromUser;
    }
    public void setFromUser(String fromUser) {
        this.fromUser = fromUser;
    }
    public String getToUser() {
        return toUser;
    }
    public void setToUser(String toUser) {
        this.toUser = toUser;
    }

    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public EnumInfoType getInfoType() {
        return infoType;
    }
    public void setInfoType(EnumInfoType infoType) {
        this.infoType = infoType;
    }
    public Info(String fromUser, String toUser, String sendTime, String content, EnumInfoType infoType) {
        super();
        this.fromUser = fromUser;
        this.toUser = toUser;

        this.content = content;
        this.infoType = infoType;
    }
    @Override
    public String toString() {
        return "Info [fromUser=" + fromUser + ", toUser=" + toUser  + ", content=" + content
                + ", infoType=" + infoType + "]";
    }
    public Info() {
        super();
    }
    
}

package com.gh.model;

import java.io.Serializable;

@SuppressWarnings("serial")
public class LoginInfo implements Serializable{
    private String name;
    private String pwd;
    private boolean flag=false;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    public LoginInfo(String name, String pwd) {
        super();
        this.name = name;
        this.pwd = pwd;
    }
    public LoginInfo() {
        super();
    }
    @Override
    public String toString() {
        return "LoginInfo [name=" + name + ", pwd=" + pwd + ", flag=" + flag + "]";
    }
    
}

package com.gh.model;
/**
 * 用户模型
 * @author ganhang
 * 暂时没用，因为没涉及数据库和一些用户管理功能
 */
public class User {
    private String name;
    private String age;
    private String pwd;
    private String email;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", pwd=" + pwd + ", email=" + email + "]";
    }
    public User(String name, String age, String pwd, String email) {
        super();
        this.name = name;
        this.age = age;
        this.pwd = pwd;
        this.email = email;
    }
    public User() {
        super();
    }
    public User(String name, String pwd) {
        super();
        this.name = name;
        this.pwd = pwd;
    }
    public User(String name) {
        super();
        this.name = name;
    }
    
}

 整个代码：https://github.com/ganhang/My-ChatSystem