清华辰安JAVA项目---网络版JQ.doc

个人收集整理 勿做商业用途
1概述 1
2需求描述 1
3功能分析 2
4主要功能实现 2
4。1服务器监听模块 3
4.2客户端用户登录模块 35
4。3用户注册模块 48
4.4聊天模块 59
4。5发送文件模块 85
4。6发送振动消息模块 89

清华辰安JAVA项目———网络版JQ
1概述
为巩固对JAVA的学习，帮助大家掌握知识点，特让同学们编写一个模拟QQ在线聊天的程序JQ，可实现网上多人聊天,主要用到Swing、 线程、网络编程、集合类、文件IO处理、日期、泛型及JAVA基础知识，采用面向对象的方法设计，是对本课程的一个完整的复习和提高.
2需求描述
娱乐聊天作为一个长期的话题，早已经深入人心。为了满足学习JAVA的爱好者对网络聊天程序开发的愿望，因此开发出类似QQ聊天系统的系统JQ。
3功能分析
这个聊天系统分为服务器端和客户端两个部分：服务器端主要负责监听客户端的连接请求，把客户端的注册请求、登录请求通过网络发送给服务器端进行处理,把客户端（请求方)的聊天请求、发送文件请求、发送振动请求等转发给目标客户端（接收方）;而客户端就是负责发送请求并处理服务器端返回的响应信息。
4主要功能实现
本项目的客户端和服务器端的源代码列表如图:

从图中可以看出：项目的包主要分成客户端和服务器端两个部分.根据功能分析分为以下几大功能模块：
● 服务器监听模块
● 客户端用户登录模块
● 用户注册模块
● 聊天模块
● 发送文件模块
● 发送振动消息模块
下面就从这6个主要功能模块来分别介绍。

4。1服务器监听模块
首先运行server。serverMain.java来启动服务器监听.效果如图:

在服务器监听窗体中显示了：服务器当前所监听的端口、当前的在线用户列表、当前已注册的用户列表。如果要想看当前已注册的用户列表，可以单击【已注册用户列表】标签切换到这个选项卡,显示结果如图：

图中为了方便用户的测试,把密码显示出来了，如果有必要的话，可以修改代码将密码设置为不可见.
如果想关闭并退出服务器，可以单击【关闭服务器】按钮或关闭窗体按钮,此时会弹出是否关闭的提示对话框，效果如图所示:

如果想要关闭服务器，可以单击【是】按钮，否则单击【否】按钮可以取消这步操作。
以上这些功能的实现,需要了解以下几个类：

1. server。ServerMain类
他首先在配置文件serverconfig.properties中指定的端口上启动监听，当接收到一个客户端连接时就创建一个线程专门处理这个客户端的请求,最后启动服务器监听窗体。代码如下：
/*＊
* ClassName: ServerMain.java
* Author: qiujy
* CreateTime： 2009-4-15
* EMAIL： qjyong＠gmail。com
* Copyright 2009 ++YONG All rights reserved.
＊/
package server;

import java。io。IOException；
import java。net。＊;
import javax.swing。＊;
import server.controller.RequestProcessor;
import server.ui。ServerInfoFrame；

/** 服务器入口程序 */
public class ServerMain ｛
public static void main(String[] args) {
int port = Integer。parseInt（DataBuffer。configProp。getProperty("port"）)；
//初始化服务器套节字
try {
DataBuffer。serverSocket = new ServerSocket(port)；
} catch (IOException e) ｛
e。printStackTrace(）;
｝

new Thread（new Runnable(） {//启动新线程进行客户端连接监听
public void run（） ｛
try ｛
while （true） ｛
// 监听客户端的连接
Socket socket = DataBuffer.serverSocket。accept（）；
System。out.println（"客户来了:"
+ socket.getInetAddress()。getHostAddress（）
+ "：" + socket.getPort(））；

//针对每个客户端启动一个线程，在线程中调用请求处理器来处理每个客户端的请求
new Thread（new RequestProcessor（socket)）.start（）；
｝
} catch （IOException e) {
e。printStackTrace()；
}
｝
})。start（)；

