1.项目开发流程
需求分析(需求分析报告) -> 设计阶段(设计工作,原型开发,组建团队) -> 实现阶段(完成架构的模块功能) -> 测试阶段(单元测试,测试用例,白/黑盒测试) -> 实施阶段(环境配置部署) -> 维护阶段
2.多用户即时通讯系统
2.1需求分析
1.用户登陆
2.拉取在线用户列表
3.私聊
4.群聊
5.发文件
6.文件服务器推送新闻
2.2通讯系统整体分析
2.3 QQ用户登陆模块
1.首先创建两个项目,一个客户端,一个服务端(由于没有使用到数据库所以通过特定的用户名以及密码登陆)。
客户端和服务器端都要创建两个一样的package(需要同名),用来存放用户信息类(User),消息类(Message),以及消息类型接口(MeesageType)。
//User类
import java.io.Serializable;
//需要登录,所以用来表示一个用户信息
//因为User对象需要在网络上进行传输,所以需要进行序列化
public class User implements Serializable {
private static final long serialVersionUID=1L;
private String userId;//用户Id
private String pwd;//用户密码
public User(String userId, String pwd) {
this.userId = userId;
this.pwd = pwd;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
//Message类
import java.io.Serializable;
//表示传送的消息对象
//之后该对象需要在网络上进行传输,所以需要进行序列化
public class Message implements Serializable {
private final static long serialVersionUID=1L;
private String sender;//表示发送者
private String getter;//表示接收者
private String content;//表示消息的内容
private String sendTime;//表示信息发送的时间
private String mesType;//表示消息的类型,可以在接口中定义消息的类型
public String getSender() {
return sender;
}
public void setSender(String sender) {
this.sender = sender;
}
public String getGetter() {
return getter;
}
public void setGetter(String getter) {
this.getter = getter;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getSendTime() {
return sendTime;
}
public void setSendTime(String sendTime) {
this.sendTime = sendTime;
}
public String getMesType() {
return mesType;
}
public void setMesType(String mesType) {
this.mesType = mesType;
}
}
//消息类型接口
public interface MessageType {
//在接口中定义常量,不同的值表示不同的接口类型
String MESSAGE_LOGIN_SUCCEED="1";//表示登陆成功
String MESSAGE_LOGIN_FAIL="2";//表示登陆失败
}
2.登录页面的完成
2.1基本登陆界面的功能
import com.qq.qqclient.utils.Utility;
public class QQView {
private boolean loop=true;//用于控制用户退出与登陆
private String key="";//用于接收用户输入
public static void main(String args[]) {
new QQView().mainMenu();
}
//显示主菜单
public void mainMenu(){
while(loop) {
System.out.println("===============欢迎进入即时通信系统===============");
System.out.println("\t\t1.登陆系统");
System.out.println("\t\t9.退出系统");
System.out.print("请输入你的选择:");
key= Utility.readString(1);
switch (key) {
case "1":
System.out.print("请输入你的用户名:");
String userId=Utility.readString(20);
System.out.print("请输入你的密 码:");
String pwd= Utility.readString(20);
//此处省略若干....
if(true) {
//进入二级菜单
while(loop) {
System.out.println("===============欢迎用户"+userId+"进入系统===============");
System.out.println("\t\t1.显示在线用户列表");
System.out.println("\t\t2.群发消息");
System.out.println("\t\t3.私聊消息");
System.out.println("\t\t4.发送文件");
System.out.println("\t\t9.退出系统");
System.out.print("请输入你的选择:");
key=Utility.readString(1);
switch(key) {
case "1":
System.out.println("显示在线用户列表");
break;
case "2":
System.out.println("群发消息");
break;
case "3":
System.out.println("私聊消息");
break;
case "4":
System.out.println("发送文件");
break;
case "9":
loop=false;
break;
}
}
} else {
System.out.println("登陆失败...");
}
break;
case "9":
loop=false;
System.out.println("退出系统...");
break;
}
}
}
}
2.2客户端登陆用户的验证
客户端发送一个User对象给服务器,服务器端给该线程返回一个Message对象
import com.qq.common.Message;
import com.qq.common.MessageType;
import com.qq.common.User;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
//用来完成登陆用户的验证,用户注册等功能
public class UserClientService {
//将user做成属性的原因:在其他地方也需要使用到user的信息
private User user=new User();
//socket之后也会被使用到,所以也做成属性
private Socket socket;
//根据UserId和pwd到服务器验证用户是否合法
public boolean checkUser(String userId,String pwd) {
boolean b=false;
//创建User对象
user.setUserId(userId);
user.setPwd(pwd);
try {
//连接到服务器,发送user对象
Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);
//向服务器端发送User对象
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(user);
//读取服务器发回的Message对象
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message message=(Message)ois.readObject();
//判断登陆是否成功
if(message.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) {
b=true;//登陆成功
//创建一个和服务器端保持通信的线程 -> 创建一个类ClientConnectServerThread
ClientConnectServerThread clientConnectServerThread = new ClientConnectServerThread(socket);
//启动客户端线程
clientConnectServerThread.start();
//因为有多个线程,需要将线程放入集合中进行管理
ManageClientConnectServerThread.addClientConnectServerThread(userId,clientConnectServerThread);
}else {
//登陆失败,我们就不能启动线程和服务器通信的线程,关闭socket
socket.close();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return b;
}
}
登陆成功,需要创建一个和服务器进行通信的线程,用来控制socket,即创建一个ClientConnectServerThread类
import com.qq.common.Message;
import java.io.ObjectInputStream;
import java.net.Socket;
public class ClientConnectServerThread extends Thread {
//该线程必须持有socket
private Socket socket;
//构造器可以接收一个Socket对象
public ClientConnectServerThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
//因为Thread需要在后台和服务器进行通信,用while循环一直等待
while(true) {
System.out.println("客户端线程,等待读取从服务器端发送的消息");
try {
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message message=(Message)ois.readObject();//当服务器没有发送message对象,线程就会阻塞在此处
//在做相应的处理
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
//为了方便得到socket对象
public Socket getSocket() {
return socket;
}
}
当有多个线程要进行通信时,需要对线程进行管理,创建一个管理线程的集合类ManageClientConnectServerThread
import java.util.HashMap;
//管理客户端连接到服务器端线程的类
public class ManageClientConnectServerThread {
//我们将多个线程放入到一个HashMap集合当中,key就是用户名,value就是线程
private static HashMap<String,ClientConnectServerThread> hm=new HashMap<>();
//将某个线程加入到线程中
public static void addClientConnectServerThread(String userId,ClientConnectServerThread thread) {
hm.put(userId,thread);
}
//通过一个userId 可以得到相应的线程
public static ClientConnectServerThread getClientConnectServerThread(String userId) {
return hm.get(userId);
}
}
最后在对登陆基本功能类进行修改,对登录的用户进行检查,判断是否能够登陆进系统。
import com.qq.common.Message;
import com.qq.common.MessageType;
import com.qq.common.User;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
//用来完成登陆用户的验证,用户注册等功能
public class UserClientService {
//将user做成属性的原因:在其他地方也需要使用到user的信息
private User user=new User();
//socket之后也会被使用到,所以也做成属性
private Socket socket;
//根据UserId和pwd到服务器验证用户是否合法
public boolean checkUser(String userId,String pwd) {
boolean b=false;
//创建User对象
user.setUserId(userId);
user.setPwd(pwd);
try {
//连接到服务器,发送user对象
Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);
//向服务器端发送User对象
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(user);
//读取服务器发回的Message对象
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message message=(Message)ois.readObject();
//判断登陆是否成功
if(message.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) {
b=true;//登陆成功
//创建一个和服务器端保持通信的线程 -> 创建一个类ClientConnectServerThread
ClientConnectServerThread clientConnectServerThread = new ClientConnectServerThread(socket);
//启动客户端线程
clientConnectServerThread.start();
//因为有多个线程,需要将线程放入集合中进行管理
ManageClientConnectServerThread.addClientConnectServerThread(userId,clientConnectServerThread);
}else {
//登陆失败,我们就不能启动线程和服务器通信的线程,关闭socket
socket.close();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return b;
}
}
客户端登陆模块完成。
2.3服务器端登陆模块的实现
服务器端监听9999端口,等待用户连接,并保持通信。QQServer代码如下:
import com.qq.common.Message;
import com.qq.common.MessageType;
import com.qq.common.User;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
//服务器端,在监听9999,等待客户端的连接,并保持通信
public class QQServer {
private ServerSocket serverSocket=null;
//创建一个集合,存放多个用户,如果是这些用户登陆,就合法
//这里也可以使用ConcurrentHashMap,可以处理兵法的集合,没有线程安全
//HashMap没有处理线程安全,多线程情况下是不安全的
//ConcurrentHashMap处理的线程安全,即线程同步处理,在多线程情况下安全
private static HashMap<String,User> validUsers=new HashMap<>();
static {//在静态代码块里面初始化validUsers
validUsers.put("100",new User("100","123456"));
validUsers.put("200",new User("200","123456"));
validUsers.put("艾伦",new User("艾伦","123456"));
validUsers.put("三笠",new User("三笠","123456"));
validUsers.put("兵长",new User("兵长","123456"));
}
//验证用户是否有效
public boolean checkUser(String userId,String pwd) {
User user=validUsers.get(userId);
if(user==null) {//UserId没有存在validUser的key
return false;
}
if(!user.getPwd().equals(pwd)) {//id正确,密码错误
return false;
}
return true;
}
public QQServer() {
//端口可以写在配置文件当中
System.out.println("服务器端在9999端口进行监听...");
try {
serverSocket=new ServerSocket(9999);
//当与客户端连接完成后,服务器端的监听是一直在进行的
while(true) {
Socket socket=serverSocket.accept();//没有客户端连接就会一直阻塞在这里
//通过得到的socket进行读取关联对象的输入流
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
//读取客户端发送的User对象
User user=(User)ois.readObject();
//用户登陆信息的验证
//创建一个Message对象,准备恢复客户端
Message message=new Message();
//得到socket对象关联的对象输出流
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
if(checkUser(user.getUserId(), user.getPwd())) {//登陆成功
message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);
//将message对象回复给客户端
oos.writeObject(message);
//创建一个线程,和客户端保持通信,该线程需要持有socket对象
ServerConnectClientThread serverConnectClientThread =
new ServerConnectClientThread(socket, user.getUserId());
//启动一个线程
serverConnectClientThread.start();
//将该线程对象放到一个集合当中,进行管理
ManageServerThread.addServerThread(user.getUserId(), serverConnectClientThread);
}else {//登陆失败
System.out.println("用户 "+user.getUserId()+" 登陆失败");
message.setMesType(MessageType.MESSAGE_LOGIN_FAIL);
oos.writeObject(message);//返回失败消息
socket.close();//关闭socket流
}
}
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
//服务器端退出while,说明该服务器端已经不在监听了,关闭ServerSocket
try {
serverSocket.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
当用户验证登陆成功之后需要创建一个线程和客户端保持通信,该线程持有一个socket对象
ServerConnectClientThread类如下:
import com.qq.common.Message;
import java.io.ObjectInputStream;
import java.net.Socket;
//该类的对象和某个客户端保持通信
public class ServerConnectClientThread extends Thread{
private Socket socket;
private String userId;//用来区别与哪一个用户保持通讯
public ServerConnectClientThread(Socket socket, String userId) {
this.socket = socket;
this.userId = userId;
}
@Override
public void run() {//该线程一直处于运行状态,可以接收和发送消息
while(true) {
System.out.println("服务器端与客户端 "+userId+" 保持通信,读取数据....");
try {
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message message=(Message)ois.readObject();
//后面通过message传发消息
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}
当有多个线程时,需要创建一个管理线程的类,ManageServerThread类如下:
import java.util.HashMap;
//该类用于管理和客户端进行通信的线程
public class ManageServerThread {
private static HashMap<String,ServerConnectClientThread> hm=new HashMap<>();
//添加线程对象到线程集合
public static void addServerThread(String userId,ServerConnectClientThread thread) {
hm.put(userId,thread);
}
//根据userId得到线程集合中的一个线程对象
public static ServerConnectClientThread getServerConnectClientThread(String userId) {
return hm.get(userId);
}
}