总结一下一点心得和体会，源码直接看下面即可

一开始先写一级菜单，然后写左2，对应右2，2主要是验证是否能登录成功的类。‘

只有当我们登录成功之后，我们才会有3的说法以及二级菜单的说法，也就是启动线程执行二级菜单涉及到的业务，多线程有利于维护程序的并发性以及稳定流畅性。。

然后就写出左3和右3，即是线程类

 左3客户端主要是接收右3服务端封装好的message信息，右3服务端处理完成业务逻辑。左3进行简单的输出即可。并且做到一个线程对应一个socket端口

然后就是左4和右4了，主要就是管理这些线程的集合

我们可以这样想：左2和右2是为一级菜单做服务的，

当我们执行进入到第二级菜单时，可能会有多个用户带有多个任务为了并发执行，那么就要用左3和右3启动线程，所以二级菜单中的步骤对应的就是左3和右3相对应进行服务的

1.写出两级菜单

第一级为是否登录，并且输入信息

第二级就是认证能否登录成功

我们把验证用户信息能否进行登录的逻辑写到一个类中

连接服务端 

由于我们这里是网络通信，所以要和服务端进行连接，询问服务端是否有该用户的信息

写出服务端类逻辑：

假设我们选择登录系统

那么我们进行验证时会把userId和passwd传递给验证的类

 我们先进行包装一个User对象，把这个userId和passwd给到我们包装的User对象

通过IO流，客户端先把User这个对象，也就是我们要验证的对象通过对象流传递给服务端进行验证，

服务端通过对象流接收进行验证。

 服务端通过哈希表模拟一个可登录的用户数据库，那么我们就要进行判断封装为一个方法

 那么文件类型应运而生：

假设登录成功，那么我们通过对象流把这个创建出的message对象输出给客户端，这个message对象的MessageType如图：

 登录失败同理即可。

客户端类进行读取

 如果成功，那么就启动线程进行执行任务，为了多线程并发执行，保证系统的稳定运行。。

如果接收到的是不成功，那么就关socket资源走人即可

假设成功：那么进入二级菜单

 二级菜单中执行的方法，直接会对应到服务端的线程进行接收，接收之后执行相关的业务逻辑

 服务端的线程执行二级菜单的业务逻辑之后，并且封装好一个message对象写出到程序通道，客户端的线程进行读取操作即可。。。读取之后进行打印输出到屏幕上

总结一下接下来的思路：

我们先在二级菜单中的选择想要执行的业务，往往都是封装为一个个的方法。把其MessageType等属性封装成一个对象通过对象流传递给程序通道。

服务端有监听端口。然后对应的服务端的线程通过socket端口进行读取，之后执行接收到的任务的业务逻辑，执行完之后封装为一个message对象进行输出到程序通道，

这个时候客户端的线程通过socket端口进行读取然后输出到屏幕上

总的流程就是：

一级菜单流程：

一级菜单进入——》客户端UserClientSevice类发送User对象到服务端QQServer类进行验证是否存在——》QQServer进行验证该User对象是否存在——》返回封装的结果信息对象给客户端的UserClientSevice类

假如说一级菜单验证用户信息成功，那么就可以进行第二级菜单流程了。。。

二级菜单流程：

二级菜单封装的方法【这些方法可以封装到一个类，也可以是之前的原有类中】——>服务端的线程对应socket读取——》服务端的线程进行执行有关业务逻辑——》服务端的线程对应的socket进行输出到程序通道——》客户端的线程对应的socket进行读取message——》进行打印输出到屏幕

项目源码：

 客户端：

1.核心包：

(1) UserClientSevice 类：

