JAVA即时通讯系统(无界面)————登陆页面模块

1.项目开发流程

需求分析(需求分析报告)  ->  设计阶段(设计工作，原型开发，组建团队)  ->  实现阶段(完成架构的模块功能)  ->  测试阶段(单元测试，测试用例，白/黑盒测试)  ->  实施阶段(环境配置部署)  ->  维护阶段

2.多用户即时通讯系统

2.1需求分析

1.用户登陆

2.拉取在线用户列表

3.私聊

4.群聊

5.发文件

6.文件服务器推送新闻

2.2通讯系统整体分析

2.3 QQ用户登陆模块

1.首先创建两个项目，一个客户端，一个服务端(由于没有使用到数据库所以通过特定的用户名以及密码登陆)。

客户端和服务器端都要创建两个一样的package(需要同名),用来存放用户信息类(User),消息类(Message)，以及消息类型接口(MeesageType)。

//User类
import java.io.Serializable;

//需要登录，所以用来表示一个用户信息
//因为User对象需要在网络上进行传输，所以需要进行序列化
public class User implements Serializable {
    private static final long serialVersionUID=1L;
    private String userId;//用户Id
    private String pwd;//用户密码

    public User(String userId, String pwd) {
        this.userId = userId;
        this.pwd = pwd;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

//Message类
import java.io.Serializable;

//表示传送的消息对象
//之后该对象需要在网络上进行传输，所以需要进行序列化
public class Message implements Serializable {
    private final static long serialVersionUID=1L;
    private String sender;//表示发送者
    private String getter;//表示接收者
    private String content;//表示消息的内容
    private String sendTime;//表示信息发送的时间
    private String mesType;//表示消息的类型，可以在接口中定义消息的类型

    public String getSender() {
        return sender;
    }

    public void setSender(String sender) {
        this.sender = sender;
    }

    public String getGetter() {
        return getter;
    }

    public void setGetter(String getter) {
        this.getter = getter;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getSendTime() {
        return sendTime;
    }

    public void setSendTime(String sendTime) {
        this.sendTime = sendTime;
    }

    public String getMesType() {
        return mesType;
    }

    public void setMesType(String mesType) {
        this.mesType = mesType;
    }
}

//消息类型接口
public interface MessageType {
    //在接口中定义常量，不同的值表示不同的接口类型
    String MESSAGE_LOGIN_SUCCEED="1";//表示登陆成功
    String MESSAGE_LOGIN_FAIL="2";//表示登陆失败
}

2.登录页面的完成

        2.1基本登陆界面的功能

import com.qq.qqclient.utils.Utility;

public class QQView {
    private boolean loop=true;//用于控制用户退出与登陆
    private String key="";//用于接收用户输入
    public static void main(String args[]) {
        new QQView().mainMenu();
    }

    //显示主菜单
    public void mainMenu(){
        while(loop) {
            System.out.println("===============欢迎进入即时通信系统===============");
            System.out.println("\t\t1.登陆系统");
            System.out.println("\t\t9.退出系统");
            System.out.print("请输入你的选择:");
            key= Utility.readString(1);
            switch (key) {
                case "1":
                    System.out.print("请输入你的用户名:");
                    String userId=Utility.readString(20);
                    System.out.print("请输入你的密  码:");
                    String pwd= Utility.readString(20);
                    //此处省略若干....

                    if(true) {
                        //进入二级菜单
                        while(loop) {
                            System.out.println("===============欢迎用户"+userId+"进入系统===============");
                            System.out.println("\t\t1.显示在线用户列表");
                            System.out.println("\t\t2.群发消息");
                            System.out.println("\t\t3.私聊消息");
                            System.out.println("\t\t4.发送文件");
                            System.out.println("\t\t9.退出系统");
                            System.out.print("请输入你的选择:");
                            key=Utility.readString(1);
                            switch(key) {
                                case "1":
                                    System.out.println("显示在线用户列表");
                                    break;
                                case "2":
                                    System.out.println("群发消息");
                                    break;
                                case "3":
                                    System.out.println("私聊消息");
                                    break;
                                case "4":
                                    System.out.println("发送文件");
                                    break;
                                case "9":
                                    loop=false;
                                    break;
                            }
                        }
                    } else {
                        System.out.println("登陆失败...");
                    }
                    break;
                case "9":
                    loop=false;
                    System.out.println("退出系统...");
                    break;
            }
        }
    }
}

        2.2客户端登陆用户的验证

 客户端发送一个User对象给服务器，服务器端给该线程返回一个Message对象

import com.qq.common.Message;
import com.qq.common.MessageType;
import com.qq.common.User;

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

//用来完成登陆用户的验证，用户注册等功能
public class UserClientService {
    //将user做成属性的原因：在其他地方也需要使用到user的信息
    private User user=new User();
    //socket之后也会被使用到，所以也做成属性
    private Socket socket;

    //根据UserId和pwd到服务器验证用户是否合法
    public boolean checkUser(String userId,String pwd) {
        boolean b=false;
        //创建User对象
        user.setUserId(userId);
        user.setPwd(pwd);
        try {
            //连接到服务器，发送user对象
            Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);
            //向服务器端发送User对象
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(user);

            //读取服务器发回的Message对象
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            Message message=(Message)ois.readObject();

            //判断登陆是否成功
            if(message.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) {
                b=true;//登陆成功
                //创建一个和服务器端保持通信的线程 -> 创建一个类ClientConnectServerThread
                ClientConnectServerThread clientConnectServerThread = new ClientConnectServerThread(socket);
                //启动客户端线程
                clientConnectServerThread.start();
                //因为有多个线程，需要将线程放入集合中进行管理
                ManageClientConnectServerThread.addClientConnectServerThread(userId,clientConnectServerThread);
            }else {
                //登陆失败，我们就不能启动线程和服务器通信的线程，关闭socket
                socket.close();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return b;
    }
}

登陆成功，需要创建一个和服务器进行通信的线程，用来控制socket，即创建一个ClientConnectServerThread类

import com.qq.common.Message;

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

public class ClientConnectServerThread extends Thread {
    //该线程必须持有socket
    private Socket socket;

    //构造器可以接收一个Socket对象
    public ClientConnectServerThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        //因为Thread需要在后台和服务器进行通信，用while循环一直等待
        while(true) {
            System.out.println("客户端线程，等待读取从服务器端发送的消息");
            try {
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                Message message=(Message)ois.readObject();//当服务器没有发送message对象，线程就会阻塞在此处
                //在做相应的处理

            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
    
    //为了方便得到socket对象
    public Socket getSocket() {
        return socket;
    }
}

当有多个线程要进行通信时，需要对线程进行管理，创建一个管理线程的集合类ManageClientConnectServerThread

import java.util.HashMap;

//管理客户端连接到服务器端线程的类
public class ManageClientConnectServerThread {
    //我们将多个线程放入到一个HashMap集合当中，key就是用户名，value就是线程
    private static HashMap<String,ClientConnectServerThread> hm=new HashMap<>();

    //将某个线程加入到线程中
    public static void addClientConnectServerThread(String userId,ClientConnectServerThread thread) {
        hm.put(userId,thread);
    }

    //通过一个userId 可以得到相应的线程
    public static ClientConnectServerThread getClientConnectServerThread(String userId) {
        return hm.get(userId);
    }
}

最后在对登陆基本功能类进行修改，对登录的用户进行检查，判断是否能够登陆进系统。

import com.qq.common.Message;
import com.qq.common.MessageType;
import com.qq.common.User;

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

//用来完成登陆用户的验证，用户注册等功能
public class UserClientService {
    //将user做成属性的原因：在其他地方也需要使用到user的信息
    private User user=new User();
    //socket之后也会被使用到，所以也做成属性
    private Socket socket;

    //根据UserId和pwd到服务器验证用户是否合法
    public boolean checkUser(String userId,String pwd) {
        boolean b=false;
        //创建User对象
        user.setUserId(userId);
        user.setPwd(pwd);
        try {
            //连接到服务器，发送user对象
            Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);
            //向服务器端发送User对象
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(user);

            //读取服务器发回的Message对象
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            Message message=(Message)ois.readObject();

            //判断登陆是否成功
            if(message.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) {
                b=true;//登陆成功
                //创建一个和服务器端保持通信的线程 -> 创建一个类ClientConnectServerThread
                ClientConnectServerThread clientConnectServerThread = new ClientConnectServerThread(socket);
                //启动客户端线程
                clientConnectServerThread.start();
                //因为有多个线程，需要将线程放入集合中进行管理
                ManageClientConnectServerThread.addClientConnectServerThread(userId,clientConnectServerThread);
            }else {
                //登陆失败，我们就不能启动线程和服务器通信的线程，关闭socket
                socket.close();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return b;
    }
}

客户端登陆模块完成。

2.3服务器端登陆模块的实现

服务器端监听9999端口，等待用户连接，并保持通信。QQServer代码如下：

import com.qq.common.Message;
import com.qq.common.MessageType;
import com.qq.common.User;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;


//服务器端，在监听9999，等待客户端的连接，并保持通信
public class QQServer {
    private ServerSocket serverSocket=null;
    //创建一个集合，存放多个用户，如果是这些用户登陆，就合法
    //这里也可以使用ConcurrentHashMap，可以处理兵法的集合，没有线程安全
    //HashMap没有处理线程安全，多线程情况下是不安全的
    //ConcurrentHashMap处理的线程安全，即线程同步处理，在多线程情况下安全
    private static HashMap<String,User> validUsers=new HashMap<>();

    static {//在静态代码块里面初始化validUsers
        validUsers.put("100",new User("100","123456"));
        validUsers.put("200",new User("200","123456"));
        validUsers.put("艾伦",new User("艾伦","123456"));
        validUsers.put("三笠",new User("三笠","123456"));
        validUsers.put("兵长",new User("兵长","123456"));
    }

    //验证用户是否有效
    public boolean checkUser(String userId,String pwd) {
        User user=validUsers.get(userId);
        if(user==null) {//UserId没有存在validUser的key
            return false;
        }
        if(!user.getPwd().equals(pwd)) {//id正确，密码错误
            return false;
        }
        return true;
    }

    public QQServer() {
        //端口可以写在配置文件当中
        System.out.println("服务器端在9999端口进行监听...");
        try {
            serverSocket=new ServerSocket(9999);
            //当与客户端连接完成后，服务器端的监听是一直在进行的
            while(true) {
                Socket socket=serverSocket.accept();//没有客户端连接就会一直阻塞在这里
                //通过得到的socket进行读取关联对象的输入流
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                //读取客户端发送的User对象
                User user=(User)ois.readObject();
                //用户登陆信息的验证
                //创建一个Message对象，准备恢复客户端
                Message message=new Message();
                //得到socket对象关联的对象输出流
                ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                if(checkUser(user.getUserId(), user.getPwd())) {//登陆成功
                    message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);
                    //将message对象回复给客户端
                    oos.writeObject(message);
                    //创建一个线程，和客户端保持通信，该线程需要持有socket对象
                    ServerConnectClientThread serverConnectClientThread =
                            new ServerConnectClientThread(socket, user.getUserId());
                    //启动一个线程
                    serverConnectClientThread.start();
                    //将该线程对象放到一个集合当中，进行管理
                    ManageServerThread.addServerThread(user.getUserId(), serverConnectClientThread);
                }else {//登陆失败
                    System.out.println("用户 "+user.getUserId()+" 登陆失败");
                    message.setMesType(MessageType.MESSAGE_LOGIN_FAIL);
                    oos.writeObject(message);//返回失败消息
                    socket.close();//关闭socket流
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            //服务器端退出while，说明该服务器端已经不在监听了，关闭ServerSocket
            try {
                serverSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

当用户验证登陆成功之后需要创建一个线程和客户端保持通信，该线程持有一个socket对象

ServerConnectClientThread类如下：

import com.qq.common.Message;

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

//该类的对象和某个客户端保持通信
public class ServerConnectClientThread extends Thread{
    private Socket socket;
    private String userId;//用来区别与哪一个用户保持通讯

    public ServerConnectClientThread(Socket socket, String userId) {
        this.socket = socket;
        this.userId = userId;
    }

    @Override
    public void run() {//该线程一直处于运行状态，可以接收和发送消息
        while(true) {
            System.out.println("服务器端与客户端 "+userId+" 保持通信，读取数据....");
            try {
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                Message message=(Message)ois.readObject();
                //后面通过message传发消息
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
}

当有多个线程时，需要创建一个管理线程的类，ManageServerThread类如下：

import java.util.HashMap;

//该类用于管理和客户端进行通信的线程
public class ManageServerThread {
    private static HashMap<String,ServerConnectClientThread> hm=new HashMap<>();

    //添加线程对象到线程集合
    public static void addServerThread(String userId,ServerConnectClientThread thread) {
        hm.put(userId,thread);
    }

    //根据userId得到线程集合中的一个线程对象
    public static ServerConnectClientThread getServerConnectClientThread(String userId) {
        return hm.get(userId);
    }
}