//设置外观感觉
JFrame。setDefaultLookAndFeelDecorated(true);
JDialog.setDefaultLookAndFeelDecorated（true)；
try {
UIManager.setLookAndFeel（UIManager。getCrossPlatformLookAndFeelClassName(））；
} catch (Exception e） ｛
e.printStackTrace();
｝
//启动服务器监控窗体
new ServerInfoFrame（）；
}
}
2. server。controller.RequestProcessor类
这个类专门用来处理客户端的所有请求，每个客户端的请求都会在一个独立的线程中创建RequestProcessor类的实例来处理。每个客户的不同请求会调用不同的方法来进行处理.详细代码如下:
/*＊
＊ ClassName: ServerListener.java
＊ Author: qiujy
＊ CreateTime： 2009-4-15
＊ EMAIL： qjyong@
＊ Copyright 2009 ++YONG All rights reserved.
＊/
package server.controller;

import java。io。＊;
import 。Socket;
import java.text。＊；
import java。util.concurrent。CopyOnWriteArrayList;
import server.＊；
import server.model.service。UserService;
import common.model。entity.*;

/** 服务器端请求处理器 */
public class RequestProcessor implements Runnable｛
private Socket currentClientSocket； //当前正在请求服务器的客户端Socket

public RequestProcessor（Socket currentClientSocket){
this.currentClientSocket = currentClientSocket；
｝

public void run（） {
boolean flag = true； //是否不间断监听
try｛
OnlineClientIOCache currentClientIOCache = new OnlineClientIOCache(
new ObjectInputStream（currentClientSocket.getInputStream(）），
new ObjectOutputStream（currentClientSocket。getOutputStream(）)）；
while（flag）{ //不停地读取客户端发过来的请求对象
//从请求输入流中读取到客户端提交的请求对象
Request request = （Request)currentClientIOCache.getOis().readObject(）；
System.out。println(”Server读取了客户端的请求：” + request。getAction(））；

String actionName = request.getAction(）； //获取请求中的动作
if（actionName.equals(”userRegiste"））｛ //用户注册
registe（currentClientIOCache， request);
｝else if(actionName.equals（"userLogin"）)｛ //用户登录
login(currentClientIOCache, request);
｝else if(”exit”.equals（actionName）){ //请求断开连接
flag = logout（currentClientIOCache， request);
｝else if（"chat"。equals（actionName）)｛ //聊天
chat（request）；
｝else if("shake".equals(actionName）){ //振动
shake(request);
｝else if(”toSendFile”。equals(actionName）){ //准备发送文件
toSendFile（request);
｝else if("agreeReceiveFile".equals(actionName)){ //同意接收文件
agreeReceiveFile（request);
}else if（”refuseReceiveFile".equals（actionName))｛ //拒绝接收文件
refuseReceiveFile(request);
｝
}
｝catch(Exception e)｛
e.printStackTrace(）;
}
｝

/** 拒绝接收文件 ＊/
private void refuseReceiveFile(Request request） throws IOException ｛
FileInfo sendFile = (FileInfo）request.getAttribute(”sendFile"）；
Response response = new Response(）； //创建一个响应对象
response.setType（ResponseType.REFUSERECEIVEFILE)；
response.setData(”sendFile”, sendFile)；
response。setStatus(ResponseStatus.OK)；
//向请求方的输出流输出响应
OnlineClientIOCache ocic = DataBuffer。onlineUserIOCacheMap。get（sendFile.getFromUser().getId(））;
this.sendResponse(ocic， response);
}

/** 同意接收文件 ＊/
private void agreeReceiveFile(Request request) throws IOException ｛
FileInfo sendFile = （FileInfo）request。getAttribute(”sendFile”）；
//向请求方（发送方)的输出流输出响应
Response response = new Response()； //创建一个响应对象
response。setType（ResponseType.AGREERECEIVEFILE)；
response。setData(”sendFile", sendFile）；
response.setStatus（ResponseStatus.OK);
OnlineClientIOCache sendIO = DataBuffer。onlineUserIOCacheMap.get(sendFile.getFromUser(）.getId（)）；
this.sendResponse（sendIO, response）；

//向接收方发出接收文件的响应
Response response2 = new Response（); //创建一个响应对象
response2.setType(ResponseType。RECEIVEFILE);
response2。setData（"sendFile"， sendFile）;
response2.setStatus（ResponseStatus。OK）;
OnlineClientIOCache receiveIO = DataBuffer.onlineUserIOCacheMap.get(sendFile.getToUser(）.getId())；
this.sendResponse（receiveIO, response2)；
}

/＊＊ 客户端退出 */
public boolean logout(OnlineClientIOCache oio, Request request) throws IOException｛
System.out.println（currentClientSocket。getInetAddress(）。getHostAddress()
+ ”：" + currentClientSocket。getPort() + "走了")；

User user = (User）request.getAttribute(”user”);
//把当前上线客户端的IO从Map中删除
DataBuffer.onlineUserIOCacheMap。remove(user.getId（)）;
//从在线用户缓存Map中删除当前用户
DataBuffer。onlineUsersMap。remove(user。getId（）)；

Response response = new Response(); //创建一个响应对象
response。setType（ResponseType。LOGOUT)；
response.setData（"logoutUser", user）;
oio。getOos（）.writeObject（response）; //把响应对象往客户端写
oio.getOos()。flush（)；
currentClientSocket.close（)； //关闭这个客户端Socket

DataBuffer.onlineUserTableModel。remove（user.getId()）； //把当前下线用户从在线用户表Model中删除
iteratorResponse（response）;//通知所有其它在线客户端

return false； //断开监听
}
/*＊ 注册 */
public void registe(OnlineClientIOCache oio， Request request) throws IOException {
User user = (User）request。getAttribute("user”）;
UserService userService = new UserService(）；
userService。addUser(user)；

Response response = new Response(）； //创建一个响应对象
response。setStatus（ResponseStatus.OK）；
response。setData("user"， user）;

oio。getOos（）。writeObject（response); //把响应对象往客户端写
oio。getOos（)。flush();

//把新注册用户添加到RegistedUserTableModel中
DataBuffer.registedUserTableModel.add（new String[］{
String.valueOf(user.getId（）），
user。getPassword(),
user。getNickname（)，
String.valueOf(user。getSex()）
｝)；
}

/*＊ 登录 */
public void login（OnlineClientIOCache currentClientIO， Request request） throws IOException {
String idStr = (String）request.getAttribute（"id"）;
String password = （String) request.getAttribute（"password”);
UserService userService = new UserService(）;
User user = userService。login（Long.parseLong（idStr), password）；

Response response = new Response(）； //创建一个响应对象
if(null != user)｛
if(DataBuffer。onlineUsersMap.containsKey（user.getId（）))｛ //用户已经登录了
response.setStatus(ResponseStatus。OK);
response。setData（”msg”， ”该 用户已经在别处上线了！"）;
currentClientIO.getOos(）.writeObject(response); //把响应对象往客户端写
currentClientIO。getOos(）.flush（)；
}else { //正确登录
DataBuffer。onlineUsersMap.put（user。getId（）, user)； //添加到在线用户
//设置在线用户
response.setData("onlineUsers"，
new CopyOnWriteArrayList<User〉(DataBuffer。onlineUsersMap.values(）))；

response.setStatus（ResponseStatus.OK);
response。setData（"user”, user);
currentClientIO。getOos（)。writeObject(response）; //把响应对象往客户端写
currentClientIO。getOos(）.flush()；

//通知其它用户有人上线了
Response response2 = new Response（）;
response2。setType(ResponseType。LOGIN）；
response2。setData("loginUser", user);
iteratorResponse（response2）;

//把当前上线的用户IO添加到缓存Map中
DataBuffer.onlineUserIOCacheMap。put(user。getId(）,currentClientIO);

//把当前上线用户添加到OnlineUserTableModel中
DataBuffer。onlineUserTableModel。add(
new String［］{String。valueOf(user.getId（))，
user。getNickname(),
String.valueOf(user.getSex())}）；
}
}else｛ //登录失败
response.setStatus（ResponseStatus。OK);
response。setData(”msg"， "账号或密码不正确！”）;
currentClientIO。getOos(）.writeObject（response);
currentClientIO。getOos()。flush()；
}
}

/*＊ 聊天 ＊/
public void chat(Request request) throws IOException {
Message msg = （Message）request。getAttribute(”msg”）；
Response response = new Response（）；
response。setStatus（ResponseStatus。OK)；
response。setType(ResponseType.CHAT)；
response.setData（”txtMsg”, msg）；

if（msg。getToUser（） != null)｛ //私聊:只给私聊的对象返回响应
OnlineClientIOCache io = DataBuffer.onlineUserIOCacheMap.get（msg。getToUser(）。getId()）;
sendResponse（io， response）；
}else｛ //群聊：给除了发消息的所有客户端都返回响应
for（Long id : DataBuffer.onlineUserIOCacheMap。keySet(）){
if(msg。getFromUser（).getId（) == id ）{ continue; }
sendResponse（DataBuffer。onlineUserIOCacheMap。get(id), response）；
｝
｝
}

/** 发送振动 ＊/
public void shake(Request request)throws IOException {
Message msg = （Message）request。getAttribute（”msg"）；

DateFormat df = new SimpleDateFormat("HH：mm：ss”）;
StringBuffer sb = new StringBuffer（);
sb.append(" ")。append（msg.getFromUser(）。getNickname(））
.append（”(")。append(msg.getFromUser().getId（)）。append（”) ”)
.append（df.format(msg。getSendTime（)））。append(”\n 给您发送了一个窗口抖动\n”)；
msg.setMessage(sb.toString（））;

Response response = new Response（）；
response。setStatus（ResponseStatus。OK）;
response.setType（ResponseType.SHAKE）;
response。setData（"ShakeMsg"， msg)；

OnlineClientIOCache io = DataBuffer。onlineUserIOCacheMap。get（msg。getToUser（）.getId（））;
sendResponse（io, response);
｝

/** 准备发送文件 ＊/
public void toSendFile（Request request)throws IOException{
Response response = new Response（）;
response。setStatus(ResponseStatus。OK);
response。setType(ResponseType.TOSENDFILE);
FileInfo sendFile = （FileInfo）request.getAttribute(”file”）;
response.setData(”sendFile", sendFile）；
//给文件接收方转发文件发送方的请求
OnlineClientIOCache ioCache = DataBuffer.onlineUserIOCacheMap.get(sendFile.getToUser（).getId(））;
sendResponse（ioCache, response）;
｝

/*＊ 给所有在线客户都发送响应 ＊/
private void iteratorResponse(Response response） throws IOException {
for（OnlineClientIOCache onlineUserIO : DataBuffer。onlineUserIOCacheMap。values（））｛
ObjectOutputStream oos = onlineUserIO.getOos（）;
oos.writeObject（response）；
oos.flush（)；
}
}

/＊* 向指定客户端IO的输出流中输出指定响应 */
private void sendResponse(OnlineClientIOCache onlineUserIO， Response response)throws IOException ｛
ObjectOutputStream oos = onlineUserIO.getOos(）;
oos。writeObject(response)；
oos。flush(）；
}
｝
3. server。ui.ServerInfoFrame类
服务器信息显示窗体,他会显示当前在线用户列表和所有已经注册的用户列表，并且用一个定时任务在状态栏动态显示当前时间.代码如下：
/＊*
＊ ClassName: ServerInfoFrame.java
* Author: qiujy
* CreateTime： 2009-4-23
＊ EMAIL： qjyong＠
＊ Copyright 2009 ++YONG All rights reserved。
＊/
package server.ui；

import java.awt。BorderLayout；
import java。awt.event.*；
import java.text.*;
import java.util。＊；
import javax.swing。*；
import javax.swing.border。＊；

import common.model.entity.User；
import server。DataBuffer;
import server.model。service.UserService;

/*＊ 服务器信息窗体 */
public class ServerInfoFrame extends JFrame ｛
private static final long serialVersionUID = 6274443611957724780L;

public ServerInfoFrame（） ｛
init（）;
loadData()；
setVisible（true）;
｝

public void init(）{ //初始化窗体
this.setTitle(”服务器启动"）；//设置服务器启动标题
this。setBounds((DataBuffer.screenSize.width - 500)/2，
（DataBuffer。screenSize。height — 375）/2， 500, 375);
this。setLayout（new BorderLayout(）)；

JPanel panel = new JPanel()；
Border border = BorderFactory.createEtchedBorder（EtchedBorder。LOWERED）；
panel.setBorder(BorderFactory。createTitledBorder（border,
”服务器监控"， TitledBorder。LEFT，TitledBorder.TOP));
this.add(panel， BorderLayout。NORTH）;

JLabel label = new JLabel(”服务器当前监听在: "
+ DataBuffer。serverSocket.getLocalPort（） + ” 端口 ”);
panel。add（label）;
JButton exitBtn = new JButton(”关闭服务器”)；//关闭关闭服务器按钮
panel.add(exitBtn）；

//使用服务器缓存中的TableModel
JTable onlineUserTable = new JTable（DataBuffer.onlineUserTableModel）；
JTable registedUserTable = new JTable（DataBuffer。registedUserTableModel);

//选项卡
JTabbedPane tabbedPane = new JTabbedPane();
tabbedPane。addTab（"在线用户列表”， new JScrollPane（onlineUserTable））;
tabbedPane.addTab（"已注册用户列表", new JScrollPane（registedUserTable））；
tabbedPane.setTabComponentAt（0， new JLabel("在线用户列表”）);
this。add（tabbedPane， BorderLayout。CENTER）；

final JLabel stateBar = new JLabel（"", SwingConstants。RIGHT)；
stateBar。setBorder(BorderFactory。createEtchedBorder(EtchedBorder。LOWERED));
//用定时任务来显示当前时间
new java.util。Timer（)。scheduleAtFixedRate(
new TimerTask(）{
DateFormat df = new SimpleDateFormat（"yyyy年MM月dd日 HH：mm:ss")；
public void run(） {
stateBar.setText(”当前时间:" + df.format(new Date(）） + ” "）；
}
｝， 0, 1000);
this.add(stateBar， BorderLayout.SOUTH); //把状态栏添加到窗体的南边

//关闭窗口
this。addWindowListener（new WindowAdapter(）{
public void windowClosing（WindowEvent e） {
logout()；
｝
｝)；

/* 添加关闭服务器按钮事件处理方法 */
exitBtn。addActionListener（new ActionListener（） {
public void actionPerformed(final ActionEvent event) ｛
logout（)；
｝
｝)；
｝

/*＊ 把所有已注册的用户信息加载到RegistedUserTableModel中 */
private void loadData（)｛
List<User> users = new UserService(）。loadAllUser(）;
for (User user ： users） ｛
DataBuffer.registedUserTableModel。add（new String[]｛
String。valueOf（user.getId()），
user。getPassword（)，
user.getNickname（),
String.valueOf(user。getSex（)）
｝);
｝
}

/＊＊ 关闭服务器 ＊/
private void logout（)