package qq.客户端.qqclient.service;import qq.客户端.qqclient.service.ClientConnectServerThread;
import qq.客户端.qqclient.service.ManageClientConnectServerThread;
import qq.客户端.qqserve.Message;
import qq.客户端.qqserve.MessageType;
import qq.客户端.qqserve.User;import java.io.*;
import java.net.InetAddress;
import java.net.Socket;/*** 为了完成该类用户完成用户注册和用户登录的验证功能*/
@SuppressWarnings({"all"})
public class UserClientSevice {//我们可能在别的地方也会使用User这个属性信息和Socket，所以设为属性private static User user=new User();private Socket socket;private boolean b=false;//根据userId和pwd这两个属性到服务器验证该用户是否是合法的public boolean checkUser(String userId,String passwd) throws ClassNotFoundException {//调用设置并且设置属性user.setUserId(userId);user.setPasswd(passwd);try {//连接到服务端，发送user对象，我们使用对象流//InetAddress.getByName("127.0.0.1")表示服务器的IP地址；9999表示服务器的端口号socket=new Socket(InetAddress.getByName("127.0.0.1"),9999);//客户端通过对象流objectOutputStream进行把user这个对象写出到数据通道ObjectOutputStream objectOutputStream=new ObjectOutputStream(socket.getOutputStream());objectOutputStream.writeObject(user);//接收服务端发送到数据通道的Message对象ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());//记住：无论是否服务端能返回一个真的Message对象，这里的Message对象都会接收一个值，// 所以这里写一句，我们后面启动线程才是真的判断是否返回的是真的Message，如果返回假的Message，那么后面线程run的时候会阻塞Message message=(Message) objectInputStream.readObject();//MESSAGE_LOGIN_SUCCEED：为接口中的常量，//默认就是static和final类型的，所以可以使用MessageType这个接口名直接进行访问if(message.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) {//表示登录成功//创建一个和服务端保持联系的线程类 ClientConnectServerThreadClientConnectServerThread css= new ClientConnectServerThread(socket);//启动客户端的线程,//不停的调用run方法，让其不停的读，直到读取到了Message对象才会进行，否则会阻塞在那里css.start();//为了后面客户端的扩展，我们创建一个集合用来存放线程//我们不止一个客户端，所以要创建多个线程，所以要创建线程集合//把这个线程加入到hashMap集合中ManageClientConnectServerThread.addClientConnectServerThread(userId,css);b=true;} else {//表示登录失败，那么我们就要关闭资源socket.close();}} catch (IOException e) {e.printStackTrace();}return b;}public static void LoginExit() {Message message=new Message();message.setMesType(MessageType.MESSAGE_CLIENT_EXIT);message.setSender(user.getUserId());//确定message的发送者是谁try {ObjectOutputStream oos=new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(user.getUserId()).getSocket().getOutputStream());//给服务端发送一个退出系统的messageoos.writeObject(message);System.exit(0);//退出登录} catch (IOException e) {e.printStackTrace();}}//向服务器端要求返回在线用户列表public static void onLineFriendList() {Message message=new Message();//客户端想要从服务端得到：String MESSAGE_RET_ONLINE_FRIEND="5";//返回在线用户列表//  那么就要发送： String MESSAGE_GET_ONLINE_FRIEND="4";//要求返回在线用户列表 给服务端//  给服务端示意一下之后，服务端才会返回MESSAGE_RET_ONLINE_FRIENDmessage.setMesType("MESSAGE_GET_ONLINE_FRIEND");try {//1.通过user.getUserId()得到对应的线程对象//2.通过得到对应线程得到对应socket对象//3.通过socket对象得到对应的输出流ObjectOutputStream oos=new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(user.getUserId()).getSocket().getOutputStream());//发送一个message，向服务端要求在线用户列表oos.writeObject(message);} catch (IOException e) {e.printStackTrace();}}
}

 (2)ClientConnectServerThread类

