day02-代码实现01

多用户即时通讯系统02

4.编码实现01

4.1功能实现-用户登录

4.1.1功能说明

因为还没有学习数据库，我们人为规定 用户名/id = 100，密码为 123456 就可以登录，其他用户不能登录，后面使用HashMap模拟数据库，这样就可以多个用户登录。
4.1.2思路分析+框架图

用户的登录功能的流程：

• 用户进入系统界面，选择登录
  
• 输入登录信息之后，客户端与服务端建立连接，把信息发送给服务端
  
• 服务端接收信息，在数据库中进行校验，作出判断
  
• 服务端将判断返回客户端
  
• 客户端接收信息后，进行下一步操作（成功则进入二级菜单，失败则请求用户重新输入）
  

4.1.3代码实现

4.1.3.1客户端代码

1.User类

用户输入登录信息后，在客户端发送信息给服务端的过程中，为了方便数据的解析（比如用户id、用户密码等），使用对象来进行数据的传输

1. package qqcommon;
3. import java.io.Serializable;
5. /**
6. * @author 李
7. * @version 1.0
8. * 表示一个用户信息
9. */
10. public class User implements Serializable {//要序列化某个对象，实现接口Serializable
11.     private static final long serialVersionUID = 1L;//声明序列化版本号，提高兼容性
12.     private String userId;//用户id/用户名
13.     private String password;//用户密码
15.     public User() {
16.     }
18.     public User(String uerId, String password) {
19.         this.userId = uerId;
20.         this.password = password;
21.     }
23.     public String getUerId() {
24.         return userId;
25.     }
27.     public void setUerId(String uerId) {
28.         this.userId = uerId;
29.     }
31.     public String getPassword() {
32.         return password;
33.     }
35.     public void setPassword(String password) {
36.         this.password = password;
37.     }
38. }

复制代码

2.Message类

表示客户端和服务器端通讯时的消息对象，目的同User

1. package qqcommon;
3. import java.io.Serializable;
5. /**
6. * @author 李
7. * @version 1.0
8. * 表示客户端和服务器端通讯时的消息对象
9. */
10. public class Message implements Serializable {
11.     private static final long serialVersionUID = 1L;//声明序列化版本号，提高兼容性
12.     //因为客户端之间的通信都要依靠服务端，因此信息必须要写明接收者和发送者等
13.     private String sender;//发送者
14.     private String getter;//接收者
15.     private String content;//消息内容
16.     private String sendTime;//发送时间  -因为发送时间也要被序列化，因此这里也用String类型
17.     private String mesType;//消息类型[可以在接口中定义消息类型]
19.     public String getMesType() {
20.         return mesType;
21.     }
23.     public void setMesType(String mesType) {
24.         this.mesType = mesType;
25.     }
27.     public String getSender() {
28.         return sender;
29.     }
31.     public void setSender(String sender) {
32.         this.sender = sender;
33.     }
35.     public String getGetter() {
36.         return getter;
37.     }
39.     public void setGetter(String getter) {
40.         this.getter = getter;
41.     }
43.     public String getContent() {
44.         return content;
45.     }
47.     public void setContent(String content) {
48.         this.content = content;
49.     }
51.     public String getSendTime() {
52.         return sendTime;
53.     }
55.     public void setSendTime(String sendTime) {
56.         this.sendTime = sendTime;
57.     }
58. }

复制代码

3.MessageType接口

1. package qqcommon;
3. /**
4. * @author 李
5. * @version 1.0
6. * 表示消息类型
7. */
8. public interface MessageType {
9.     //在接口中定义类一些常量，不同的常量的表示不同的消息类型
10.     String MESSAGE_LOGIN_SUCCEED = "1";//表示登录成功
11.     String MESSAGE_LOGIN_FAIL = "2";//表示登录失败
13. }

复制代码

4.QQView类

主程序入口，显示菜单

