多用户通信系统
做了两个版本,这里分享命令行的版本
需求分析
- 用户登录
- 拉取在线用户列表
- 无异常退出(服务器、客户端)
- 私聊
- 群聊
- 发文件
- 服务器新闻推送
用户登录
功能说明
因为还没有学习数据库,我们人为规定用户名id = 100,密码123456 就可以登录,其它用户不能登录后面使用HashMap模拟数据库,可以多个用户登录
结构图
客户端代码实现
1.信息共享类
//Message类
/**
* 表示客户端和服务器端通讯时的消息对象
*/
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 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;
}
}
//User类
/**
* 表示一个用户信息
*/
public class User implements Serializable {
private static final long serialVersionUID = 1L;//增强兼容性
private String userId;//用户ID
private String passwd;//用户密码
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;
}
}
//MessageType接口类
/**
* 表示消息类型
*/
public interface MessageType {
//接口种定义了不同常量,不同常量代表不同的消息类型。
String MESSAGE_LOGIN_SUCCEED = "1";//表示登陆成功
String MESSAGE_LOGIN_FAIL = "2";//表示登陆成功
}
2.客户端View界面
//QQView类
/**
*用户界面,一级二级菜单
*/
public class QQView {
private boolean loop = true;//控制是否显示菜单
private String key = ""; //接受用户的键盘输入
public static void main(String[] args) {
new QQView().mainMenu();
System.out.println("客户端退出系统");
}
//显示主菜单
private 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(50);
System.out.print("请输入密 码:");
String pwd = Utility.readString(50);
//需要到服务端验证该用户是否合法(即是否存在该用户)
if(false){//假设合法
System.out.println("=========欢迎用户 "+userId+" 登录成功=========");
//进入二级菜单
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;
// System.out.println("退出系统");
break;
}
}
}else {//登录服务器失败
System.out.println("========登陆失败========");
}
break;
case "9":
loop = false;
// System.out.println("退出系统");
break;
}
}
}
}
3.处理验证登录、用户退出服务(类)
编写一个 UserClientService 类,首先用户端在登陆时候会给服务端发送一个User对象,服务器端收到后会进行验证,然后返回给用户端要给Message对象来告知用户端是否合法。
//UserClientService类
/**
* 该类完成用户登录验证和用户注册功能等
*/
public class UserClientService {
//创建User属性,因为可能在其他地方使用User信息
// 在User类中创建一个无参构造器
private User u = new User();
//因为Socket在其他地方也可能使用到,因此做成属性
private Socket socket;
//根据userId 和 pwd 到服务器端验证用户是否合法
public boolean checkUser(String userId ,String pwd) throws Exception{
boolean b = false;
//创建User对象
u.setUserId(userId);
u.setPasswd(pwd);
//连接到服务端,发送u对象
socket = new Socket(InetAddress.getByName("127.0.0.1"),9999);
//得到ObjectOutputStream对象
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(u);//发送User对象
//读取服务器返回的Message对象
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message ms = (Message)ois.readObject();
if (ms.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)){//登陆成功
//创建一个和服务器端保持通信的线程 -> 创建一个类, ClientConnectServerThread
ClientConnectServerThread clientConnectServerThread = new ClientConnectServerThread(socket);
//启动线程
clientConnectServerThread.start();
//客户端可能会有多个Socket线程,为了方便管理和扩展,可以放在集合中。
ManageClientConnectServerThread.addClientConnectServerThread(userId,clientConnectServerThread);
b = true;
}else {
//登陆失败,不能启动和服务器通信的线程,关闭Socket
socket.close();
}
return b;
}
}
并且在QQView类中对判断用户是否登录成功的判断条件设置为
userClientService.checkUser(userId,pwd)
4.通信服务(后台线程)类
创建一个和服务器端保持通信的线程 -> 创建一个类, ClientConnectServerThread
//ClientConnectServerThread类
public class ClientConnectServerThread extends Thread {
private Socket 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 ms = (Message)ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
}
}
//为了更方便的得到Socket
public Socket getSocket() {
return socket;
}
}
5.管理线程类
当应用允许登录多个用户来接受信息的时候,需要拥有一个对多个用户通信线程的管理服务(类)
//ManageClientConnectServerThread类
public class ManageClientConnectServerThread {
//把多个线程放入到要给HashMap集合,key 是用户的id,value就是线程
private static HashMap<String, ClientConnectServerThread> hm = new HashMap<>();
//将某个线程加入到集合
public static void addClientConnectServerThread(String userId, ClientConnectServerThread clientConnectServerThread){
hm.put(userId,clientConnectServerThread);
}
//通过userId得到相应的线程
public static ClientConnectServerThread getClientConnectServerThread(String userId){
return hm.get(userId);
}
}
服务端代码实现
####1.SocketServer监听端口服务
对QQServer项目进行编写,首先建立一个QQserver类,在9999端口循环监听【while循环】,如果有一个客户端连接到服务器端就继续往下执行【没有则堵塞等待】,得到可u护短其发送的User对象流,并判断是否是正确的,如果是正确的,返回Message对象流,然后建立一个线程时刻监听来自客户端的信息;如果不是正确的,则也返回一个Message对象流,并关闭socket对象,执行完后,又从头开始继续监听。当while循环退出了,即不再监听来自客户端的连接,则把serversocket对象关掉即可。
//QQServer类
/**
* 服务端,在监听9999,等待客户端的连接,保持通信
*/
public class QQServer {
private ServerSocket ss = 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("300",new User("300","123456"));
validUsers.put("至尊宝",new User("至尊宝","123456"));
validUsers.put("紫霞仙子",new User("紫霞仙子","123456"));
validUsers.put("菩提老祖",new User("菩提老祖","123456"));
}
//验证用户是否有效的方法
private boolean checkUser(String userId,String pwd){
// for (int i = 0; i < validUsers.size(); i++) {
// User user = validUsers.get(i);
// if (userId.equals(user.getUserId()) && pwd.equals(user.getPasswd())){
// return true;
// }
// }
// return false;
User user = validUsers.get(userId);
if (user == null){//不存在直接返回false
return false;
}
if (!(pwd.equals(user.getPasswd()))){//id正确,但是密码错误
return false;
}
return true;
}
public QQServer(){
//注意端口可以放在一个配置文件中,可以改变
try {
System.out.println("服务端在9999端口监听");
ss = new ServerSocket(9999);
while (true) {//当和某个客户端连接后,会继续监听,因此while
Socket socket = ss.accept();//如果没有客户端连接就会堵塞在这
//得到socket关联的对象输入流
ObjectInputStream ois =
new ObjectInputStream(socket.getInputStream());
//得到socket关联的对象输出流
ObjectOutputStream oos =
new ObjectOutputStream(socket.getOutputStream());
User user = (User)ois.readObject();//读取客户端发送的User对象
//创建一个Message对象,准备回复客户端
Message message = new Message();
if(checkUser(user.getUserId(),user.getPasswd())){//登陆成功
message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);
oos.writeObject(message);
//创建一个线程,和客户端保持通信,该线程要有Socket对象
ServerConnectClientThread serverConnectClientThread =
new ServerConnectClientThread(socket, user.getUserId());
//启动该线程
serverConnectClientThread.start();
//把该线程对象放到一个集合中进行管理
ManageServerConnectClientThread.addServerConnectClientThread(user.getUserId(),serverConnectClientThread);
}else {//登录失败
System.out.println("用户Id:" + user.getUserId() + "pwd: "+ user.getPasswd() +"验证失败");
message.setMesType(MessageType.MESSAGE_LOGIN_FAIL);
oos.writeObject(message);
//登录失败,关闭socket
socket.close();
}
}
} catch (Exception e) {
e.printStackTrace();
}finally {
//如果服务端退出了while,说明服务器端不再监听了,因此需要关闭资源ServerSocket
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.保持服务器与客户端进行通信的服务
//ServerConnectClientThread类
/**
* 该类的一个对象和某个客户端保持通信
*/
public class ServerConnectClientThread extends Thread{
private Socket socket;//该线程需要持有Socket保持通信
private String userId;//连接到服务器端的用户Id
public ServerConnectClientThread(Socket socket, String userId) {
this.socket = socket;
this.userId = userId;
}
@Override
public void run() {//这里线程处于run状态,可以发送或接收到客户端消息
while (true){
try {
System.out.println("服务器端和客户端"+ userId +"保持通信,读取数据");
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message ms = (Message)ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
3.对所有通信线程进行管理的服务
//ManageServerConnectClientThread类
/**
* 该类用于管理和客户端通信的线程
*/
public class ManageServerConnectClientThread {
//把多个线程放入到要给HashMap集合,key 是用户的id,value就是线程
private static HashMap<String,ServerConnectClientThread> hm = new HashMap<>();
//将某个线程加入到集合
public static void addServerConnectClientThread(String userId, ServerConnectClientThread serverConnectClientThread){
hm.put(userId,serverConnectClientThread);
}
//通过userId得到相应的线程
public static ServerConnectClientThread getServerConnectClientThread(String userId){
return hm.get(userId);
}
}
拉取用户列表
功能说明
从服务器获得在线的线程,得知在线的用户。
客户端代码实现
1.Message拓展
增加messageType类型,在UserClientService类中加入向服务器端请求在线用户列表的onlineFriendList方法,在 ClientConnectServerThread 类中的run()方法中加入判断message类型,然后做相应的业务处理
//MessageType类
/**
* 表示消息类型
*/
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"; //客户端请求退出
}
2.代码修改
//UserClientService类
/**
* 该类完成用户登录验证和用户注册功能等
*/
public class UserClientService {
//创建User属性,因为可能在其他地方使用User信息
// 在User类中创建一个无参构造器
private User u = new User();
//因为Socket在其他地方也可能使用到,因此做成属性
private Socket socket;
//根据userId 和 pwd 到服务器端验证用户是否合法
public boolean checkUser(String userId ,String pwd) throws Exception{
boolean b = false;
//创建User对象
u.setUserId(userId);
u.setPasswd(pwd);
//连接到服务端,发送u对象
socket = new Socket(InetAddress.getByName("127.0.0.1"),9999);
//得到ObjectOutputStream对象
ObjectOutputStream oos =
new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(u);//发送User对象
//读取服务器返回的Message对象
ObjectInputStream ois =
new ObjectInputStream(socket.getInputStream());
Message ms = (Message)ois.readObject();
if (ms.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)){//登陆成功
//创建一个和服务器端保持通信的线程 -> 创建一个类, ClientConnectServerThread
ClientConnectServerThread clientConnectServerThread = new ClientConnectServerThread(socket);
//启动线程
clientConnectServerThread.start();
//客户端可能会有多个Socket线程,为了方便管理和扩展,可以放在集合中。
ManageClientConnectServerThread.addClientConnectServerThread(userId,clientConnectServerThread);
b = true;
}else {
//登陆失败,不能启动和服务器通信的线程,关闭Socket
socket.close();
}
return b;
}
//向服务器端请求在线用户列表
public void onlineFriendList(){
//发送一个message,类型MESSAGE_GET_ONLINE_FRIEND
Message message = new Message();
message.setSender(u.getUserId());
message.setMesType(MessageType.MESSAGE_GET_ONLINE_FRIEND);
//发送给服务器
try {
//从管理线程的集合中,通过userId,得到这个线程
ClientConnectServerThread clientConnectServerThread =
ManageClientConnectServerThread.getClientConnectServerThread(u.getUserId());
//得到这个线程关联的socket
Socket socket = clientConnectServerThread.getSocket();
//得到当先socket对应的ObjectOutPutStream对象
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
//向服务器端发送message对象,要求服务器要求在线用户列表
oos.writeObject(message);
} catch (IOException e) {
e.printStackTrace();
}
}
}
//ClientConnectServerThread类
public class ClientConnectServerThread extends Thread {
private Socket socket;//
//构造器可以接受一个Socket对象
public ClientConnectServerThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//因为在Thread需要在后台和服务器一直保持通信,因此我们while循环
while (true){
System.out.println();
System.out.println("客户端线程,在等待读取从服务器端返回的消息");
try {
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
//如果服务器没有发送的Message对象,线程会堵塞在这里。
Message ms = (Message)ois.readObject();
//判断这个message类型,然后做相应的业务处理
//如果读取到的是服务端返回的在线用户列表
if (ms.getMesType().equals(MessageType.MESSAGE_RET_ONLINE_FRIEND)){
//取出在线列表信息,并显示
//规定
String[] onlineUsers = ms.getContent().split(" ");
System.out.println();
System.out.println("========在线用户列表========");
for (int i = 0; i < onlineUsers.length; i++) {
System.out.println("用户:" + onlineUsers[i]);
}
}else {
System.out.println("是其他类型的message,暂时不处理..");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
//为了更方便的得到Socket
public Socket getSocket() {
return socket;
}
}
//ClientConnectServerThread类
public class ClientConnectServerThread extends Thread {
private Socket socket;//
//构造器可以接受一个Socket对象
public ClientConnectServerThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//因为在Thread需要在后台和服务器一直保持通信,因此我们while循环
while (true){
System.out.println();
System.out.println("客户端线程,在等待读取从服务器端返回的消息");
try {
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
//如果服务器没有发送的Message对象,线程会堵塞在这里。
Message ms = (Message)ois.readObject();
//判断这个message类型,然后做相应的业务处理
//如果读取到的是服务端返回的在线用户列表
if (ms.getMesType().equals(MessageType.MESSAGE_RET_ONLINE_FRIEND)){
//取出在线列表信息,并显示
//规定
String[] onlineUsers = ms.getContent().split(" ");
System.out.println();
System.out.println("========在线用户列表========");
for (int i = 0; i < onlineUsers.length; i++) {
System.out.println("用户:" + onlineUsers[i]);
}
}else {
System.out.println("是其他类型的message,暂时不处理..");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
//为了更方便的得到Socket
public Socket getSocket() {
return socket;
}
}
服务端代码实现
1.Message拓展
//MessageType类
/**
* 表示消息类型
*/
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"; //客户端请求退出
}
2.代码修改
//ServerConnectClientThread类
/**
* 该类的一个对象和某个客户端保持通信
*/
public class ServerConnectClientThread extends Thread{
private Socket socket;//该线程需要持有Socket保持通信
private String userId;//连接到服务器端的用户Id
public ServerConnectClientThread(Socket socket, String userId) {
this.socket = socket;
this.userId = userId;
}
@Override
public void run() {//这里线程处于run状态,可以发送或接收到客户端消息
while (true){
try {
System.out.println("服务器端和客户端"+ userId +"保持通信,读取数据");
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message ms = (Message)ois.readObject();
//判断这个message类型,然后做相应的业务处理
if (ms.getMesType().equals(MessageType.MESSAGE_GET_ONLINE_FRIEND)){
//客户端要在线用户列表
//在线用户列表格式 100 200 紫霞仙子
System.out.println(ms.getSender() + " 要在线用户列表");
String onlineUser = ManageServerConnectClientThread.getOnlineUser();
//返回message
Message message2 = new Message();
message2.setMesType(MessageType.MESSAGE_RET_ONLINE_FRIEND);
message2.setContent(onlineUser);
message2.setGetter(ms.getGetter());
//返回给客户端
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(message2);
}else {
System.out.println("其他的处理");
}
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
//ManageServerConnectClientThread类
/**
* 该类用于管理和客户端通信的线程
*/
public class ManageServerConnectClientThread {
//把多个线程放入到要给HashMap集合,key 是用户的id,value就是线程
private static HashMap<String,ServerConnectClientThread> hm = new HashMap<>();
//将某个线程加入到集合
public static void addServerConnectClientThread(String userId, ServerConnectClientThread serverConnectClientThread){
hm.put(userId,serverConnectClientThread);
}
//通过userId得到相应的线程
public static ServerConnectClientThread getServerConnectClientThread(String userId){
return hm.get(userId);
}
//编写方法,可以返回在线用户列表
public static String getOnlineUser() {
//集合遍历,遍历 hashMap的key
Iterator<String> iterator = hm.keySet().iterator();
String onlineUserList = "";
while (iterator.hasNext()){
onlineUserList += iterator.next() + " ";
}
return onlineUserList;
}
}
无异常用户登出系统
功能说明
实现系统正常退出后服务端得知用户下线,将线程销毁。
客户端解决方法
① 调用方法,给服务器端发送一个退出系统的message对象;
② 调用System.exit(0)//正常退出。
服务器端
① 服务器端和某个客户端通信的线程如果接收到了一个退出系统的message后;
② 把持有的socket关闭;
③ 退出线程。
客户端代码实现
在客户端UserClientService类中添加向服务端发送关闭的信息方法,然后在QQView中调用该方法。
//编写方法,退出客户端,并给服务端发送一个退出系统的message对象
public void logout(){
Message message = new Message();
message.setMesType(MessageType.MESSAGE_CLIENT_EXIT);
message.setSender(u.getUserId());//指出是哪个用户id
//发送message
try {
OutputStream outputStream = socket.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(outputStream);
oos.writeObject(message);
System.out.println(u.getUserId() + " 退出系统");
System.exit(0);//结束进程
} catch (IOException e) {
e.printStackTrace();
}
}
//调用方法,给服务器发送一个退出系统的message
userClientService.logout();
服务端代码实现
在 ManageServerConnectClientThread 类中添加将某个线程从集合移除的方法,在ServerConnectClientThread类中,若信息类型为退出,则将对应的线程从线程集合移除,关闭连接,退出线程。
//ManageServerConnectClientThread类
//将某个线程从集合移除
public static void removeServerConnectClientThread(String userId){
hm.remove(userId);
}
//ServerConnectClientThread类
if (ms.getMesType().equals(MessageType.MESSAGE_CLIENT_EXIT)){
System.out.println(ms.getSender() + " 退出系统");
//将对应的线程从线程集合移除
ManageServerConnectClientThread.removeServerConnectClientThread(ms.getSender());
socket.close();//关闭连接
break;//退出线程
}
至此,框架搭建完成,亮代码
完整代码
公用
package com.evesky.qqclient.utils;
/**
工具类的作用:
处理各种情况的用户输入,并且能够按照程序员的需求,得到用户的控制台输入。
*/
import java.util.*;
/**
*/
public class ScannerUtility {
//静态属性。。。
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;
}
/**
* @return
*/
public static double readDouble(){
double n;
for (;;){
String str = readKeyBoard(10,false);
try{
n = Double.parseDouble(str);
break;
}catch (NumberFormatException e){
System.out.print("数字输入错误,请重新输入:");
}
}
return n;
}
/**
* @param defaultValue
* @return
*/
public static double readDouble(double defaultValue){
double n;
for (;;){
String str = readKeyBoard(10,true);
if("".equals(str)){
return defaultValue;
}
try{
n = Double.parseDouble(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.print("请输入你的选择 (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 line 返回字符串
*/
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 {//如果blankReturn=false,不接受空串,必须输入内容
System.out.print("不允许输入为空,请重新输入:");
continue;
}
}
//如果用户输入的内容大于了 limit,就提示重写输入
//如果用户如的内容 >0 <= limit ,我就接受
if (line.length() < 1 || line.length() > limit) {
System.out.print("输入长度(不能大于" + limit + ")错误,请重新输入:");
continue;
}
break;
}
return line;
}
}
package com.evesky.qqcommon;
import java.io.Serializable;
/*
* @author 远空_
* @version 1.0
* */
public class FileMessage implements Serializable {
private byte[] fileBytes;
private int fileLen = 0;
private String dest;//传输目的地
private String src;//源文件路径
public FileMessage(String dest, String src) {
this.dest = dest;
this.src = 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 getDest() {
return dest;
}
public void setDest(String dest) {
this.dest = dest;
}
public String getSrc() {
return src;
}
public void setSrc(String src) {
this.src = src;
}
}
package com.evesky.qqcommon;
import java.io.File;
import java.io.Serializable;
/*
* @author 远空_
* @version 1.0
* 表示客户端和服务器端通信时候的消息对象
* */
public class Message implements Serializable {
private static final long serialVersionUID = 1L;
private String sender;//发送者
private String receiver;//接收者
private String content;//消息内容
private String sendTime;//发送时间
private String mesType;//消息类型
// 文件相关拓展
private FileMessage fileMessage;
public FileMessage getFileMessage() {
return fileMessage;
}
public void setFileMessage(FileMessage fileMessage) {
this.fileMessage = fileMessage;
}
public void setSender(String sender) {
this.sender = sender;
}
public String getSender() {
return sender;
}
public String getReceiver() {
return receiver;
}
public void setReceiver(String receiver) {
this.receiver = receiver;
}
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;
}
}
package com.evesky.qqcommon;
/*
* @author 远空_
* @version 1.0
* */
public interface MessageType {
/*
* 1.接口定义了一些常量
* 2.不同的常量值表示不同的消息类型
* */
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";//文件消息
}
package com.evesky.qqcommon;
import java.io.Serializable;
/*
* @author 远空_
* @version 1.0
* 表示一个用户信息
* */
public class User implements Serializable {
private static final long serialVersionUID = 1L;
private String userId;//用户ID
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;
}
}
客户端
package com.evesky.qqclient.view;
import com.evesky.qqclient.service.FileClientService;
import com.evesky.qqclient.service.MessageClientService;
import com.evesky.qqclient.service.UserClientService;
import com.evesky.qqclient.utils.ScannerUtility;
import com.evesky.qqcommon.FileMessage;
/*
* @author 远空_
* @version 1.0
* */
public class QQView {
private boolean loop = true;//控制是否显示菜单
private String key;
//对象是用于登录服务/注册用户
private UserClientService userClientService= new UserClientService();
//对象用户私聊/群聊
private MessageClientService messageClientService = new MessageClientService();
private FileClientService fileClientService = new FileClientService();
public static void main(String[] args) {
new QQView().mainMenu();
System.out.println("客户端退出系统");
}
//显示主菜单
private void mainMenu(){
while (loop){
System.out.println("===============欢迎登录网络通信系统===============");
System.out.println("\t\t 1 登录系统");
System.out.println("\t\t 9 退出系统");
System.out.print("请输入你的选择:");
key = ScannerUtility.readString(1);
//根据用户的输入来处理不同的逻辑
switch (key){
case "1":
System.out.print("请输入用户号:");
String userId = ScannerUtility.readString(50);
System.out.print("请输入密 码:");
String pwd = ScannerUtility.readString(50);
//todo 需要服务器去验证用户是否合法
//
if (userClientService.checkUser(userId,pwd)){
System.out.println("===============欢迎 -" + userId + "- ===============");
while (loop){
System.out.println("===============网络通信系统二级菜单(用户:"+userId+")===============");
System.out.println("\t\t 1 显示在线用户列表");
System.out.println("\t\t 2 群发消息");
System.out.println("\t\t 3 私聊消息");
System.out.println("\t\t 4 发送文件");
System.out.println("\t\t 9 退出系统");
System.out.print("请输入你的选择:");
key = ScannerUtility.readString(1);
String receiverId,content;
switch (key){
case "1":
userClientService.onlineFriendList();
break;
case "2":
System.out.print("想对所有人说:");
content = ScannerUtility.readString(300);
messageClientService.sendMessageToAll(content,userId);
break;
case "3":
System.out.print("请输入想聊天的在线用户ID:");
receiverId = ScannerUtility.readString(50);
System.out.print("请输入想说的话:");
content = ScannerUtility.readString(200);
//编写一个方法,将message发送给服务器
messageClientService.sendMessageToUser(content,userId,receiverId);
break;
case "4":
System.out.print("请输入发送文件的在线用户ID:");
receiverId = ScannerUtility.readString(50);
System.out.print("请输入发送的文件路径(e:\\xxx.jpg):");
String src = ScannerUtility.readString(200);
System.out.print("请输入接收的文件路径(e:\\xxx.jpg):");
String dest = ScannerUtility.readString(200);
FileMessage fileMessage = new FileMessage(dest,src);
fileClientService.sendFileToUser(fileMessage,userId,receiverId);
break;
case "9":
//调用方法,给服务器发送”退出客户端“信息
userClientService.logout();
loop = false;
break;
}
}
}else {
System.out.println("登录失败");
}
break;
case "9":
loop = false;
break;
}
}
}
}
package com.evesky.qqclient.service;
import com.evesky.qqcommon.Message;
import com.evesky.qqcommon.MessageType;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;
/*
* @author 远空_
* @version 1.0
* */
public class ClientConnectServerThread extends Thread{
//该线程需要持有Socket
private 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 = (Message) ois.readObject();
//注意,后面我们需要去使用message
//判断这个message类型,然后去做相应的业务处理
//如果读取到的是服务端返回的在线用户列表
switch (message.getMesType()){
case MessageType.MESSAGE_RET_ONLINE_FRIEND:
//取出在线列表信息,并显示
//规定
new Thread(()->{
String[] onlineUsers = message.getContent().split(" ");
System.out.println("==========当前在线用户列表==========");
for (int i = 0 ; i< onlineUsers.length ;i++){
System.out.println("用户:"+onlineUsers[i]);
}
}).start();
break;
case MessageType.MESSAGE_TO_ALL_MES:
//显示群发消息
System.out.println(message.getSendTime());
System.out.println(message.getSender() + " 对 所有人 说:"+ message.getContent());
break;
case MessageType.MESSAGE_COMM_MES:
//把服务器端的消息显示到控制台即可
System.out.println(message.getSendTime());
System.out.println(message.getSender() + " 对 "
+ message.getReceiver()+" 说:"+ message.getContent());
break;
case MessageType.MESSAGE_FILE_MES:
System.out.println(message.getSendTime());
System.out.println(message.getSender() + " 给 " + message.getReceiver() +" 发送文件:"+ message.getFileMessage().getSrc()
+"\n到对方电脑目录:"+ message.getFileMessage().getDest());
//取出message的文件字节数组,转存文件
FileOutputStream fos = new FileOutputStream(message.getFileMessage().getDest());
fos.write(message.getFileMessage().getFileBytes());
fos.close();
break;
}
} catch (IOException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
}
//为了更方便得到Socket
public Socket getSocket() {
return socket;
}
}
package com.evesky.qqclient.service;
import com.evesky.qqcommon.FileMessage;
import com.evesky.qqcommon.Message;
import com.evesky.qqcommon.MessageType;
import java.io.*;
import java.util.Date;
/*
* @author 远空_
* @version 1.0
* */
public class FileClientService {
/**
*
* @param fileMessage 文件包
* @param sendId 发送者
* @param receiverId 接收者
*/
public void sendFileToUser(FileMessage fileMessage,String sendId,String receiverId){
//读取文件 打包进 fileMessage
File file = new File(fileMessage.getSrc());
FileInputStream fileInputStream = null;
byte[] fileBytes = new byte[(int) file.length()];
try {
fileInputStream = new FileInputStream(file);
fileInputStream.read(fileBytes);
//设置 fileMessage 文件数据FileBytes
fileMessage.setFileBytes(fileBytes);
fileMessage.setFileLen(fileBytes.length);
} catch (IOException e) {
throw new RuntimeException(e);
}finally {
if (fileInputStream != null){
try {
fileInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
//将文件打包到message
Message message = new Message();
message.setFileMessage(fileMessage);
message.setSender(sendId);
message.setMesType(MessageType.MESSAGE_FILE_MES);
message.setReceiver(receiverId);
message.setSendTime(new Date().toString());
//发送 Message
System.out.println(message.getSendTime());
System.out.println(sendId + " 给 " + receiverId +" 发送文件:"+ fileMessage.getSrc()+"\n到对方电脑目录:"+ fileMessage.getDest());
try {
ObjectOutputStream oos =
new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(sendId).getSocket().getOutputStream());
oos.writeObject(message);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
package com.evesky.qqclient.service;
import java.util.HashMap;
/*
* @author 远空_
* @version 1.0
* 管理客户端连接到服务器端的线程的类
* */
public class ManageClientConnectServerThread {
//我们把多个线程放入一个HashMap集合,key就是用户id,value就是线程
private static HashMap<String,ClientConnectServerThread> threads = new HashMap<>();
/**
* 将某个线程加入到集合
* @param userId
* @param clientConnectServerThread
*/
public static void addClientConnectServerThread(String userId,
ClientConnectServerThread clientConnectServerThread){
threads.put(userId,clientConnectServerThread);
}
public static ClientConnectServerThread getClientConnectServerThread(String userId){
return threads.get(userId);
}
}
package com.evesky.qqclient.service;
import com.evesky.qqcommon.Message;
import com.evesky.qqcommon.MessageType;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Date;
/*
* @author 远空_
* @version 1.0
* */
public class MessageClientService {
/**
*
* @param content 内容
* @param senderId 发送者ID
* @param receiverId 接收者ID
*/
public void sendMessageToUser(String content,String senderId,String receiverId){
//构建Message
Message message = new Message();
message.setContent(content);
message.setSender(senderId);
message.setReceiver(receiverId);
message.setSendTime(new Date().toString());
message.setMesType(MessageType.MESSAGE_COMM_MES);
System.out.println(senderId + " 对 "+ receiverId + " 说 "+content);
//发送消息给服务吨
try {
ObjectOutputStream oos =
new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderId).getSocket().getOutputStream());
oos.writeObject(message);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
*
* @param content 内容
* @param senderId 发送者
*/
public void sendMessageToAll(String content,String senderId){
//构建Message
Message message = new Message();
message.setContent(content);
message.setSender(senderId);
message.setSendTime(new Date().toString());
message.setMesType(MessageType.MESSAGE_TO_ALL_MES);
System.out.println(senderId + " 对 所有人 说 "+content);
//发送消息给服务吨
try {
ObjectOutputStream oos =
new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderId).getSocket().getOutputStream());
oos.writeObject(message);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
package com.evesky.qqclient.service;
import com.evesky.qqcommon.Message;
import com.evesky.qqcommon.MessageType;
import com.evesky.qqcommon.User;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
/*
* @author 远空_
* @version 1.0
* 该类完成用户登录验证和用户注册等用户基础功能
* */
public class UserClientService {
//因为我们可能在其他使用User信息
private User u = new User();
//因为Socket在其它地方也可能使用,如果使用有另外的用户使用该服务,则socket是共有的,仅用于登录校验
private Socket socket;
/**
* 根据userId和 pwd 到服务器检验该用户是否非法
* @param userId
* @param pwd
* @return
*/
public boolean checkUser(String userId,String pwd) {
boolean flag = false;
//创建User对象
u.setUserId(userId);
u.setPasswd(pwd);
//连接到服务器,发送u对象
try {
socket = new Socket(InetAddress.getLocalHost(), 9999);
//得到ObjectOutputStream对象
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(u);
//读取从服务器回复的Message对象
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message ms = (Message) ois.readObject();
if (ms.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)){
//登录成功
flag = true;
//创建一个和武器端保持通信的进程->创建一个类ClientConnectServerThread
ClientConnectServerThread clientConnectServerThread = new ClientConnectServerThread(socket);
//启动客户端线程
clientConnectServerThread.start();
//为了后续客户端的拓展,将线程放入到集合中处理
ManageClientConnectServerThread.addClientConnectServerThread(userId,clientConnectServerThread);
} else {
//如果登录失败,我们就不会启动和服务器通信的线程,但需要关闭socket
socket.close();
}
} catch (IOException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
return flag;
}
//向服务器请求在线用户列表
public void onlineFriendList(){
//发送一个Message,类型MESSAGE_GET_ONLINE_FRIEND
Message message = new Message();
message.setMesType(MessageType.MESSAGE_GET_ONLINE_FRIEND);
message.setSender(u.getUserId());
//发送给服务器
//应该得到当前线程的Socket 对应的 objectOutputStream对象
try {
//从线程管理的集合种,通过userId,得到对应线程
ClientConnectServerThread clientConnectServerThread =
ManageClientConnectServerThread.getClientConnectServerThread(u.getUserId());
Socket socket = clientConnectServerThread.getSocket();
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
//发送message对象,请求获取用户在线列表
oos.writeObject(message);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
//编写方法,退出客户端,并给客户端发送一个退出系统的message对象
public void logout(){
Message message = new Message();
message.setMesType(MessageType.MESSAGE_CLIENT_EXIT);
message.setSender(u.getUserId());//一定要指定客户端用户id
try {
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(message);
System.out.println(u.getUserId()+" 退出系统 ");
System.exit(0);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
服务端
package com.evesky.qqframe;
import com.evesky.qqserver.service.QQServer;
/*
* @author 远空_
* @version 1.0
* 该类创建QQserver对象,启动后台服务
* */
public class QQFrame {
public static void main(String[] args) {
QQServer qqServer = new QQServer();
}
}
package com.evesky.qqserver.service;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
* @author 远空_
* @version 1.0
* 该类用于管理和客户端通信的线程
* */
public class ManageServerConnectClientThread {
private static HashMap<String,ServerConnectClientThread> threads = new HashMap<>();
//添加线程对象到集合
public static void addServerConnectClientThread(String userId,ServerConnectClientThread serverConnectClientThread){
threads.put(userId,serverConnectClientThread);
}
//根据userId返回对应通信线程
public static ServerConnectClientThread getServerConnectClientThread(String userId){
return threads.get(userId);
}
//编写一个方法,可以返回在线用户列表(线程相关)
public static String getOnlineUser(){
//集合遍历,遍历hashMap的key
Set<String> strings = threads.keySet();
Iterator<String> iterator = strings.iterator();
String onlineUserList = "";
while (iterator.hasNext()){
onlineUserList += iterator.next() + " ";
}
return onlineUserList;
}
public static void removeServerConnectClientThread(String userId){
threads.remove(userId);
}
public static HashMap<String, ServerConnectClientThread> getThreads() {
return threads;
}
}
package com.evesky.qqserver.service;
import com.evesky.qqcommon.Message;
import com.evesky.qqcommon.MessageType;
import com.evesky.qqcommon.SendNewsToALLService;
import com.evesky.qqcommon.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;
import java.util.concurrent.ConcurrentHashMap;
/*
* @author 远空_
* @version 1.0
* 这是服务器,在监听9999,等待客户端的连接,并保持联系
* */
public class QQServer {
private ServerSocket serverSocket = null;
//创建一个集合,存放多个用户,如果是这些用户东路,就认为是合法
//这里我们也可以使用ConcurrentHashMap,可以处理并发的集合,没有线程安全问题
//HashMap没有处理线程安全,因此在多线程情况下是不安全的
private static ConcurrentHashMap<String,User> validUsers = new ConcurrentHashMap<>();
static {//在静态代码块,初始化validUsers
validUsers.put("邓圣君",new User("邓圣君","123456"));
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"));
}
//验证用户是否有效的方法
private boolean checkUser(String userId,String passwd){
User user = validUsers.get(userId);
if (user == null){//说明用户不存在
return false;
}
if (!user.getPasswd().equals(passwd)){//密码错误
return false;
}
return true;
}
public QQServer() {
//端口可以写在配置文件
try {
System.out.println("服务器在9999端口监听");
new Thread(new SendNewsToALLService()).start();
serverSocket = new ServerSocket(9999);
//当和某个客户端连接后,会继续监听,返回socket
while (true){
Socket socket = serverSocket.accept();//如果客户端没有连接,会阻塞在这
//得到socket关联的对象输入流
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
User u = (User) ois.readObject();//读取客户端发送的User对象
//创建一个Message对象和输出流对象,准备回复客户端
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
Message message = new Message();
//验证用户登录
if (checkUser(u.getUserId(),u.getPasswd())){
//登录成功
message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);
//将message对象回复客户端
oos.writeObject(message);
//创建一个线程,和客户端保持通信,该线程需要持有socket对象
ServerConnectClientThread serverConnectClientThread =
new ServerConnectClientThread(socket, u.getUserId());
serverConnectClientThread.start();
//把该线程对象放入到集合中,进行管理
ManageServerConnectClientThread.addServerConnectClientThread(u.getUserId(),serverConnectClientThread);
} else {
//登录失败
System.out.println("用户 id ="+u.getUserId() + " pwd= " + u.getUserId() + " 验证失败");
message.setMesType(MessageType.MESSAGE_LOGIN_FAIL);
//将message对象回复客户端
oos.writeObject(message);
//关闭socket
socket.close();
}
}
} catch (IOException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}finally {
//如果服务器退出了while说明,父亲不再监听,因此关闭ServerSocket
try {
serverSocket.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
package com.evesky.qqserver.service;
import com.evesky.qqcommon.Message;
import com.evesky.qqcommon.MessageType;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.HashMap;
import java.util.Iterator;
/*
* @author 远空_
* @version 1.0
* 该类的一个对象和某个客户端保持通信
* */
public class ServerConnectClientThread extends Thread{
private Socket socket;
private String userId;//连接到服务端的用户id
public Socket getSocket() {
return socket;
}
private boolean loop = true;
public ServerConnectClientThread(Socket socket, String userId) {
this.socket = socket;
this.userId = userId;
}
@Override
public void run() {
while (loop){
try {
System.out.println("服务端和客户端"+userId+"保持通信...读取数据...");
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message message = (Message) ois.readObject();
//后面会使用message,根据message的type,做相应处理
ObjectOutputStream oos = null;
Message sendMessage;
switch (message.getMesType()){
case MessageType.MESSAGE_GET_ONLINE_FRIEND:
//客户端要获取在线用户列表
System.out.println(message.getSender() + "-要获取在线用户列表");
String onlineUsers = ManageServerConnectClientThread.getOnlineUser();
//返回message对象,返回给客户端
sendMessage = new Message();
sendMessage.setMesType(MessageType.MESSAGE_RET_ONLINE_FRIEND);
sendMessage.setContent(onlineUsers);
sendMessage.setReceiver(message.getSender());
//写入到数据通道
oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(sendMessage);
break;
case MessageType.MESSAGE_TO_ALL_MES:
//遍历 所有线程的集合 ,获得所有线程里的所有socket
HashMap<String, ServerConnectClientThread> threads =
ManageServerConnectClientThread.getThreads();
Iterator<String> iterator = threads.keySet().iterator();
//遍历所有在线用户
while (iterator.hasNext()) {
String onlineUserId = iterator.next();
//排除发送者
if (!onlineUserId.equals(message.getSender())){
//进行消息转发
oos = new ObjectOutputStream(threads.get(onlineUserId).getSocket().getOutputStream());
sendMessage = message;
oos.writeObject(sendMessage);
}
}
break;
case MessageType.MESSAGE_FILE_MES:
case MessageType.MESSAGE_COMM_MES:
//跟看message获取receiver,然后得到对应线程
ServerConnectClientThread serverConnectClientThread =
ManageServerConnectClientThread.getServerConnectClientThread(message.getReceiver());
if (serverConnectClientThread == null){
break;
}
//得到对应线程的socket
Socket receiverSocket = serverConnectClientThread.getSocket();
//得到对应socket的输出流
oos = new ObjectOutputStream(receiverSocket.getOutputStream());
//转发消息
sendMessage = message;
oos.writeObject(sendMessage);
break;
case MessageType.MESSAGE_CLIENT_EXIT:
System.out.println(message.getSender() + " 退出了系统");
//将这个客户端对应线程,从集合中删除
ManageServerConnectClientThread.removeServerConnectClientThread(message.getSender());
socket.close();
//结束线程
loop = false;
break;
}
} catch (IOException e) {
throw new RuntimeException(e);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
}
}