转载请注明出处，谢谢！
今天跟大家分享一下我那QQ小项目中服务器与客户端的核心代码，并谈谈一些我的建议和看法，希望大家多多支持，你们的支持，就是我继续分享的动力，哈哈！
一、服务器，好了，废话不多说，我们先来看看服务器部分，我这里用到线程池，至于为什么用线程池，不知道的童鞋可以去我的另一篇blog看看：http://blog.csdn.net/weidi1989/article/details/7930820。当一个用户连接上之后，我们马上将该用户的socket丢入已经建好的线程池中去处理，这样可以很快腾出时间来接受下一个用户的连接，而线程池中的这个线程又分支为两个线程，一个是读消息线程，一个是写消息线程，当然，因为我这个聊天是用来转发消息的，所以还以单例模式建了一个Map用来存放每个用户的写消息线程（如果用户多的话，这是相当消耗资源的），以便在转发消息的时候，通过Map的key就可以取出对应用户的写消息线程，从而达到转发消息的目的。具体下面再说
/**
* 服务器，接受用户登录、离线、转发消息
*
* @author way
*
*/
public class Server {
private ExecutorService executorService;// 线程池
private ServerSocket serverSocket = null;
private Socket socket = null;
private boolean isStarted = true;//是否循环等待
public Server() {
try {
// 创建线程池，池中具有(cpu个数*50)条线程
executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
.availableProcessors() * 50);
serverSocket = new ServerSocket(Constants.SERVER_PORT);
} catch (IOException e) {
e.printStackTrace();
quit();
}
}
public void start() {
System.out.println(MyDate.getDateCN() + " 服务器已启动...");
try {
while (isStarted) {
socket = serverSocket.accept();
String ip = socket.getInetAddress().toString();
System.out.println(MyDate.getDateCN() + " 用户：" + ip + " 已建立连接");
// 为支持多用户并发访问，采用线程池管理每一个用户的连接请求
if (socket.isConnected())
executorService.execute(new SocketTask(socket));// 添加到线程池
}
if (socket != null)//循环结束后，记得关闭socket，释放资源
socket.close();
if (serverSocket != null)
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
// isStarted = false;
}
}
private final class SocketTask implements Runnable {
private Socket socket = null;
private InputThread in;
private OutputThread out;
private OutputThreadMap map;
public SocketTask(Socket socket) {
this.socket = socket;
map = OutputThreadMap.getInstance();
}
@Override
public void run() {
out = new OutputThread(socket, map);//
// 先实例化写消息线程,（把对应用户的写线程存入map缓存器中）
in = new InputThread(socket, out, map);// 再实例化读消息线程
out.setStart(true);
in.setStart(true);
in.start();
out.start();
}
}
/**
* 退出
*/
public void quit() {
try {
this.isStarted = false;
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new Server().start();
}
}
二、服务器写消息线程，接下来，我们来看看写消息线程，很简单的一段代码，有注释，我就不多说了：
/**
* 写消息线程
*
* @author way
*
*/
public class OutputThread extends Thread {
private OutputThreadMap map;
private ObjectOutputStream oos;
private TranObject object;
private boolean isStart = true;// 循环标志位
private Socket socket;
public OutputThread(Socket socket, OutputThreadMap map) {
try {
this.socket = socket;
this.map = map;
oos = new ObjectOutputStream(socket.getOutputStream());// 在构造器里面实例化对象输出流
} catch (IOException e) {
e.printStackTrace();
}
}
public void setStart(boolean isStart) {//用于外部关闭写线程
this.isStart = isStart;
}
// 调用写消息线程，设置了消息之后，唤醒run方法，可以节约资源
public void setMessage(TranObject object) {
this.object = object;
synchronized (this) {
notify();
}
}
@Override
public void run() {
try {
while (isStart) {
// 没有消息写出的时候，线程等待
synchronized (this) {
wait();
}
if (object != null) {
oos.writeObject(object);
oos.flush();
}
}
if (oos != null)// 循环结束后，关闭流，释放资源
oos.close();
if (socket != null)
socket.close();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
三、服务器写消息线程缓存器，接下来让我们看一下那个写消息线程缓存器的庐山真面目：
/**
* 存放写线程的缓存器
*
* @author way
*/
public class OutputThreadMap {
private HashMap<Integer, OutputThread> map;
private static OutputThreadMap instance;
// 私有构造器，防止被外面实例化改对像
private OutputThreadMap() {
map = new HashMap<Integer, OutputThread>();
}
// 单例模式像外面提供该对象
public synchronized static OutputThreadMap getInstance() {
if (instance == null) {
instance = new OutputThreadMap();
}
return instance;
}
// 添加写线程的方法
public synchronized void add(Integer id, OutputThread out) {
map.put(id, out);
}
// 移除写线程的方法
public synchronized void remove(Integer id) {
map.remove(id);
}
// 取出写线程的方法,群聊的话，可以遍历取出对应写线程
public synchronized OutputThread getById(Integer id) {
return map.get(id);
}
// 得到所有写线程方法，用于向所有在线用户发送广播
public synchronized List<OutputThread> getAll() {
List<OutputThread> list = new ArrayList<OutputThread>();
for (Map.Entry<Integer, OutputThread> entry : map.entrySet()) {
list.add(entry.getValue());
}
return list;
}
}
四、服务器读消息线程，接下来是读消息线程，这里包括两个部分，一部分是读消息，另一部分是处理消息，我以分开的形式贴出代码，虽然我是写在一个类里面的：
/**
* 读消息线程和处理方法
*
* @author way
*
*/
public class InputThread extends Thread {
private Socket socket;// socket对象
private OutputThread out;// 传递进来的写消息线程，因为我们要给用户回复消息啊
private OutputThreadMap map;//写消息线程缓存器
private ObjectInputStream ois;//对象输入流
private boolean isStart = true;//是否循环读消息
public InputThread(Socket socket, OutputThread out, OutputThreadMap map) {
this.socket = socket;
this.out = out;
this.map = map;
try {
ois = new ObjectInputStream(socket.getInputStream());//实例化对象输入流
} catch (IOException e) {
e.printStackTrace();
}
}
public void setStart(boolean isStart) {//提供接口给外部关闭读消息线程
this.isStart = isStart;
}
@Override
public void run() {
try {
while (isStart) {
// 读取消息
readMessage();
}
if (ois != null)
ois.close();
if (socket != null)
socket.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
五、服务器消息处理，下面是处理消息的方法，由于比较麻烦以及各种纠结，我就与读消息线程分开贴，显得稍微简洁一点：
/**
* 读消息以及处理消息，抛出异常
*
* @throws IOException
* @throws ClassNotFoundException
*/
public void readMessage() throws IOException, ClassNotFoundException {
Object readObject = ois.readObject();// 从流中读取对象
UserDao dao = UserDaoFactory.getInstance();// 通过dao模式管理后台
if (readObject != null && readObject instanceof TranObject) {
TranObject read_tranObject = (TranObject) readObject;// 转换成传输对象
switch (read_tranObject.getType()) {
case REGISTER:// 如果用户是注册
User registerUser = (User) read_tranObject.getObject();
int registerResult = dao.register(registerUser);
System.out.println(MyDate.getDateCN() + " 新用户注册:"
+ registerResult);
// 给用户回复消息
TranObject<User> register2TranObject = new TranObject<User>(
TranObjectType.REGISTER);
User register2user = new User();
register2user.setId(registerResult);
register2TranObject.setObject(register2user);
out.setMessage(register2TranObject);
break;
case LOGIN:
User loginUser = (User) read_tranObject.getObject();
ArrayList<User> list = dao.login(loginUser);
TranObject<ArrayList<User>> login2Object = new TranObject<ArrayList<User>>(
TranObjectType.LOGIN);
if (list != null) {// 如果登录成功
TranObject<User> onObject = new TranObject<User>(
TranObjectType.LOGIN);
User login2User = new User();
login2User.setId(loginUser.getId());
onObject.setObject(login2User);
for (OutputThread onOut : map.getAll()) {
onOut.setMessage(onObject);// 广播一下用户上线
}
map.add(loginUser.getId(), out);// 先广播，再把对应用户id的写线程存入map中，以便转发消息时调用
login2Object.setObject(list);// 把好友列表加入回复的对象中
} else {
login2Object.setObject(null);
}
out.setMessage(login2Object);// 同时把登录信息回复给用户
System.out.println(MyDate.getDateCN() + " 用户："
+ loginUser.getId() + " 上线了");
break;
case LOGOUT:// 如果是退出，更新数据库在线状态，同时群发告诉所有在线用户
User logoutUser = (User) read_tranObject.getObject();
int offId = logoutUser.getId();
System.out
.println(MyDate.getDateCN() + " 用户：" + offId + " 下线了");
dao.logout(offId);
isStart = false;// 结束自己的读循环
map.remove(offId);// 从缓存的线程中移除
out.setMessage(null);// 先要设置一个空消息去唤醒写线程
out.setStart(false);// 再结束写线程循环
TranObject<User> offObject = new TranObject<User>(
TranObjectType.LOGOUT);
User logout2User = new User();
logout2User.setId(logoutUser.getId());
offObject.setObject(logout2User);
for (OutputThread offOut : map.getAll()) {// 广播用户下线消息
offOut.setMessage(offObject);
}
break;
case MESSAGE:// 如果是转发消息（可添加群发）
// 获取消息中要转发的对象id，然后获取缓存的该对象的写线程
int id2 = read_tranObject.getToUser();
OutputThread toOut = map.getById(id2);
if (toOut != null) {// 如果用户在线
toOut.setMessage(read_tranObject);
} else {// 如果为空，说明用户已经下线,回复用户
TextMessage text = new TextMessage();
text.setMessage("亲！对方不在线哦，您的消息将暂时保存在服务器");
TranObject<TextMessage> offText = new TranObject<TextMessage>(
TranObjectType.MESSAGE);
offText.setObject(text);
offText.setFromUser(0);
out.setMessage(offText);
}
break;
case REFRESH:
List<User> refreshList = dao.refresh(read_tranObject
.getFromUser());
TranObject<List<User>> refreshO = new TranObject<List<User>>(
TranObjectType.REFRESH);
refreshO.setObject(refreshList);
out.setMessage(refreshO);
break;
default:
break;
}
}
}
好了，服务器的核心代码就这么一些了，很简单吧？是的，因为我们还有很多事情没有去做，比如说心跳监测用户是否一直在线，如果不在线，就释放资源等，这些都是商业项目中必须要考虑到的问题，至于这个通过心跳监测用户是否在线，我说说我的一些想法吧：由客户端定时给服务器发送一个心跳包（最好是空包，节约流量），服务器也定时去监测那个心跳包，如果有3次未收到客户端的心跳包，就判断该用户已经掉线，释放资源，至于这次数和时间间隔，就随情况而定了。如果有什么更好的其他建议，欢迎给我留言，谢谢。
六、消息传输对象，下面，我们来看看，这个超级消息对象和定义好的消息类型：
/**
* 传输的对象,直接通过Socket传输的最大对象
*
* @author way
*/
public class TranObject<T> implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private TranObjectType type;// 发送的消息类型
private int fromUser;// 来自哪个用户
private int toUser;// 发往哪个用户
private T object;// 传输的对象，这个对象我们可以自定义任何
private List<Integer> group;// 群发给哪些用户
get...set...
/**
* 传输对象类型
*
* @author way
*
*/
public enum TranObjectType {
REGISTER, // 注册
LOGIN, // 用户登录
LOGOUT, // 用户退出登录
FRIENDLOGIN, // 好友上线
FRIENDLOGOUT, // 好友下线
MESSAGE, // 用户发送消息
UNCONNECTED, // 无法连接
FILE, // 传输文件
REFRESH,//刷新好友列表
}
七、客户端，然后是客户端部分了，其实跟服务器差不多，只是没有建立线程池了，因为没有必要，是吧？然后实例化写线程和读线程没有先后顺序，这也勉强算一个区别吧~呵呵
/**
* 客户端
*
* @author way
*
*/
public class Client {
private Socket client;
private ClientThread clientThread;
private String ip;
private int port;
public Client(String ip, int port) {
this.ip = ip;
this.port = port;
}
public boolean start() {
try {
client = new Socket();
// client.connect(new InetSocketAddress(Constants.SERVER_IP,
// Constants.SERVER_PORT), 3000);
client.connect(new InetSocketAddress(ip, port), 3000);
if (client.isConnected()) {
// System.out.println("Connected..");
clientThread = new ClientThread(client);
clientThread.start();
}
} catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
// 直接通过client得到读线程
public ClientInputThread getClientInputThread() {
return clientThread.getIn();
}
// 直接通过client得到写线程
public ClientOutputThread getClientOutputThread() {
return clientThread.getOut();
}
// 直接通过client停止读写消息
public void setIsStart(boolean isStart) {
clientThread.getIn().setStart(isStart);
clientThread.getOut().setStart(isStart);
}
public class ClientThread extends Thread {
private ClientInputThread in;
private ClientOutputThread out;
public ClientThread(Socket socket) {
in = new ClientInputThread(socket);
out = new ClientOutputThread(socket);
}
public void run() {
in.setStart(true);
out.setStart(true);
in.start();
out.start();
}
// 得到读消息线程
public ClientInputThread getIn() {
return in;
}
// 得到写消息线程
public ClientOutputThread getOut() {
return out;
}
}
}
八、客户端写消息线程，先看看客户端写消息线程吧：
/**
* 客户端写消息线程
*
* @author way
*
*/
public class ClientOutputThread extends Thread {
private Socket socket;
private ObjectOutputStream oos;
private boolean isStart = true;
private TranObject msg;
public ClientOutputThread(Socket socket) {
this.socket = socket;
try {
oos = new ObjectOutputStream(socket.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
public void setStart(boolean isStart) {
this.isStart = isStart;
}
// 这里处理跟服务器是一样的
public void setMsg(TranObject msg) {
this.msg = msg;
synchronized (this) {
notify();
}
}
@Override
public void run() {
try {
while (isStart) {
if (msg != null) {
oos.writeObject(msg);
oos.flush();
if (msg.getType() == TranObjectType.LOGOUT) {// 如果是发送下线的消息，就直接跳出循环
break;
}
synchronized (this) {
wait();// 发送完消息后，线程进入等待状态
}
}
}
oos.close();// 循环结束后，关闭输出流和socket
if (socket != null)
socket.close();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
九、客户端读消息线程，然后是客户端读消息线程，这里又有一个要注意的地方，我们收到消息的时候，是不是要告诉用户？如何告诉呢？接口监听貌似是一个很好的办法，神马？不知道接口监听？你会用Android的setOnClickListener不？这就是android封装好的点击事件监听，不懂的话，可以好好看看，理解一下，其实也不难：
/**
* 客户端读消息线程
*
* @author way
*
*/
public class ClientInputThread extends Thread {
private Socket socket;
private TranObject msg;
private boolean isStart = true;
private ObjectInputStream ois;
private MessageListener messageListener;// 消息监听接口对象
public ClientInputThread(Socket socket) {
this.socket = socket;
try {
ois = new ObjectInputStream(socket.getInputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 提供给外部的消息监听方法
*
* @param messageListener
* 消息监听接口对象
*/
public void setMessageListener(MessageListener messageListener) {
this.messageListener = messageListener;
}
public void setStart(boolean isStart) {
this.isStart = isStart;
}
@Override
public void run() {
try {
while (isStart) {
msg = (TranObject) ois.readObject();
// 每收到一条消息，就调用接口的方法，并传入该消息对象，外部在实现接口的方法时，就可以及时处理传入的消息对象了
// 我不知道我有说明白没有？
messageListener.Message(msg);
}
ois.close();
if (socket != null)
socket.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 消息监听接口
*
* @author way
*
*/
public interface MessageListener {
public void Message(TranObject msg);
}
}
好了，总算copy完了，如果大家有什么不理解，或者有什么好的建议，欢迎给我留言，记住：你们的支持是我继续下去的动力，哈哈
分享到：
相关推荐
基于java socket网络编程实现的简单模拟qq聊天的程序，可实现并发聊天，分为服务器和客户端两个部分
Java Socket 聊天通信演示代码 Java Socket 聊天通信演示代码
本程序是用java语言基于socket编写的聊天程序，可以公聊，也可以私聊。 本程序包含简单的用户登录和注册，数据库用的是Mysql数据库。
使用java编写的类似聊天室的程序，在上次的基础上继续改进，将服务器端的IP地址写在配置文件里面，是程序的使用更加灵活，server.properties文件为配置文件，修改里面的ip地址为服务器端运行的ip地址即可使用。...
可以实现简单的类似qq聊天的项目，所有的消息都是通过服务器的转发来实现的，可以实现群聊，私聊，状态的改变（包括在线、隐身、离线）
基于Javaswing和socket实现的仿QQ在线聊天程序源码(含服务端+客户端).zip基于Javaswing和socket实现的仿QQ在线聊天程序源码(含服务端+客户端).zip基于Javaswing和socket实现的仿QQ在线聊天程序源码(含服务端+客户端)...
Java Socket编写的聊天室，有用到多线程、Socket、输入输出流等相关知识。是个综合实例。局域网内多人聊天，类似qq群。
本人编写，可能有漏洞之处，但学习socket，和基本的java还是有参考价值的
基于java socket实现的多人聊天程序，分为客户端和服务器端，希望可以对你有帮助
基于TCP协议，用Java语言，仿QQ通信，简单实现视频聊天及私聊功能
一个基于java sokcet的QQ程序，代码完整！希望大家多多指教....
很完美的聊天室系统，摘自java精通实例，非常具有参考学习价值。
你花10分下载，绝对会发现物有所值，我觉得这个demo会充分的让你理解java的socket，让你可以做出自己的socket程序。
java聊天室适用java swing SOCKET QQ
Java实现的企业内部QQ聊天系统，Socket线程通信，单人，多人在线聊天
计算机网络课程设计 聊天室软件 基于C/S架构 采用多线程方法实现客户端与服务器之间消息的传送与转发
java swing socket 实现简单的聊天 详情请联系QQ1823574190
1、界面模仿QQ界面，能够发起一对一聊天、接受聊天请求； 2、能够以当前日期和时间（精确到分）命名的文件来保持聊天记录； 3、能够调出聊天记录； 4、添加和用户头像 5、还有更多功能，您看了就知道。 6、有一个小...
用java语言及网络通信socket编程编写的网络聊天室，能够实现多人在线聊天。
java实现多人聊天（类似于QQ聊天）