1. package qqclient.view;
4. import qqclient.service.UserClientService;
5. import qqclient.utils.Utility;
7. /**
8. * @author 李
9. * @version 1.0
10. */
11. public class QQView {
12.     private boolean loop = true;//控制是否显示菜单
13.     private String key = "";//用来接收用户的键盘输入
14.     private UserClientService userClientService = new UserClientService();//该对象用于登录服务/注册用户
16.     public static void main(String[] args) {
17.         new QQView().mainMenu();
18.         System.out.println("客户端退出系统......");
19.     }
21.     //显示主菜单
22.     public void mainMenu() {
23.         while (loop) {
24.             System.out.println("===========欢迎登陆网络通信系统===========");
25.             System.out.println("\t\t 1 登录系统");
26.             System.out.println("\t\t 9 退出系统");
27.             System.out.print("请输入你的选择：");
28.             key = Utility.readString(1);//读取键盘输入的指定长度的字符串
30.             //根据用户的输入，来处理不同的逻辑
31.             switch (key) {
32.                 case "1":
33.                     System.out.print("请输入用户号：");
34.                     String userId = Utility.readString(50);//读取键盘输入的指定长度的字符串
35.                     System.out.print("请输入密  码：");
36.                     String pwd = Utility.readString(50);
38.                     // 到服务端去验证用户是否合法
39.                     //这里有很多代码,我们这里编写一个类UserClientService[提供用户登录/注册等功能]
40.                     if (userClientService.checkUser(userId, pwd)) {//验证成功
41.                         System.out.println("=========欢迎（用户 " + userId + " 登录成功）=========");
42.                         //进入到二级菜单
43.                         while (loop) {
44.                             System.out.println("\n=========网络通讯系统二级菜单（用户 " + userId + " ）==========");
45.                             System.out.println("\t\t 1 显示在线用户列表");
46.                             System.out.println("\t\t 2 群发消息");
47.                             System.out.println("\t\t 3 私聊消息");
48.                             System.out.println("\t\t 4 发送文件");
49.                             System.out.println("\t\t 9 退出系统");
50.                             System.out.print("请输入你的选择：");
51.                             key = Utility.readString(1);
52.                             switch (key) {
53.                                 case "1":
54.                                     System.out.println("显示在线用户列表");
55.                                     break;
56.                                 case "2":
57.                                     System.out.println("群发消息");
58.                                     break;
59.                                 case "3":
60.                                     System.out.println("私聊消息");
61.                                     break;
62.                                 case "4":
63.                                     System.out.println("发送文件");
64.                                     break;
65.                                 case "9":
66.                                     loop = false;//退出循环
67.                                     break;
68.                             }
69.                         }
70.                     } else {//验证失败
71.                         System.out.println("=========登录失败========");
72.                     }
73.                     break;
74.                 case "9":
75.                     loop = false;//退出循环
76.                     break;
77.             }
78.         }
79.     }
80. }

复制代码

5.Utility类

工具类，用于处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。

