一套基于http的聊天c/s结构工具(除了网页tomcat还能做什么)

在我的认识当中以前一直有一种误区认为：tomcat=web。在我看过了soap协议之后，忽然有了灵感，为什么不能用tomcat来做一个聊天软件的服务器呢？
这个具体的设计如下：
在http协议中嵌入xml(仿照soap)利用xstream把pojo转化成xml然后在服务器、客户端之间传输。如果考虑扩展性，甚至可以把客户端采用c++或者其他语言来编写，当然，其中的解析http\解析xml会比较痛苦，不知道c++有没有类似commons-httpclient\xstream的开源包。总之目前实现的客户端采用的是swt技术。

下面的几个类是一对pojo也就是通讯协议。在客户端、服务器内部使用。需要传输的时候利用xstream转化为xml传输。
协议方面主要有2组：heartbeat\upload。
HeartBeatRequest就是心跳请求，用于请求下在传送给该用户的消息，HeartBeatResponse就是返回类。uploadRequest是发送给其他用户。UploadResponse就是发送后的反馈。
因为http是无状态连接，所以每次请求都需要验证，所以任何XXXRequest都继承自Request类，其中包含验证信息，和发信人地址。protocol的代码就不贴了，太恶心了都是pojo要是想看就自己看代码吧。

下面是一个util类，用作把pojo转化为xml并且嵌入到http协议中并发送到固定url并且接受反馈xml并转化为pojo供client端使用具体代码如下：

public class MessagePoster<REQ_OBJ, RESP_OBJ> {
	private String url = "http://localhost:8080/HttpChat/Server";

	private String propLoc = "com/cxz/httpchat/util/class.properties";

	// The XStream instance is thread-safe.
	public XStream xstream = null;

	public MessagePoster() {
		initXStream();
	}

	public void setUrl(String url) {
		this.url = url;
	}