package qq.客户端.qqclient.service;import qq.客户端.qqserve.Message;
import qq.客户端.qqserve.MessageType;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;/*** 客户端连接到服务器端的线程的类* 用于客户端线程对应的各种*/
@SuppressWarnings({"all"})
public class ClientConnectServerThread extends Thread{//我们把流都存放到线程中去private Socket socket;public ClientConnectServerThread(Socket socket){this.socket=socket;}@Overridepublic void run() {super.run();try {System.out.println("客户端线程等待接收从服务端发送的message消息");ObjectInputStream obs = new ObjectInputStream(socket.getInputStream());//如果服务端没有回送Message消息对象的话，那么线程会阻塞在这里//后面我们的各种消息都是通过message对象来传递的Message message = (Message) obs.readObject();//注意：后面我们需要去使用message//我们判断这个message的类型，然后做相关的业务处理if (message.getMesType().equals(MessageType.MESSAGE_RET_ONLINE_FRIEND)) {//如果读取到的是：服务端返回在线用户列表，那么就要进行返回在线用户列表【区别如下：】// String MESSAGE_RET_ONLINE_FRIEND="5";//返回在线用户列表// String MESSAGE_GET_ONLINE_FRIEND="4";//要求返回在线用户列表//规定String[] onlineUser = message.getContent().split(" ");System.out.println("=======当前在线用户列表======");for (int i = 0; i < onlineUser.length; i++) {System.out.println("用户：" + onlineUser[i]);}} else if (message.getMesType().equals(MessageType.MESSAGE_COMM_MES)) {System.out.println(message.getSender() + "向" + message.getGetter() + "发送了" + message.getContent());} else if (message.getMesType().equals(MessageType.MESSAGE_TO_ALL_MES)) {System.out.println(message.getSender() + "对大家说：" + message.getContent());} else if(message.getMesType().equals(MessageType.MESSAGE_FILE_MES)) {System.out.println(message.getSender()+"给"+message.getGetter()+"发文件："+message.getSrc()+"到"+message.getDest());//通过字节输出流，把程序中的字节数组输出到磁盘上进行保存FileOutputStream fileOutputStream = new FileOutputStream(message.getDest());fileOutputStream.write(message.getFilebytes());fileOutputStream.close();System.out.println("\n"+"文件保持成功");}else {System.out.println("是其他类型的message，暂时不处理");}} catch (IOException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();}}public Socket getSocket() {return socket;}
}

（3）ManageClientConnectServerThread类

package qq.客户端.qqclient.service;import qq.客户端.qqclient.service.ClientConnectServerThread;import java.util.HashMap;/*** 管理客户端连接到服务器端的线程的类*/
public class ManageClientConnectServerThread {//把多个线程放到HashMap这个集合，key为userId value为ClientConnectServerThreadstatic HashMap<String, ClientConnectServerThread> hashMap=new HashMap<>();//把线程加到这个集合当中public static void addClientConnectServerThread(String userId,ClientConnectServerThread clientConnectServerThread) {hashMap.put(userId,clientConnectServerThread);}//通过userId找到对应的线程public static ClientConnectServerThread getClientConnectServerThread(String userId) {return hashMap.get(userId);}
}

（4）MessageClientService类