1. package qqclient.utils;
4. /**
5. * 工具类的作用:
6. * 处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
7. */
9. import java.util.Scanner;
11. /**
14. */
15. public class Utility {
16.     //静态属性。。。
17.     private static Scanner scanner = new Scanner(System.in);
20.     /**
21.      * 功能：读取键盘输入的一个菜单选项，值：1——5的范围
22.      * @return 1——5
23.      */
24.     public static char readMenuSelection() {
25.         char c;
26.         for (; ; ) {
27.             String str = readKeyBoard(1, false);//包含一个字符的字符串
28.             c = str.charAt(0);//将字符串转换成字符char类型
29.             if (c != '1' && c != '2' &&
30.                     c != '3' && c != '4' && c != '5') {
31.                 System.out.print("选择错误，请重新输入：");
32.             } else break;
33.         }
34.         return c;
35.     }
37.     /**
38.      * 功能：读取键盘输入的一个字符
39.      * @return 一个字符
40.      */
41.     public static char readChar() {
42.         String str = readKeyBoard(1, false);//就是一个字符
43.         return str.charAt(0);
44.     }
46.     /**
47.      * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
48.      * @param defaultValue 指定的默认值
49.      * @return 默认值或输入的字符
50.      */
52.     public static char readChar(char defaultValue) {
53.         String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
54.         return (str.length() == 0) ? defaultValue : str.charAt(0);
55.     }
57.     /**
58.      * 功能：读取键盘输入的整型，长度小于2位
59.      * @return 整数
60.      */
61.     public static int readInt() {
62.         int n;
63.         for (; ; ) {
64.             String str = readKeyBoard(10, false);//一个整数，长度<=10位
65.             try {
66.                 n = Integer.parseInt(str);//将字符串转换成整数
67.                 break;
68.             } catch (NumberFormatException e) {
69.                 System.out.print("数字输入错误，请重新输入：");
70.             }
71.         }
72.         return n;
73.     }
75.     /**
76.      * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
77.      * @param defaultValue 指定的默认值
78.      * @return 整数或默认值
79.      */
80.     public static int readInt(int defaultValue) {
81.         int n;
82.         for (; ; ) {
83.             String str = readKeyBoard(10, true);
84.             if (str.equals("")) {
85.                 return defaultValue;
86.             }
88.             //异常处理...
89.             try {
90.                 n = Integer.parseInt(str);
91.                 break;
92.             } catch (NumberFormatException e) {
93.                 System.out.print("数字输入错误，请重新输入：");
94.             }
95.         }
96.         return n;
97.     }
99.     /**
100.      * 功能：读取键盘输入的指定长度的字符串
101.      * @param limit 限制的长度
102.      * @return 指定长度的字符串
103.      */
105.     public static String readString(int limit) {
106.         return readKeyBoard(limit, false);
107.     }
109.     /**
110.      * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
111.      * @param limit 限制的长度
112.      * @param defaultValue 指定的默认值
113.      * @return 指定长度的字符串
114.      */
116.     public static String readString(int limit, String defaultValue) {
117.         String str = readKeyBoard(limit, true);
118.         return str.equals("") ? defaultValue : str;
119.     }
122.     /**
123.      * 功能：读取键盘输入的确认选项，Y或N
124.      * 将小的功能，封装到一个方法中.
125.      * @return Y或N
126.      */
127.     public static char readConfirmSelection() {
128.         System.out.println("请输入你的选择(Y/N): 请小心选择");
129.         char c;
130.         for (; ; ) {//无限循环
131.             //在这里，将接受到字符，转成了大写字母
132.             //y => Y n=>N
133.             String str = readKeyBoard(1, false).toUpperCase();
134.             c = str.charAt(0);
135.             if (c == 'Y' || c == 'N') {
136.                 break;
137.             } else {
138.                 System.out.print("选择错误，请重新输入：");
139.             }
140.         }
141.         return c;
142.     }
144.     /**
145.      * 功能： 读取一个字符串
146.      * @param limit 读取的长度
147.      * @param blankReturn 如果为true ,表示 可以读空字符串。
148.      *                   如果为false表示 不能读空字符串。
149.      *
150.      * 如果输入为空，或者输入大于limit的长度，就会提示重新输入。
151.      * @return
152.      */
153.     private static String readKeyBoard(int limit, boolean blankReturn) {
155.         //定义了字符串
156.         String line = "";
158.         //scanner.hasNextLine() 判断有没有下一行
159.         while (scanner.hasNextLine()) {
160.             line = scanner.nextLine();//读取这一行
162.             //如果line.length=0, 即用户没有输入任何内容，直接回车
163.             if (line.length() == 0) {
164.                 if (blankReturn) return line;//如果blankReturn=true,可以返回空串
165.                 else continue; //如果blankReturn=false,不接受空串，必须输入内容
166.             }
168.             //如果用户输入的内容大于了 limit，就提示重写输入
169.             //如果用户如的内容 >0 <= limit ,我就接受
170.             if (line.length() < 1 || line.length() > limit) {
171.                 System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
172.                 continue;
173.             }
174.             break;
175.         }
177.         return line;
178.     }
179. }

复制代码

6.UserClientService类