	private void initXStream() {
		xstream = new XStream();
		Properties properties = new Properties();
		try {
			properties.load(MessagePoster.class.getClassLoader()
					.getResourceAsStream(propLoc));
			Set keys = properties.keySet();
			for (Object key : keys) {
				xstream.alias((String) key, Class.forName((String) properties
						.get(key)));
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public RESP_OBJ postXML(REQ_OBJ requestObj) throws HttpException,
			IOException {
		RESP_OBJ responseObj = null;
		PostMethod method = null;
		try {
			String xml = xstream.toXML(requestObj);
			HttpClient client = new HttpClient();
			method = new PostMethod(url);
			RequestEntity entity;
			entity = new StringRequestEntity(xml, "text/xml", "utf-8");
			method.setRequestEntity(entity);
			client.executeMethod(method);
			responseObj = (RESP_OBJ) xstream.fromXML(method
					.getResponseBodyAsStream());
		} catch(StreamException e){
			e.printStackTrace();
		} finally {
			method.releaseConnection();
		}
		return responseObj;
	}

}

MessagePoster::initXStream()是初始化xstream的一个函数，具体从配置文件当中读取。具体配置文件如下：

HeartBeatRequest=com.cxz.httpchat.message.HeartBeatRequest
HeartBeatResponse=com.cxz.httpchat.message.HeartBeatResponse
UploadRequest=com.cxz.httpchat.message.UploadRequest
UploadResponse=com.cxz.httpchat.message.UploadResponse
Message=com.cxz.httpchat.message.Message

TimedQueue是该项目的另一个核心类，主要是一个消息队列，采用lru算法维护生命周期。

public class TimedQueue implements Queue<Message> {

	private long lastAccess;

	private int cycleSeconds;
	
	private static final int UNIT_CONVERSION = 1000;

	private Queue<Message> queue = new ConcurrentLinkedQueue<Message>();
	
	public List<Message> toList(){
		resetLastAccess();
		List<Message> messages = new ArrayList<Message>();
		while(!queue.isEmpty()){
			messages.add(queue.remove());
		}
		return messages;
	}

	public boolean isOutOfDate(){
		System.out.println(System.currentTimeMillis() - lastAccess);
		return System.currentTimeMillis() >= lastAccess + cycleSeconds * UNIT_CONVERSION;
	}

	public boolean add(Message e) {
		resetLastAccess();
		queue.add(e);
		return true;
	}

	public Message poll() {
		resetLastAccess();
		return queue.poll();
	}

最后一个核心类就是：SelfCleaner他会定期清理队列中的无用成员，说白了就是长期没有响应的消息。

package com.cxz.httpchat.util;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import com.cxz.httpchat.message.Message;
import com.cxz.httpchat.util.TimedQueue;

public class SelfCleaner implements Runnable{

	private Map<Integer, TimedQueue> map = new ConcurrentHashMap<Integer, TimedQueue>();
	
	private Thread gcThread;
	
	private static SelfCleaner instance;
	
	private static final int POLL_SECONDS = 60;
	
	private boolean runFlag = true;
	
	private static final int UNIT_CONVERSION = 1000;
	
	public static synchronized SelfCleaner getInstance() {
		if (instance == null) {
			instance = new SelfCleaner();
		}
		return instance;
	}
	
	private SelfCleaner(){
		
	}
	
	public void stopGc(){
		runFlag = false;
		gcThread.interrupt();
	}
	
	public void forceGc() {
		//Interrupted the sleeping gc Thread
		gcThread.interrupt();
	}
	
	public boolean isStopped() {
		return runFlag;
	}
	
	public void start() {
		gcThread = new Thread(this, "gcThread");
		gcThread.start();
	}
	
	public void run() {
		cleanTheHashMap();
		while(runFlag){
			try {
				Thread.sleep(POLL_SECONDS * UNIT_CONVERSION);
			} catch (InterruptedException e) {
				// This thread has been woken up by a interruption.
				System.out.println("Hey, man, get up from the bed and gc.");
			}
		}
		
	}
	
	public void remove(Integer id) {
		map.remove(id);
	}
	
	public List<Message> getMessage(Integer id){
		if(map.get(id) == null){
			List<Message> list = new ArrayList<Message>();
			return list;
		} else {
			return map.get(id).toList();
		}
	}
	
	public void add(Integer id, Message message) {
		TimedQueue queue = map.get(id);
		if (queue == null) {// If the user does not exists in the queue
			TimedQueue temp = new TimedQueue();
			temp.add(message);
			map.put(id, temp);
		} else {
			queue.add(message);
		}
	}

	private void cleanTheHashMap() {
		Set<Integer> set = map.keySet();
		for (Integer id : set) {
			TimedQueue tq = map.get(id);
			if (tq.isOutOfDate()) {
				map.remove(id);
			}
		}
	}

}

最后一个类就是服务器类，很短，但很精悍。

package com.cxz.httpchat.server;

import java.io.IOException;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.cxz.httpchat.message.HeartBeatRequest;
import com.cxz.httpchat.message.HeartBeatResponse;
import com.cxz.httpchat.message.Message;
import com.cxz.httpchat.message.UploadRequest;
import com.cxz.httpchat.message.UploadResponse;
import com.cxz.httpchat.util.MessagePoster;
import com.cxz.httpchat.util.SelfCleaner;
import com.thoughtworks.xstream.XStream;

/**
 * Servlet implementation class for Servlet: Server
 *
 */
public class Server extends javax.servlet.http.HttpServlet implements
		javax.servlet.Servlet {
	/* (non-Java-doc)
	 * @see javax.servlet.http.HttpServlet#HttpServlet()
	 */
	private XStream xstream = new MessagePoster().xstream;
	
	SelfCleaner map = SelfCleaner.getInstance();

	public Server() {
		super();
		map.start();
	}

	
	/* (non-Java-doc)
	 * @see javax.servlet.http.HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
	}

	/* (non-Java-doc)
	 * @see javax.servlet.http.HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		Object req = xstream.fromXML(request.getInputStream());
		Object resp = processRequest(req);
		if(resp != null){
			xstream.toXML(resp, response.getOutputStream());
		} else {// Check the null
			
		}
	}
	
	private Object processRequest(Object req){
		if(req.getClass() == UploadRequest.class){
			UploadRequest upload = (UploadRequest)req;
			return processUpload(upload);
		} else if (req.getClass() == HeartBeatRequest.class) {
			HeartBeatRequest heartBeat = (HeartBeatRequest)req;
			return processHeartBeat(heartBeat);
		} else {
			return null;
		}
	}

	/**
	 * Just for fun
	 * @param upload
	 * @return
	 */
	private UploadResponse processUpload(UploadRequest upload) {
		//Just for tracking the message flow
		Message message = new Message();
		message.setFrom(upload.getId());
		message.setDate(upload.getDate());
		message.setContent(upload.getContent());
		map.add(upload.getTo(), message);
		UploadResponse resp = null;
		if(true/*upload.getId().equals(new Integer(1))&&upload.getPwd().equals("19841230")*/){
			resp = new UploadResponse(); 
			resp.setFlag(true);
		} else {
			resp = new UploadResponse(); 
			resp.setFlag(false);
		}
		return resp;
	}

	/**
	 * Just for fun
	 * @param heartBeat
	 * @return
	 */
	private HeartBeatResponse processHeartBeat(HeartBeatRequest heartBeat) {
		//Just for tracking the message flow
		HeartBeatResponse resp = new HeartBeatResponse();
		//need to do some login process
		if(true/*heartBeat.getId().equals(new Integer(1))&&heartBeat.getPwd().equals("19841230")*/){
			resp.setFlag(true);
			List<Message> list = map.getMessage(heartBeat.getId());
			resp.setMessages(list);
		} else {
			resp.setFlag(false);
		}
		return resp;
	}
}

写完了。好累。

最后写下怎么用吧：在ChatClient中修改usrId、distId成员来确定发送者和接受者。设成相反的两个数字就可以，当然，客户端要启动2次。验证功能目前是关闭的。password无所谓了。
MessagePoster中的url可能需要修改一下，如果你部署的时候改变路径了。

就这么多了

评论

4 楼 tianzhihehe 2009-12-16  

支持，我一直在想用什么协议来传输数据呢。看了楼主的文章，应该是SOAP了。拜读……

3 楼 Aga 2008-08-19  

Zhang [e-mail]

2 楼 sion 2008-08-09  

gmail

1 楼 jelver 2008-08-09  

感觉还不错，看看