清华辰安JAVA项目网络版JQWord文件下载.docx

清华辰安JAVA项目网络版JQWord文件下载.docx

《清华辰安JAVA项目网络版JQWord文件下载.docx》由会员分享，可在线阅读，更多相关《清华辰安JAVA项目网络版JQWord文件下载.docx（60页珍藏版）》请在冰豆网上搜索。

图中为了方便用户的测试，把密码显示出来了，如果有必要的话，可以修改代码将密码设置为不可见。

如果想关闭并退出服务器，可以单击【关闭服务器】按钮或关闭窗体按钮，此时会弹出是否关闭的提示对话框，效果如图所示：

如果想要关闭服务器，可以单击【是】按钮，否则单击【否】按钮可以取消这步操作。

以上这些功能的实现，需要了解以下几个类：

1.server.ServerMain类

他首先在配置文件serverconfig.properties中指定的端口上启动监听，当接收到一个客户端连接时就创建一个线程专门处理这个客户端的请求，最后启动服务器监听窗体。

代码如下：

/**

*ClassName:

ServerMain.java

*Author:

qiujy

*CreateTime:

2009-4-15

*EMAIL:

qjyong@

*Copyright2009++YONGAllrightsreserved.

*/

packageserver;

importjava.io.IOException;

import.*;

importjavax.swing.*;

importserver.controller.RequestProcessor;

importserver.ui.ServerInfoFrame;

/**服务器入口程序*/

publicclassServerMain{

publicstaticvoidmain（String[]args）{

intport=Integer.parseInt（DataBuffer.configProp.getProperty（"

port"

））;

//初始化服务器套节字

try{

DataBuffer.serverSocket=newServerSocket（port）;

}catch（IOExceptione）{

e.printStackTrace（）;

}

newThread（newRunnable（）{//启动新线程进行客户端连接监听

publicvoidrun（）{

try{

while（true）{

//监听客户端的连接

Socketsocket=DataBuffer.serverSocket.accept（）;

System.out.println（"

客户来了：

"

+socket.getInetAddress（）.getHostAddress（）

+"

:

+socket.getPort（））;

//针对每个客户端启动一个线程，在线程中调用请求处理器来处理每个客户端的请求

newThread（newRequestProcessor（socket））.start（）;

}

}catch（IOExceptione）{

e.printStackTrace（）;

}

}

}）.start（）;

//设置外观感觉

JFrame.setDefaultLookAndFeelDecorated（true）;

JDialog.setDefaultLookAndFeelDecorated（true）;

UIManager.setLookAndFeel（UIManager.getCrossPlatformLookAndFeelClassName（））;

}catch（Exceptione）{

//启动服务器监控窗体

newServerInfoFrame（）;

}

}

2.server.controller.RequestProcessor类

这个类专门用来处理客户端的所有请求，每个客户端的请求都会在一个独立的线程中创建RequestProcessor类的实例来处理。

每个客户的不同请求会调用不同的方法来进行处理。

详细代码如下：

/**

ServerListener.java

packageserver.controller;

importjava.io.*;

import.Socket;

importjava.text.*;

importjava.util.concurrent.CopyOnWriteArrayList;

importserver.*;

importserver.model.service.UserService;

importcommon.model.entity.*;

/**服务器端请求处理器*/