该类完成用户登录验证和用户注册等功能

1. package qqclient.service;
3. import qqcommon.Message;
4. import qqcommon.MessageType;
5. import qqcommon.User;
7. import java.io.ObjectInputStream;
8. import java.io.ObjectOutputStream;
9. import java.net.InetAddress;
10. import java.net.Socket;
12. /**
13. * @author 李
14. * @version 1.0
15. * 该类完成用户登录验证和用户注册等功能
16. */
17. public class UserClientService {
18.     //因为我们可能在其他地方使用User信息，因此做成成员属性
19.     private User u = new User();
20.     //因为可能在其他地方使用Socket，因此也做成成员属性
21.     private Socket socket;
23.     //根据用户输入的 userId 和 pwd，到服务器去验证该用户是否合法
24.     public boolean checkUser(String userId, String pwd) {
25.         boolean b = false;
26.         //创建User对象
27.         u.setUerId(userId);
28.         u.setPassword(pwd);
30.         try {
31.             //连接服务器，发送u对象
32.             socket = new Socket(InetAddress.getByName("192.168.1.6"), 9999);//指定服务端的ip和端口
33.             //获取ObjectOutputStream对象(对象输出流)
34.             ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
35.             oos.writeObject(u);//向服务端发送User对象，服务器会进行验证
37.             //socket.shutdownOutput();
39.             //服务器验证后，客户端读取从服务端回送的Message对象
40.             ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
41.             Message ms = (Message) ois.readObject();//强转为Message类型
43.             /**取出服务端返回的Message对象中的getMesType属性
44.              * 如果为MESSAGE_LOGIN_SUCCEED则说明登录成功,
45.              * 否则登录失败
46.              * */
47.             if (ms.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) {//登录成功
48.                 //创建一个服务器保持通信的线程
49.                 // -->创建一个类 ClientConnectServerThread，
50.                 // 把socket传到该线程里面，然后把线程放到一个集合里面去管理
51.                 ClientConnectServerThread clientConnectServerThread = new ClientConnectServerThread(socket);
52.                 //启动客户端的线程
53.                 clientConnectServerThread.start();
54.                 //这里为了后面客户端的扩展，我们将线程放入到集合里面
55.                 ManageClientConnectServerThread.addClientConnectServerThread(userId, clientConnectServerThread);
56.                 b = true;
57.             } else {//登录失败
58.                 //如果登录失败，就不启动和服务器通讯的线程，直接关闭socket
59.                 socket.close();
60.             }
61.         } catch (Exception e) {
62.             e.printStackTrace();
63.         }
64.         return b;
65.     }
66. }

复制代码

7.ClientConnectServerThread类

客户端与服务端通过socket连接，考虑到一个客户端会有多个socket的情况（服务端同此），将socket放在线程内

1. package qqclient.service;
3. import qqcommon.Message;
5. import java.io.ObjectInputStream;
6. import java.net.Socket;
8. /**
9. * @author 李
10. * @version 1.0
11. */
12. public class ClientConnectServerThread extends Thread {
13.     //该线程需要持有socket
14.     private Socket socket;
16.     //构造器可以接收一个Socket对象
17.     public ClientConnectServerThread(Socket socket) {
18.         this.socket = socket;
19.     }
21.     @Override
22.     public void run() {
23.         //因为Thread需要在后台和服务器通信，因此我们使用while循环
24.         while (true) {
25.             try {
26.                 System.out.println("客户端线程，等待读取从服务端发送的消息");
27.                 ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
29.                 //如果服务器没有发送Message对象，线程会阻塞在这里
30.                 Message message = (Message) ois.readObject();
31.                 //注意，后面我们需要使用message
33.             } catch (Exception e) {
34.                 e.printStackTrace();
35.             }
36.         }
37.     }
39.     //为了更方便地得到socket，提供get方法
40.     public Socket getSocket() {
41.         return socket;
42.     }
44.     public void setSocket(Socket socket) {
45.         this.socket = socket;
46.     }
47. }

复制代码

8.ManageClientConnectServerThread类