package qq.客户端.qqclient.service;import qq.客户端.qqserve.Message;
import qq.客户端.qqserve.MessageType;import java.io.ObjectOutputStream;
import java.util.Date;public class MessageClientService {public static void Message_TO_ALL(String content,String senderid) {//new出一个Message对象Message message=new Message();message.setMesType(MessageType.MESSAGE_TO_ALL_MES);//表示的意思是群发消息的聊天方式message.setSender(senderid);//message.setGetter(getterid);message.setContent(content);message.setSendTime(new Date().toString());//发送时间设置到发送的message对象中System.out.println(senderid+"对大家说"+content);try {ObjectOutputStream oos = new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderid).getSocket().getOutputStream());oos.writeObject(message);} catch (Exception e) {e.printStackTrace();}}public static void Sendprivately(String content,String senderid,String getterid) {//new出一个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());//发送时间设置到发送的message对象中System.out.println(senderid+"给"+getterid+"发送了"+content);try {ObjectOutputStream oos = new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderid).getSocket().getOutputStream());oos.writeObject(message);} catch (Exception e) {e.printStackTrace();}}
}

（5）FileClientService类

package qq.客户端.qqclient.service;import qq.客户端.qqserve.Message;
import qq.客户端.qqserve.MessageType;
import qq.服务端.QQServer.ManageServerConnectClientThread;import java.io.*;/*** 该类完成文件传输的服务*/
public class FileClientService {/**** @param dest 把这个文件传输到哪个目录* @param src 源文件* @param sender 文件的传输者* @param getter 文件的接收者*/public static void sendFileToOne(String dest,String src,String sender,String getter) throws IOException {Message message = new Message();message.setMesType(MessageType.MESSAGE_FILE_MES);message.setSender(sender);message.setGetter(getter);message.setSrc(src);message.setDest(dest);//需要将文件读取FileInputStream fileInputStream=null;byte[] filebytes=new byte[(int) new File(src).length()];try {fileInputStream=new FileInputStream(src);fileInputStream.read();//把src处的文件读取到字节数组filebytes中去//文件对应的字节数组设置到message对象message.setFilebytes(filebytes);} catch (Exception e) {e.printStackTrace();} finally {try {if (fileInputStream!=null) {fileInputStream.close();}} catch (IOException e) {e.printStackTrace();}}//提示信息System.out.println("\n"+sender+"给"+getter+"发送文件："+src+"到对方电脑的目录"+dest);ObjectOutputStream objectOutputStream =new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(sender).getSocket().getOutputStream());objectOutputStream.writeObject(message);}
}

 2.View包

View类

package qq.客户端.qqclient.View;import qq.客户端.qqclient.service.FileClientService;
import qq.客户端.qqclient.service.MessageClientService;
import qq.客户端.qqclient.service.UserClientSevice;import java.io.IOException;
import java.util.Scanner;/*** 客户端的菜单页面*/
@SuppressWarnings({"all"})
public class View {private boolean loop=true;private String key="";private static Scanner scanner=new Scanner(System.in);private UserClientSevice userClientSevice=new UserClientSevice();public static void main(String[] args) throws Exception {new View().menu();}public void menu() throws ClassNotFoundException, IOException {while (loop) {System.out.println("欢迎登录网络通信系统");System.out.println("\t\t     1登录系统");System.out.println("\t\t     9退出系统");System.out.print("请输你的选择:");key=scanner.next();switch (key) {case "1":System.out.println("登录系统");System.out.print("请输入用户名:");String userId=scanner.next();System.out.print("请输入密码:");String passwd=scanner.next();//这里有很多代码，我们需要去服务端去验证该用户是否合法//我们把这些代码写到UserClientSevice这个类中while (loop) {if(userClientSevice.checkUser(userId,passwd)) {System.out.println("=======欢迎用户"+userId+"=======");System.out.println("欢迎登录网络通信系统二级菜单");System.out.println("\t\t\t1 显示在线用户列表");System.out.println("\t\t\t2 群发消息");System.out.println("\t\t\t3 私聊消息");System.out.println("\t\t\t4 发送文件");System.out.println("\t\t\t9 退出系统");System.out.print("请输你的选择:");key=scanner.next();switch (key) {case "1":System.out.println("\t\t\t1 显示在线用户列表");UserClientSevice.onLineFriendList();break;case "2":System.out.println("请输入想对大家说的话：");String contents=scanner.next();MessageClientService.Message_TO_ALL(contents,userId);break;case "3":System.out.println("\t\t\t3 私聊消息");System.out.println("请输入您要和谁私聊,即是接收用户的id");String userId2= scanner.next();System.out.println("请输入要发送的内容");String content=scanner.next();MessageClientService.Sendprivately(content,userId,userId2);break;case "4":System.out.println("\t\t\t4 发送文件");System.out.println("请输入您想要给谁发送文件");String usergetter=scanner.next();System.out.println("请输入您要发送的文件路径");String srcname=scanner.next();System.out.println("请输入你要发送到哪个文件路径");String destname=scanner.next();FileClientService.sendFileToOne(destname,srcname,userId,usergetter);break;case "9":loop=false;UserClientSevice.LoginExit();break;default:System.out.println("您输入有误呢");break;}} else {System.out.println("您的用户名或密码输入有误");break;}}break;case "9":loop=false;break;}}}
}

 3.辅助功能的包

 (1) Message类

package qq.客户端.qqserve;import java.io.Serializable;public class Message implements Serializable {private static final 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;}
}

 (2)User类

package qq.客户端.qqserve;import java.io.Serializable;public class User implements Serializable {private static final long serialVersionUID=1L;private String userId;//用户名/用户Idprivate 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;}
}

 （3）接口MessageType

package qq.客户端.qqserve;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.核心包

（1） QQServer类

package qq.服务端.QQServer;import qq.客户端.qqclient.service.ManageClientConnectServerThread;
import qq.客户端.qqserve.Message;
import qq.客户端.qqserve.MessageType;
import qq.客户端.qqserve.User;import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;/*** 这是服务端，在监听9999端口，等待客户端的连接，并且保持通信*/
public class QQServer {private ServerSocket ss=null;/*** 由于我们不止一个用户可以进行登录，所以我们要搞一个集合多存放点原始数据用户* ConcurrentHashMap:是线程安全的，即线程同步处理，可以处理并发的情况* HashMap:是线程不安全的，无线程同步处理*/static ConcurrentHashMap<String,User> hashMap=new ConcurrentHashMap<>();public static void main(String[] args) throws Exception {new QQServer();}//使用静态代码块进行初始化操作static {hashMap.put("里奥梅西",new User("里奥梅西","123456"));hashMap.put("C罗",new User("C罗","123456"));hashMap.put("莱万多夫斯基",new User("莱万多夫斯基","123456"));hashMap.put("666666",new User("666666","123456"));}//独立建一个方法来判断是否可以进行成功登录public boolean isLogin(String userId,String password) {User user=hashMap.get(userId);if(user==null) {//不存在该用户return false;}if(!user.getPasswd().equals(password)) {//用户存在，但是密码输入错误return false;}return true;}public QQServer() throws Exception{ss=new ServerSocket(9999);System.out.println("服务端等待连接");//启动推送新闻的线程new Thread(new SendNewsToAllService()).start();while (true) {//当和某一个客户端连接后，会继续监听，因此为whileSocket socket=ss.accept();//如果监听不到，那么就会阻塞//把客户端写出给服务端的User对象读取出来ObjectInputStream ois=new ObjectInputStream(socket.getInputStream());User user=(User) ois.readObject();ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream());//创建message对象，准备返回给客户端Message message = new Message();if(isLogin(user.getUserId(), user.getPasswd())) {System.out.println("用户名为"+user.getUserId()+"\t\t\t"+"密码为"+user.getPasswd()+"的用户验证成功哦，正在通信");//当发送消息message对象成功的时候message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);//将message对象返回给客户端oos.writeObject(message);//创建一个线程，与客户端保持通信，该客户端需要有一个线程,并且这个线程要有socket对象对流进行掌控ServerConnectClientThread scct= new ServerConnectClientThread(socket, user.getUserId());scct.start();//并且我们要创建一个集合来存放这些线程ManageServerConnectClientThread.addServerConnectClientThread(user.getUserId(),scct);} else  {System.out.println("id为"+user.getUserId()+"密码为"+user.getPasswd()+"的用户验证失败");//当发送消息message对象失败的时候message.setMesType(MessageType.MESSAGE_LOGIN_FAIL);oos.writeObject(message);//并且关闭流socket.close();}}}
}

（2）ManageServerConnectClientThread类

package qq.服务端.QQServer;import qq.客户端.qqserve.Message;
import qq.客户端.qqserve.MessageType;
import qq.服务端.qqserve.User;import java.util.HashMap;
import java.util.Iterator;/*** 管理服务端连接客户端的线程的类的集合*/
public class ManageServerConnectClientThread {static HashMap<String,ServerConnectClientThread> hashMap=new HashMap<>();public static void addServerConnectClientThread(String userId,ServerConnectClientThread serverConnectClientThread) {hashMap.put(userId,serverConnectClientThread);}public static void removeServerConnectClientThread(String userId) {hashMap.remove(userId);}//通过对应的userId得到对应的线程public static ServerConnectClientThread getServerConnectClientThread(String userId) {return hashMap.get(userId);}//得到在线用户列表public static String getOnLineUser() {Iterator<String> iterator=hashMap.keySet().iterator();String onlineuser="";while (iterator.hasNext()) {onlineuser+=iterator.next().toString()+" ";}return onlineuser;}
}

（3）ServerConnectClientThread类

package qq.服务端.QQServer;import qq.客户端.qqserve.Message;
import qq.客户端.qqserve.MessageType;
import 数据结构与算法.图.排序算法.选择排序SelectionSort;import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;/*** 该类的一个对象和客户端保持联系*/
public class ServerConnectClientThread extends Thread{private Socket socket;private String userId;//我们要做到一个userId对应一个socket对象public ServerConnectClientThread(Socket socket,String userId) {this.socket=socket;this.userId=userId;}public Socket getSocket() {return socket;}@Overridepublic void run() {super.run();while (true) {try {//创建线程为了让客户端和服务端保持更优秀的通信ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());//如果不可以发送message给客户端，那么就阻塞在这里//后面我们的各种消息都是通过message对象来传递的Message message = (Message) ois.readObject();if (message.getMesType().equals(MessageType.MESSAGE_GET_ONLINE_FRIEND)) {//为了返回网上聊天列表//服务端接收到客户端发送的信息MESSAGE_GET_ONLINE_FRIEND，// 说明客户端要在线用户的列表System.out.println(message.getSender() + "正在要在线用户列表");String user = ManageServerConnectClientThread.getOnLineUser();//再创建一个信息对象，并且重置message2这个对象的属性Message message2 = new Message();message2.setMesType(MessageType.MESSAGE_RET_ONLINE_FRIEND);//信息的类型message2.setContent(user);//信息的内容message2.setGetter(message.getSender());//得到的人ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());oos.writeObject(message2);} else if (message.getContent().equals(MessageType.MESSAGE_COMM_MES)) {//普通聊天ObjectOutputStream oos = new ObjectOutputStream(ManageServerConnectClientThread.getServerConnectClientThread(message.getGetter()).socket.getOutputStream());oos.writeObject(message);//如果是普通私聊聊天，那么我们就要把这个从服务端接收过来的信息，再一次传递给客户端的另外一个socket} else if (message.getContent().equals(MessageType.MESSAGE_CLIENT_EXIT)) {//一个客户端退出，那么对应服务端上的一个socket也要退出，并且线程也要进行删除System.out.println(message.getSender() + "退出了");ManageServerConnectClientThread.removeServerConnectClientThread(message.getSender());socket.close();break;} else if (message.getMesType().equals(MessageType.MESSAGE_TO_ALL_MES)) {HashMap<String, ServerConnectClientThread> hashMap = ManageServerConnectClientThread.getHashMap();Iterator<String> iterator = hashMap.keySet().iterator();while (iterator.hasNext()) {String userID = iterator.next();if (!userID.equals(userId)) {//除了他自己本身之外，转发给其他的所有人ObjectOutputStream objectOutputStream = new ObjectOutputStream(ManageServerConnectClientThread.getServerConnectClientThread(userID).socket.getOutputStream());objectOutputStream.writeObject(message);}}} else if(message.getMesType().equals(MessageType.MESSAGE_FILE_MES)) {ObjectOutputStream objectOutputStream = new ObjectOutputStream(ManageServerConnectClientThread.getServerConnectClientThread(message.getGetter()).socket.getOutputStream());objectOutputStream.writeObject(message);//进行转发给另外一个客户端} else {System.out.println("其他message类型，暂时不处理");}} catch (Exception e) {e.printStackTrace();}}}
}

2.辅助包

（4）MessageType类

package qq.服务端.qqserve;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_FILE_MES="8";//文件消息
}

（5）Message类

package qq.服务端.qqserve;import java.io.Serializable;public class Message implements Serializable {private static final long serialVersionUID=1L;private String sender;//发送者private String getter;//接收者private String content;//消息内容private String sendTime;//发送时间private String mesType;//消息类型/***进行扩展和文件相关的成员*/private byte[] filebytes;private int byteLen;private String dest;//表示把文件传输到哪个目的地private String src;//表示这个文件的源头是哪public byte[] getFilebytes() {return filebytes;}public void setFilebytes(byte[] filebytes) {this.filebytes = filebytes;}public int getByteLen() {return byteLen;}public void setByteLen(int byteLen) {this.byteLen = byteLen;}public String getDest() {return dest;}public void setDest(String dest) {this.dest = dest;}public String getSrc() {return src;}public void setSrc(String src) {this.src = src;}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;}
}

（6）User类

package qq.服务端.qqserve;import java.io.Serializable;public class User implements Serializable {private static final long serialVersionUID=1L;private String userId;//用户名/用户Idprivate 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;}
}

Java小白，理解的可能不太深，可能会叙述的会有偏差，仅供参考。