publicclassRequestProcessorimplementsRunnable{

privateSocketcurrentClientSocket;

//当前正在请求服务器的客户端Socket

publicRequestProcessor（SocketcurrentClientSocket）{

this.currentClientSocket=currentClientSocket;

publicvoidrun（）{

booleanflag=true;

//是否不间断监听

try{

OnlineClientIOCachecurrentClientIOCache=newOnlineClientIOCache（

newObjectInputStream（currentClientSocket.getInputStream（））,

newObjectOutputStream（currentClientSocket.getOutputStream（）））;

while（flag）{//不停地读取客户端发过来的请求对象

//从请求输入流中读取到客户端提交的请求对象

Requestrequest=（Request）currentClientIOCache.getOis（）.readObject（）;

System.out.println（"

Server读取了客户端的请求:

+request.getAction（））;

StringactionName=request.getAction（）;

//获取请求中的动作

if（actionName.equals（"

userRegiste"

））{//用户注册

registe（currentClientIOCache,request）;

}elseif（actionName.equals（"

userLogin"

））{//用户登录

login（currentClientIOCache,request）;

}elseif（"

exit"

.equals（actionName））{//请求断开连接

flag=logout（currentClientIOCache,request）;

chat"

.equals（actionName））{//聊天

chat（request）;

shake"

.equals（actionName））{//振动

shake（request）;

toSendFile"

.equals（actionName））{//准备发送文件

toSendFile（request）;

agreeReceiveFile"

.equals（actionName））{//同意接收文件

agreeReceiveFile（request）;

refuseReceiveFile"

.equals（actionName））{//拒绝接收文件

refuseReceiveFile（request）;

}catch（Exceptione）{

/**拒绝接收文件*/

privatevoidrefuseReceiveFile（Requestrequest）throwsIOException{

FileInfosendFile=（FileInfo）request.getAttribute（"

sendFile"

）;

Responseresponse=newResponse（）;

//创建一个响应对象

response.setType（ResponseType.REFUSERECEIVEFILE）;

response.setData（"

sendFile）;

response.setStatus（ResponseStatus.OK）;

//向请求方的输出流输出响应

OnlineClientIOCacheocic=DataBuffer.onlineUserIOCacheMap.get（sendFile.getFromUser（）.getId（））;

this.sendResponse（ocic,response）;

/**同意接收文件*/

privatevoidagreeReceiveFile（Requestrequest）throwsIOException{

//向请求方（发送方）的输出流输出响应

response.setType（ResponseType.AGREERECEIVEFILE）;

OnlineClientIOCachesendIO=DataBuffer.onlineUserIOCacheMap.get（sendFile.getFromUser（）.getId（））;

this.sendResponse（sendIO,response）;

//向接收方发出接收文件的响应

Responseresponse2=newResponse（）;

response2.setType（ResponseType.RECEIVEFILE）;

response2.setData（"

response2.setStatus（ResponseStatus.OK）;

OnlineClientIOCachereceiveIO=DataBuffer.onlineUserIOCacheMap.get（sendFile.getToUser（）.getId（））;

this.sendResponse（receiveIO,response2）;

/**客户端退出*/

publicbooleanlogout（OnlineClientIOCacheoio,Requestrequest）throwsIOException{

System.out.println（currentClientSocket.getInetAddress（）.getHostAddress（）

+"

+currentClientSocket.getPort（）+"

走了"

Useruser=（User）request.getAttribute（"

user"

//把当前上线客户端的IO从Map中删除

DataBuffer.onlineUserIOCacheMap.remove（user.getId（））;

//从在线用户缓存Map中删除当前用户

DataBuffer.onlineUsersMap.remove（user.getId（））;

response.setType（ResponseType.LOGOUT）;

logoutUser"

user）;

oio.getOos（）.writeObject（response）;

//把响应对象往客户端写

oio.getOos（）.flush（）;

currentClientSocket.close（）;

//关闭这个客户端Socket

DataBuffer.onlineUserTableModel.remove（user.getId（））;

//把当前下线用户从在线用户表Model中删除

iteratorResponse（response）;

//通知所有其它在线客户端

returnfalse;

//断开监听

/**注册*/

publicvoidregiste（OnlineClientIOCacheoio,Requestrequest）throwsIOException{

UserServiceuserService=newUserService（）;

userService.addUser（user）;

//把新注册用户添加到RegistedUserTableModel中

DataBuffer.registedUserTableModel.add（newString[]{

String.valueOf（user.getId（））,

user.getPassword（）,

user.getNickname（）,

String.valueOf（user.getSex（））

}）;

/**登录*/

publicvoidlogin（OnlineClientIOCachecurrentClientIO,Requestrequest）throwsIOException{

StringidStr=（String）request.getAttribute（"

id"

Stringpassword=（String）request.getAttribute（"

password"

Useruser=userService.login（Long.parseLong（idStr）,password）;

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）;

//添加到在线用户

//设置在线用户

onlineUsers"

newCopyOnWriteArrayList<

User>

（DataBuffer.onlineUsersMap.values（）））;

//通知其它用户有人上线了

Responseresponse2=newResponse（）;

response2.setType（ResponseType.LOGIN）;

response2.setData（"

loginUser"

iteratorResponse（response2）;

//把当前上线的用户IO添加到缓存Map中

DataBuffer.onlineUserIOCacheMap.put（user.getId（）,currentClientIO）;

//把当前上线用户添加到OnlineUserTableModel中

DataBuffer.onlineUserTableModel.add（

newString[]{String.valueOf（user.getId（））,

user.getNickname（）,

String.valueOf（user.getSex（））}）;

}else{//登录失败

response.setStatus（ResponseStatus.OK）;

response.setData（"

账号或密码不正确！

currentClientIO.getOos（）.writeObject（response）;

currentClientIO.getOos（）.flush（）;

/**聊天*/

publicvoidchat（Requestrequest）throwsIOException{

Messagemsg=（Message）request.getAttribute（"

response.setType（ResponseType.CHAT）;

txtMsg"

msg）;

if（msg.getToUser（）!

=null）{//私聊:

只给私聊的对象返回响应

OnlineClientIOCacheio=DataBuffer.onlineUserIOCacheMap.get（msg.getToUser（）.getId（））;

sendResponse（io,response）;

}else{//群聊:

给除了发消息的所有客户端都返回响应

for（Longid:

DataBuffer.onlineUserIOCacheMap.keySet（））{

if（msg.getFromUser（）.getId（）==id）{continue;

sendResponse（DataBuffer.onlineUserIOCacheMap.get（id）,response）;

/**发送振动*/

publicvoidshake（Requestreq