将线程都放入集合中，便于管理

1. package qqclient.service;
3. import java.util.HashMap;
5. /**
6. * @author 李
7. * @version 1.0
8. * 该类管理客户端连接到服务器端的线程的类
9. */
10. public class ManageClientConnectServerThread {
11.     //把多个线程放入到HashMap集合，key就是用户id，value就是线程
12.     private static HashMap<String, ClientConnectServerThread> hm = new HashMap<>();
14.     //将某个线程加入到集合
15.     public static void addClientConnectServerThread(String userId, ClientConnectServerThread clientConnectServerThread) {
16.         hm.put(userId, clientConnectServerThread);
17.     }
19.     //通过userId可以得到一个对应的线程
20.     public static ClientConnectServerThread getClientConnectServerThread(String userId) {
21.         return hm.get(userId);
22.     }
23. }

复制代码

4.1.3.2服务端代码

服务端的User、Message、MessageType和客户端一致，不再赘述
1.QQFrame

1. package qqframe;
3. import qqserver.server.QQServer;
5. /**
6. * @author 李
7. * @version 1.0
8. * 该类创建QQServer，启动后台的服务
9. */
10. public class QQFrame {
11.     public static void main(String[] args) {
12.         new QQServer();
13.     }
14. }

复制代码

2.QQServer

1. package qqserver.server;
3. import qqcommon.Message;
4. import qqcommon.MessageType;
5. import qqcommon.User;
7. import java.io.IOException;
8. import java.io.ObjectInputStream;
9. import java.io.ObjectOutputStream;
10. import java.net.ServerSocket;
11. import java.net.Socket;
12. import java.util.HashMap;
13. import java.util.concurrent.ConcurrentHashMap;
15. /**
16. * @author 李
17. * @version 1.0
18. * 这是服务端，在监听端口9999，等待有客户端连接，并保持通信
19. */
20. public class QQServer {
22.     private ServerSocket ss = null;
23.     //创建一个集合，存放多个用户数据，如果是在集合里面的用户登录，就认为是合法的（模拟数据库）
24.     //这里也可以使用 ConcurrentHashMap，可以处理并发的集合，没有线程安全问题
25.     // HashMap 没有处理线程安全，因此在多线程的情况下是不安全的
26.     // ConcurrentHashMap 处理的线程安全，即线程同步处理，在多线程的情况下是安全的
27.     private static ConcurrentHashMap<String, User> validUsers = new ConcurrentHashMap<>();
29.     static {//在静态代码块，初始化 validUsers
30.         validUsers.put("100", new User("100", "123456"));
31.         validUsers.put("200", new User("200", "123456"));
32.         validUsers.put("300", new User("300", "123456"));
33.         validUsers.put("至尊宝", new User("至尊宝", "123456"));
34.         validUsers.put("紫霞仙子", new User("紫霞仙子", "123456"));
35.     }
37.     //验证用户是否有效的方法
38.     public boolean checkUser(String userId, String password) {
39.         User user = validUsers.get(userId);//在HashMap（模拟数据库）里面找key=userId对应的value=User对象
40.         //过关的验证方式
41.         if (user == null) {//如果User为空（即Value为空）就说明 userId对应的key不存在
42.             return false;
43.         }
44.         if (!user.getPassword().equals(password)) {//如果userId正确，但是密码错误
45.             return false;
46.         }
47.         return true;//如果userId和密码都正确
48.     }
50.     public QQServer() {
52.         //注意：端口可以写在配置文件里面
53.         System.out.println("服务端在9999端口监听...");
54.         try {
55.             ss = new ServerSocket(9999);
57.             while (true) {//循环监听，当和某个客户端建立连接后，会继续监听，因此使用while
58.                 Socket socket = ss.accept();//如果没有客户端连接，就会阻塞在这里，直到有新的客户端来连接
60.                 //得到socket关联的对象输入流
61.                 ObjectInputStream ois =
62.                         new ObjectInputStream(socket.getInputStream());
63.                 User u = (User) ois.readObject();//读取客户端发送的User对象
65.                 /***
66.                  * 下面这里其实是要到数据库区验证User的信息，但是因为还没学数据库，先用规定的数据进行校验
67.                  * HashMap模拟数据库，可以多个用户登录
68.                  */
69.                 //创建一个Message对象，用来回复客户端
70.                 Message message = new Message();
71.                 //得到socket关联的对象输出流
72.                 ObjectOutputStream oos =
73.                         new ObjectOutputStream(socket.getOutputStream());
74.                 //验证
75.                 if (checkUser(u.getUserId(), u.getPassword())) {//登录通过
76.                     message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);
77.                     //将Message对象回复给客户端
78.                     oos.writeObject(message);
79.                     //创建一个线程，和客户端保持通信，该线程需要持有socket对象
80.                     ServerConnectClientThread serverConnectClientThread =
81.                             new ServerConnectClientThread(socket, u.getUserId());
82.                     //启动该线程
83.                     serverConnectClientThread.start();
84.                     //把该线程对象放入到一个集合中，进行管理
85.                     ManageClientThreads.addClientThread(u.getUserId(), serverConnectClientThread);
87.                 } else {//登录失败
88.                     System.out.println("用户 id=" + u.getUserId() + " pwd=" + u.getPassword() + " 验证失败");
89.                     message.setMesType(MessageType.MESSAGE_LOGIN_FAIL);
90.                     oos.writeObject(message);
91.                     //关闭socket
92.                     socket.close();
93.                 }
94.             }
96.         } catch (Exception e) {
97.             e.printStackTrace();
98.         } finally {
100.             //如果服务器退出了while循环，说明服务器不再监听，因此关闭ServerSock
101.             try {
102.                 ss.close();
103.             } catch (IOException e) {
104.                 e.printStackTrace();
105.             }
106.         }
107.     }
108. }

