多用户通讯系统(网络编程,多线程,IO流,面向对象)项目介绍共同属性客服端服务端总结

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
package utilss;


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

import java.util.Scanner;

/**

	
*/
public class Utility {
	//静态属性。。。
    private static Scanner scanner = new Scanner(System.in);

    
    /**
     * 功能：读取键盘输入的一个菜单选项，值：1——5的范围
     * @return 1——5
     */
	public static char readMenuSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);//包含一个字符的字符串
            c = str.charAt(0);//将字符串转换成字符char类型
            if (c != '1' && c != '2' && 
                c != '3' && c != '4' && c != '5') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }

	/**
	 * 功能：读取键盘输入的一个字符
	 * @return 一个字符
	 */
    public static char readChar() {
        String str = readKeyBoard(1, false);//就是一个字符
        return str.charAt(0);
    }
    /**
     * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
     * @param defaultValue 指定的默认值
     * @return 默认值或输入的字符
     */
    
    public static char readChar(char defaultValue) {
        String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
        return (str.length() == 0) ? defaultValue : str.charAt(0);
    }
	
    /**
     * 功能：读取键盘输入的整型，长度小于2位
     * @return 整数
     */
    public static int readInt() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(10, false);//一个整数，长度<=10位
            try {
                n = Integer.parseInt(str);//将字符串转换成整数
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /**
     * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
     * @param defaultValue 指定的默认值
     * @return 整数或默认值
     */
    public static int readInt(int defaultValue) {
        int n;
        for (; ; ) {
            String str = readKeyBoard(10, true);
            if (str.equals("")) {
                return defaultValue;
            }
			
			//异常处理...
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    /**
     * 功能：读取键盘输入的指定长度的字符串
     * @param limit 限制的长度
     * @return 指定长度的字符串
     */

    public static String readString(int limit) {
        return readKeyBoard(limit, false);
    }

    /**
     * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
     * @param limit 限制的长度
     * @param defaultValue 指定的默认值
     * @return 指定长度的字符串
     */
	
    public static String readString(int limit, String defaultValue) {
        String str = readKeyBoard(limit, true);
        return str.equals("")? defaultValue : str;
    }
    
	/**
	 * 功能：读取键盘输入的确认选项，Y或N
	 * 将小的功能，封装到一个方法中.
	 * @return Y或N
	 */
    public static char readConfirmSelection() {
        System.out.println("请输入你的选择(Y/N): 请小心选择");
        char c;
        for (; ; ) {//无限循环
        	//在这里，将接受到字符，转成了大写字母
        	//y => Y n=>N
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入:");
            }
        }
        return c;
    }
    /**
     * 功能： 读取一个字符串
     * @param limit 读取的长度
     * @param blankReturn 如果为true ,表示 可以读空字符串。 
     * 					  如果为false表示 不能读空字符串。
     * 			
	 *	如果输入为空，或者输入大于limit的长度，就会提示重新输入。
     * @return
     */
    private static String readKeyBoard(int limit, boolean blankReturn) {
        
		//定义了字符串
		String line = "";

		//scanner.hasNextLine() 判断有没有下一行
        while (scanner.hasNextLine()) {
            line = scanner.nextLine();//读取这一行
           
			//如果line.length=0, 即用户没有输入任何内容，直接回车
			if (line.length() == 0) {
                if (blankReturn) return line;//如果blankReturn=true,可以返回空串
                else continue; //如果blankReturn=false,不接受空串，必须输入内容
            }

			//如果用户输入的内容大于了 limit，就提示重写输入  
			//如果用户如的内容 >0 <= limit ,我就接受
            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }
        return line;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package common;
/**
 * 表示消息的类型
 */
public interface MessageType {
    String MESSAGE_LOGIN_SUCCEED = "1"; //表示登录成功
    String MESSAGE_LOGIN_FAIL = "2"; // 表示登录失败
    String MESSAGE_COMM_MES = "3"; //普通信息
    String MESSAGE_GET_ONLINE_FRIEND = "4"; //要求返回在线用户列表
    String MESSAGE_RET_ONLINE_FRIEND = "5"; //返回在线用户列表
    String MESSAGE_CLIENT_EXIT = "6"; //客户端请求退出
    String MESSAGE_TO_ALL_MES = "7"; //群发消息
    String MESSAGE_FILE_MES = "8"; //文件消息(发送文件)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package common;
import java.io.Serializable;		//序列化
public class Message implements Serializable {
    private static final long serialVersionUID = 1419003708355194092L;
    private String sender;//发送者
    private String getter;//接收者
    private String content;//内容
    private String sendTime;//发生时间
    private String mesType; //消息类型

    //文件相关扩展
    private byte[] fileBytes;
    private int fileLen = 0;
    private String desc;
    private String src;
    
    public byte[] getFileBytes() { return fileBytes; }
    public void setFileBytes(byte[] fileBytes) { this.fileBytes = fileBytes; }
    public int getFileLen() { return fileLen; }
    public void setFileLen(int fileLen) { this.fileLen = fileLen; }
    public String getDesc() { return desc; }
    public void setDesc(String desc) { this.desc = desc; }
    public String getSrc() { return src; }
    public void setSrc(String src) { this.src = src; }
    public String getMesType() { return mesType; }
    public void setMesType(String mesType) { this.mesType = 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; }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package common;
import java.io.Serializable;
public class User implements Serializable {
	//serialVersionUID 序列化编号
    private static final long serialVersionUID = 6889194987676953061L;
    private String userID;
    private String passwd;
    public User(){};
    public User(String userID, String passwd) {
        this.userID = userID;
        this.passwd = passwd;
    }
    public String getUserID() { return userID; }
    public void setUserID(String userID) { this.userID = userID; }
    public String getPasswd() { return passwd; }
    public void setPasswd(String passwd) { this.passwd = passwd; }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package view;

import server.ChatClientServer;
import server.FileClientServer;
import server.UserClientServer;
import utils.Utility;

/**
 * 登录界面
 */
public class QQView {
    private boolean loop = true;    //控制是否显示菜单
    private String key = "";        //接收用户的键盘输入
    private UserClientServer ucs = new UserClientServer();//是用于登录服务器,注册用法
    private ChatClientServer ccs = new ChatClientServer();//聊天
    private FileClientServer fcs = new FileClientServer();//发文件

    public static void main(String[] args) {
        new QQView().mainMenu();
        System.out.println("客户端退出系统......");
    }

    //显示主菜单
    private void mainMenu() {
        while (loop) {
            System.out.println("============欢迎登录我们网络通讯系统============");
            System.out.println("tttt 1 登录系统");
            System.out.println("tttt 9 退出系统");
            System.out.print("请输入你的选择: ");
            key = Utility.readString(1);
            switch (key) {
                case "1":
                    System.out.print("请输入用户号: ");
                    String userId = Utility.readString(50);
                    System.out.print("请输入密  码: ");
                    String pwd = Utility.readString(50);
                    if (ucs.checkUser(userId,pwd)) {
                        //进入二级菜单
                        System.out.println("============欢迎用户 "+userId+" 登陆成功============");
                        while (loop){
                            System.out.println("=============网路通讯系统二级菜单=============");
                            System.out.println("ttt 1 显示在线用户列表");
                            System.out.println("ttt 2 群发消息");
                            System.out.println("ttt 3 私聊消息");
                            System.out.println("ttt 4 发送文件");
                            System.out.println("ttt 9 退出系统");
                            System.out.print("请输入你的选择: ");
                            key = Utility.readString(1);
                            String content = "";
                            switch (key){
                                case "1":
                                    ucs.onLineUserList();
                                    break;
                                case "2":
                                    System.out.print("请输入想对大家说的话:");
                                    content = Utility.readString(100);
                                    ccs.sendMessageToAll(userId,content);
                                    break;
                                case "3":
                                    System.out.print("请输入接收方的ID(在线):");
                                    String getterId = Utility.readString(10);
                                    System.out.print("请输入您要发送的内容:");
                                    content = Utility.readString(100);
                                    ccs.sendMessageToOne(userId,getterId,content);
                                    break;
                                case "4":
                                    System.out.print("请输入你要发送的对象:");
                                    String getterId1 = Utility.readString(10);
                                    System.out.print("请输入您要发送的文件路径:");
                                    String src = Utility.readString(30);
                                    System.out.print("请输入你要发送到对方什么位置:");
                                    String desc = Utility.readString(30);
                                    fcs.sendFileToOne(userId,getterId1,src,desc);
                                    break;
                                case "9":
                                    loop = false;
                                    ucs.logout();
                                    break;
                            }
                        }
                    }else {
                        System.out.println("登陆失败......");
                    }
                    break;
                case "9":
                    loop = false;
                    break;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package server;

import common.Message;
import common.MessageType;

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

public class ClientConnectServerThread extends Thread {
    //该线程需要持有socket
    private Socket socket;
    public ClientConnectServerThread(Socket socket) {
        this.socket = socket;
    }
    public Socket getSocket() {
        return socket;
    }

    @Override
    public void run() {
        //因为Thread需要在后台和服务端通讯
        while (true) {
            try {
                System.out.println("客户端等待服务端传过来消息");
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                Message message = (Message) ois.readObject(); //如果服务器没有发送message对象,线程就会阻塞在这里

                //判断这个Message的类型
                if (message.getMesType().equals(MessageType.MESSAGE_RET_ONLINE_FRIEND)) {   //返回在线列表信息

                    String[] onLineUsers = message.getContent().split(" ");
                    System.out.println("n===========当前现在用户列表==========");
                    for (int i = 0; i < onLineUsers.length; i++) {
                        System.out.println("用户:" + onLineUsers[i]);
                    }
                } else if (message.getMesType().equals(MessageType.MESSAGE_COMM_MES)) {//私聊
                    System.out.println("n" + message.getSender()
                            + " 对 " + message.getGetter() + " 说:" + message.getContent());
                } else if (message.getMesType().equals(MessageType.MESSAGE_TO_ALL_MES)) {//群聊
                    System.out.println("n" + message.getSender()
                            + " 对大家说:" + message.getContent());
                } else if (message.getMesType().equals(MessageType.MESSAGE_FILE_MES)) {//发文件
                    byte[] fileBytes = message.getFileBytes();
                    String desc = message.getDesc();
                    FileOutputStream fos = new FileOutputStream(desc);
                    fos.write(fileBytes);
                    fos.close();
                    System.out.println("成功接收" + message.getSender() + "的文件");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package server;
import java.util.HashMap;
/**
 * 管理客户端连接到服务端线程的一个类
 */
public class ManageClientConnectServerThread {
    //多个线程放到HashMap中  key 用户ID   value 连接服务端线程
    private static HashMap<String, ClientConnectServerThread> hm = new HashMap<>();

    //将某个线程加入到集合中
    public static void addClientConnectServerThread(String id,ClientConnectServerThread thread){
        hm.put(id,thread);
    }
    //通过userID可以得到对应的线程
    public static ClientConnectServerThread getClientConnectServerThread(String id){
        return hm.get(id);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
package server;

import common.Message;
import common.MessageType;
import common.User;

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

/**
 * 用户登录验证和用户注册等功能
 */
public class UserClientServer {
    //因为在其他地方要使用到user信息,所以做成成员
    private User user = new User();
    //socket也要在其他地方使用
    private Socket socket;
	
	//验证账户是否正确，并且连接服务器
    public boolean checkUser(String userID, String pwd) {
        boolean flag = false;
        //创建User对象
        user.setUserID(userID);
        user.setPasswd(pwd);

        try {
            //连接到服务器,发送user对象192.168.176.1
            socket = new Socket(InetAddress.getByName("192.168.176.1"), 9999);
            //得到对象流对象
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(user);      //发送user对象

            //读取服务端回送的对象
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            Message o = (Message) ois.readObject();
            //
            if (o.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) {
                flag = true;
                //创建一个和服务器端保持通讯的线程
                ClientConnectServerThread thread = new ClientConnectServerThread(socket);
                thread.start();
                //将线程放到一个集合中,方便后续操作(对于客服端没用,因为只有一个子线程)
                ManageClientConnectServerThread.addClientConnectServerThread(userID, thread);
            } else {
                //如果失败,就不能启动和服务器的线程,关闭socket
                socket.close();;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }
    //显示在线用户列表
    public void onLineUserList(){
        //发送一个message
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_GET_ONLINE_FRIEND);
        message.setSender(user.getUserID());
        try {
            //发送给服务器
            ObjectOutputStream oos =        //通过管理线程的到对应的socket,然后得到socket对应的输出流
                    new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(user.getUserID()).getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //退出客户端,并给服务端退出的message对象
    public void logout(){
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_CLIENT_EXIT);
        message.setSender(user.getUserID());    //要明确哪个客服端
        try {
            //ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            //因为现在一个客户端进程只有一个线程,所以这种写法也是对的,但是如果有多个线程那就不能用此socket
            ObjectOutputStream oos =
                    new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(user.getUserID()).getSocket().getOutputStream());
            oos.writeObject(message);
            System.out.println(user.getUserID()+"退出系统");
            System.exit(0);     //结束进程
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package server;

import common.Message;
import common.MessageType;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Date;
/**
 * 建立聊天服务
 */
public class ChatClientServer {
    /**
     * @param senderId 发送者
     * @param getterId 接收者
     * @param content  内容
     */
     //私聊
    public void sendMessageToOne(String senderId, String getterId, String content) {
        //构建message
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_COMM_MES);
        message.setSender(senderId);
        message.setGetter(getterId);
        message.setContent(content);
        message.setSendTime(new Date().toString()); //发送时间
        System.out.println(senderId + " 对 " + getterId + " 说 " + content);

        try {
            //发送
            ObjectOutputStream oos =
                    new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderId).getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //群聊
    public void sendMessageToAll(String senderId, String content) {
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_TO_ALL_MES);
        message.setSender(senderId);
        message.setContent(content);
        message.setSendTime(new Date().toString());
        System.out.println("我 对大家说 " + content);
        try {
            //发送
            ObjectOutputStream oos =
                    new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderId).getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package server;

import common.Message;
import common.MessageType;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class FileClientServer {
    /**
     * @param senderId 发送者
     * @param getterId 接收者
     * @param src      发送路径
     * @param desc     接收路径
     */
    public void sendFileToOne(String senderId, String getterId, String src, String desc) {
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_FILE_MES);
        message.setSender(senderId);
        message.setGetter(getterId);
        message.setSrc(src);
        message.setDesc(desc);
        FileInputStream fis = null;
        byte[] bytes = new byte[(int) new File(src).length()];
        try {
            fis = new FileInputStream(src);
            fis.read(bytes);
            message.setFileBytes(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("n" + senderId + " 给 " + getterId + "发了文件");
        try {
            ObjectOutputStream oos =
                    new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderId).getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
package server;

import common.Message;
import common.MessageType;
import 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.ArrayList;
import java.util.HashMap;

/**
 * 这是服务端,在监听端口9999,等待客户端的连接,并保持通讯
 */
public class QQServer {
    private ServerSocket ss = null;
    //创建集合存放多个用户
    //HashMap没有处理线程安全,在多线程情况下是不安全的
    //ConcurrentHashMap处理线程安全(线程同步处理),在多线程情况下是安全的
    private static HashMap<String, User> validUsers = new HashMap<>();  //用集合代替Mysql
    public static HashMap<String, ArrayList<Message>> notOnLineMessages = new HashMap<>();  //存储离线信息

    //启动服务端
    public static void main(String[] args) {
        new QQServer();
    }

    static {        //静态代码块,伴随着类的加载而加载一次
        validUsers.put("100", new User("100", "12345"));
        notOnLineMessages.put("100", new ArrayList<>());
        validUsers.put("200", new User("200", "12345"));
        notOnLineMessages.put("200", new ArrayList<>());
        validUsers.put("300", new User("300", "12345"));
        notOnLineMessages.put("300", new ArrayList<>());
        validUsers.put("小灰洁", new User("小灰洁", "12345"));
        notOnLineMessages.put("小灰洁", new ArrayList<>());
        validUsers.put("sxy", new User("sxy", "12345"));
        notOnLineMessages.put("sxy", new ArrayList<>());
        validUsers.put("syj", new User("syj", "12345"));
        notOnLineMessages.put("syj", new ArrayList<>());
    }

    //判断账号和密码是否正确
    private boolean checkUser(String userID, String pwd) {
        User user = validUsers.get(userID);
        if (user == null) return false;
        if (user.getPasswd().equals(pwd)) return true;
        return false;
    }

    public QQServer() {
        //端口可以写在配置文件里
        try {
            System.out.println("服务端在9999端口监听...");
            //启动新闻推送
            new Thread(new SendNewsToAll()).start();
            ss = new ServerSocket(9999);

            while (true) { //和某个客户端连接后,继续监听
                Socket socket = ss.accept();    //用于连接客户端的socket

                //得到socket关联的对象输入流  接收用户发送的账户信息
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                User user = (User) ois.readObject();

                //得到socket关联的对象输出流  返回验证信息
                ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                Message message = new Message();

                //验证用户
                if (checkUser(user.getUserID(), user.getPasswd())) {
                    message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);
                    oos.writeObject(message);

                    //判断是否有客服端在此客户端没上线时，发来离线信息，如果有就显示
                    ArrayList<Message> messages = notOnLineMessages.get(user.getUserID());
                    if (messages.size() != 0) {
                        for (int i = 0; i < messages.size(); i++) {
                            Message message1 = messages.get(i);
                            ObjectOutputStream oos1 = new ObjectOutputStream(socket.getOutputStream());
                            oos1.writeObject(message1);
                        }
                    }
                    notOnLineMessages.remove(user.getUserID()); //移除离线相关信息


                    //创建一个线程,和客户端保持通讯,该线程需要持有socket对象
                    ServerConnectClientThread thread = new ServerConnectClientThread(socket, user.getUserID());
                    thread.start();
                    //因为一个客服端，建立多个子线程，所以为了方便管理，将所有子线程存入到集合中，方便使用
                    ManageServerConnectClientThread.addServerConnectClientThread(user.getUserID(), thread);
                } else {
                    //密码错误，也要进行信息反馈
                    System.out.println("密码错误");
                    message.setMesType(MessageType.MESSAGE_LOGIN_FAIL);
                    oos.writeObject(message);
                    oos.flush();
                    //登录失败,要关闭socket
                    socket.close();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                ss.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package server;

import common.Message;
import common.MessageType;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.HashMap;
import java.util.Iterator;

/**
 * 该类对应的对象和客户端保持通讯
 */
public class ServerConnectClientThread extends Thread {
    private Socket socket;
    private String userId;//连接到服务端的id

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

    public Socket getSocket() {
        return socket;
    }

    @Override
    public void run() {     //可以接收发送消息
        while (true) {
            try {
                System.out.println("服务端和客服端" + userId + "保持通信,读取数据...");
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                Message message = (Message) ois.readObject();
                if (message.getMesType().equals(MessageType.MESSAGE_GET_ONLINE_FRIEND)) {//在线用户列表
                    System.out.println(message.getSender() + " 要在线用户列表");
                    //得到用户列表
                    String onLineUser = ManageServerConnectClientThread.getOnLineUser();
                    //返回的数据信息
                    Message message1 = new Message();
                    message1.setMesType(MessageType.MESSAGE_RET_ONLINE_FRIEND);
                    message1.setContent(onLineUser);
                    message1.setGetter(message.getSender());
                    //写入到数据通道
                    ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                    oos.writeObject(message1);

                } else if (message.getMesType().equals(MessageType.MESSAGE_CLIENT_EXIT)) {//客服端下线,服务端子线程退出
                    System.out.println(message.getSender() + "退出系统");
                    //将客服端对应的线程删除
                    ManageServerConnectClientThread.deleteServerConnectClientThread(message.getSender());
                    socket.close();
                    break;

                } else if (message.getMesType().equals(MessageType.MESSAGE_COMM_MES)) { //私聊
                    if (ManageServerConnectClientThread.getServerConnectClientThread(message.getGetter())==null){
                        QQServer.notOnLineMessages.get(message.getGetter()).add(message);//离线消息存储
                    }else {
                        //根据message获取getterId,的到对应的线程
                        ObjectOutputStream oos = new
                                ObjectOutputStream(ManageServerConnectClientThread.getServerConnectClientThread(message.getGetter()).getSocket().getOutputStream());
                        oos.writeObject(message);
                    }

                } else if (message.getMesType().equals(MessageType.MESSAGE_TO_ALL_MES)) { //群发
                    //遍历全部客户
                    HashMap<String, ServerConnectClientThread> hm = ManageServerConnectClientThread.getHm();
                    Iterator<String> iterator = hm.keySet().iterator();
                    while (iterator.hasNext()) {
                        //获取在线用户ID
                        String userId = iterator.next().toString();
                        if (!userId.equals(message.getSender())){
                            ObjectOutputStream oos =
                                    new ObjectOutputStream(hm.get(userId).getSocket().getOutputStream());
                            oos.writeObject(message);
                        }
                    }
                }else if (message.getMesType().equals(MessageType.MESSAGE_FILE_MES)){   //发文件
                    if (ManageServerConnectClientThread.getServerConnectClientThread(message.getGetter())==null){
                        QQServer.notOnLineMessages.get(message.getGetter()).add(message);   //如果不在线
                    }else {
                        ObjectOutputStream oos = new
                                ObjectOutputStream(ManageServerConnectClientThread.getServerConnectClientThread(message.getGetter()).getSocket().getOutputStream());
                        oos.writeObject(message);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package server;

import java.util.HashMap;
import java.util.Iterator;

public class ManageServerConnectClientThread {
    private static HashMap<String, ServerConnectClientThread> hm = new HashMap<>();

    public static HashMap<String, ServerConnectClientThread> getHm() {
        return hm;
    }

    //添加线程对象到集合里面
    public static void addServerConnectClientThread(String userId, ServerConnectClientThread thread) {
        hm.put(userId,thread);
    }
    //删除线程对象
    public static void deleteServerConnectClientThread(String userId){
        hm.remove(userId);
    }
    public static ServerConnectClientThread getServerConnectClientThread(String userId){
        return hm.get(userId);
    }

    //返回在线用户列表
    public static String getOnLineUser(){
        //遍历HashMap
        Iterator<String> iterator = hm.keySet().iterator();
        String onLineUserList = "";
        while (iterator.hasNext()){
            onLineUserList += iterator.next().toString()+" ";
        }
        return onLineUserList;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package server;

import common.Message;
import common.MessageType;
import utilss.Utility;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;

public class SendNewsToAll implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("请输入服务器要推送的消息[输入exit表示退出]");
            String news = Utility.readString(1000);
            if ("exit".equals(news)){
                break;
            }
            //构建消息
            Message message = new Message();
            message.setMesType(MessageType.MESSAGE_TO_ALL_MES);
            message.setSender("server");
            message.setContent(news);
            message.setSendTime(new Date().toString());
            System.out.println("服务器推送给所有人消息:"+news);

            //遍历所有线程
            HashMap<String, ServerConnectClientThread> hm = ManageServerConnectClientThread.getHm();
            Iterator<String> iterator = hm.keySet().iterator();
            while (iterator.hasNext()){
                String onLineUserId = iterator.next().toString();
                ServerConnectClientThread thread = hm.get(onLineUserId);
                try {
                    ObjectOutputStream oos = new ObjectOutputStream(thread.getSocket().getOutputStream());
                    oos.writeObject(message);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}