复制代码

3.ServerConnectClientThread

线程类，与客户端的线程类同理

1. package qqserver.server;
3. import qqcommon.Message;
5. import java.io.IOException;
6. import java.io.ObjectInputStream;
7. import java.net.Socket;
9. /**
10. * @author 李
11. * @version 1.0
12. * 该类的一个对象和某个客户端保持通信
13. */
14. public class ServerConnectClientThread extends Thread {
15.     private Socket socket;
16.     private String userId;//连接到服务端的用户id
19.     public ServerConnectClientThread(Socket socket, String userId) {
20.         this.socket = socket;
21.         this.userId = userId;
22.     }
24.     @Override
25.     public void run() {//这里线程处于run的状态，可以发送/接收消息
27.         while (true) {
28.             try {
29.                 System.out.println("服务端和客户端" + userId + "保持通信，读取数据...");
30.                 ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
31.                 Message message = (Message) ois.readObject();
32.                 //后面会使用Message
33.             } catch (Exception e) {
34.                 e.printStackTrace();
35.             }
36.         }
37.     }
38. }

复制代码

4.ManageClientThreads

使用集合来存放线程，便于管理

1. package qqserver.server;
3. import java.util.HashMap;
5. /**
6. * @author 李
7. * @version 1.0
8. * 该类用于管理和客户端通信的线程
9. */
10. public class ManageClientThreads {
11.     private static HashMap<String, ServerConnectClientThread> hm = new HashMap<>();
13.     //添加线程对象到 hm集合中
14.     public static void addClientThread(String userId, ServerConnectClientThread serverConnectClientThread) {
15.         hm.put(userId, serverConnectClientThread);
16.     }
18.     //根据userId返回ServerConnectClientThread线程
19.     public static ServerConnectClientThread getServerConnectClientThread(String userId) {
20.         return hm.get(userId);
21.     }
22. }

复制代码

运行截图：

• 先运行服务端：
  

• 运行客户端，并输入信息：
  
  

此时服务端：
可以看到服务端成功地从客户端获取用户登录信息，匹配相应用户后返回了信息，客户端成功获取到了服务端返回的信息，并进入了二级菜单。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！