websocket - java 后台处理实例详解

websocket 的前台这里就不多说了 主要说一下后台的业务逻辑 。
以下是本人的websocket 协议解析,框架是基于mina + spring 做的。
需要的mina jar包有

mina-core-2.0.4.jar
mina-integration-beans-2.0.4.jar
mina-integration-jmx-2.0.4.jar
mina-integration-ognl-2.0.4.jar
mina-integration-spring-1.1.7.jar.zip
大家还没搞出来的可以参照一下，若不对的还希望各位大神指出或者线下交流 QQ：593040793



import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;

import qq.web.model.Data;
import qq.web.service.MessageData;
import qq.web.service.UserService;

/**
*
* @author 程欣伟
*
*/
public class WebSocketIoHandler extends IoHandlerAdapter {


@Autowired private MessageData messageData;

@Autowired private UserService userService;

    public static final String INDEX_KEY = WebSocketIoHandler.class.getName() + ".INDEX";
   
    //key=sessionId  value = session   sid 和 session对应
    private   Map<Long, IoSession>  ioSessionMap = new HashMap<Long, IoSession>();
    //key = userId value = sessionId   用户和 sid 对应
    private Map<Integer,Long> userSessionMap =   new HashMap<Integer, Long>();
   
    /**
     * 将IoBuffer转换成string  
     * @author 程欣伟
     * @param message
     * @return
     */
    public String ioBufferToString(Object message) { 
    if (!(message instanceof IoBuffer)){ 
    return ""; 
    } 
    IoBuffer ioBuffer = (IoBuffer) message; 
    return new String(ioBuffer.array());
    } 
   
    /**
     * 当有请求消息时触发
     * @author 程欣伟
     * @return
     */
    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {
//    System.out.println(ioBufferToString(message));
    //吧传入的消息转换成流
    IoBuffer buffer = (IoBuffer)message;
    //转换成字节数组
    byte[] b = new byte[buffer.limit()];
    buffer.get(b);
   
    //获取sessionId
    Long sid = session.getId();

    //如果没有此sessionId则代表第一次连接
    if (!ioSessionMap.containsKey(sid)) {
    //把此session放入map
    ioSessionMap.put(sid, session);
   
    byte[] bufferAry = buffer.array();
        String m = new String(bufferAry);
       
        //获取握手协议字符串
String sss = getSecWebSocketAccept(m);

buffer.clear();
buffer.put(sss.getBytes("utf-8"));

buffer.flip();
session.write(buffer);

buffer.free();
    } else {
    //存在session
    //解析传输的数据内容
    String str = decode(b);
//    System.out.println(roleStr);
   
   
    //--------------- 业务开始 ---------------- //
    ObjectMapper objectMapper = new ObjectMapper();
   
    Data data = null;
    try{
    data = objectMapper.readValue(str, Data.class);
    }catch(Exception e){
    return ;
    }
   
    try{
    if(data.getDataType().equals("message")){
    messageData.processMessage(data.getData());
    }else if(data.getDataType().equals("login")){
    userService.processUser(data.getData(),sid);
    }
    }catch(Exception e){
    //如果处理消息报错 则告知浏览器
    e.printStackTrace();
    data.setData("false");
    sendMessageToHtml(objectMapper.writeValueAsString(data), sid);
    }
   
    }
    }
   
   
    /**
     * 发送消息给浏览器
     * @author 程欣伟
     * @param msg
     * @param sid
     * @return
     */
    public  boolean sendMessageToHtml(String msg,Long sid) {
    boolean sendFlag = true;
    try{
    //获取字节数组
    byte[] bb = encode( msg);
   
    //创建IO流
    IoBuffer ioBuffer = IoBuffer.allocate(bb.length);
    //把字节数组写入流中
    ioBuffer.put(bb);
    //api 解释为翻转 但是目前不知道什么意思
    ioBuffer.flip();
   
    //同步块
    synchronized (ioSessionMap) {
    //获取所有的session
        IoSession ioSession = ioSessionMap.get(sid);
if (ioSession!=null&&ioSession.isConnected()) {
//复制一个新的buffer
IoBuffer  writeResult = ioBuffer.duplicate();
ioSession.write(writeResult);
}else{
sendFlag = false;
    }
        }
    ioBuffer.free();
    }catch(Exception e){
    e.printStackTrace();
    sendFlag=false;
    }
    return sendFlag;
    }
   

    @Override  
    public void sessionOpened(IoSession session) throws Exception {
        session.setAttribute(INDEX_KEY, 0);
    }

//    @Override  
//    public void sessionIdle( IoSession session, IdleStatus status ) throws Exception {  
//        System.out.println( "IDLE " + session.getIdleCount( status ));  
//    }
   

    /**
     * 当ws连接断开时触发
     */
@Override
public void sessionClosed(IoSession session) throws Exception {
//如果不连接的话 则删除
ioSessionMap.remove(session);;
}
   




/**
* 根据用户ID 获取 session连接
* @param userId
* @return
*/
public IoSession getSessionByUserId(int userId){

Long sid = userSessionMap.get(userId);
if(sid==null){
return null;
}
IoSession session = ioSessionMap.get(sid);
if(session==null){
userSessionMap.remove(userId);
return null;
}
return session;
}

   


/**
*
* @author 程欣伟
* 获取握手协议 字符串
* 首先要获取到请求头中的Sec-WebSocket-Key的值，再把这一段GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11
* 加到获取到的Sec-WebSocket-Key的值的后面，然后拿这个字符串做SHA-1 hash计算，然后再把得到的结果通过base64加密
* @param key
* @return
*/
private String getSecWebSocketAccept(String key) {
String secKey = getSecWebSocketKey(key);

String guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
secKey += guid;
try {
MessageDigest md = MessageDigest.getInstance("SHA-1");
md.update(secKey.getBytes("iso-8859-1"), 0, secKey.length());
byte[] sha1Hash = md.digest();
secKey = base64Encode(sha1Hash);
} catch (Exception e) {
e.printStackTrace();
}

String rtn = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "
+ secKey + "\r\n\r\n";
return rtn;
}

/**
*
* @author 程欣伟
* 获取到请求头中的Sec-WebSocket-Key的
* @param req
* @return
*/
private String getSecWebSocketKey(String req) {
Pattern p = Pattern.compile("^(Sec-WebSocket-Key:).+",
Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
Matcher m = p.matcher(req);
if (m.find()) {
String foundstring = m.group();
return foundstring.split(":")[1].trim();
} else {
return null;
}

}

/**
* base64
* @param input
* @return
*/
private String base64Encode(byte[] input) {
return new String(org.apache.mina.util.Base64.encodeBase64(input));
}



/**
* @author 程欣伟
* 把传入的消息解码
* @param receivedDataBuffer
* @return
* @throws UnsupportedEncodingException
*/
private String decode(byte[] receivedDataBuffer)
throws UnsupportedEncodingException {
String result = null;

//数据开始的位数  前面2个byte 固定必须存在
int dataStartIndex=2;

//查看第一帧的值  代表是否结束
int isend = receivedDataBuffer[0]>>7&0x1;
System.out.println("是否结束：【"+(isend==1?"yes":"no")+"】");

//获取是否需要掩码
boolean mask = ((receivedDataBuffer[1]>>7&0x1)==1)?true:false;

System.out.println("掩码：【"+(mask?"yes":"no")+"】");

//Payload length: 传输数据的长度，以字节的形式表示：7位、7+16位、或者7+64位。
//如果这个值以字节表示是0-125这个范围，那这个值就表示传输数据的长度；
//如果这个值是126，则随后的两个字节表示的是一个16进制无符号数，用来表示传输数据的长度；
//如果这个值是127,则随后的是8个字节表示的一个64位无符合数，这个数用来表示传输数据的长度
int dataLength = receivedDataBuffer[1] & 0x7F;

System.out.println("描述消息长度：【"+dataLength+"】");

//查看 消息描述 是否大于 126 如果大于

if(dataLength<126){
//126以内取本身
}else if(dataLength==126){
dataStartIndex = dataStartIndex +2;
}else if(dataLength==127){
dataStartIndex = dataStartIndex +8;
}

//掩码数组
byte[]  frameMaskingAry = new byte[4];
if(mask){
for(int i=0;i<frameMaskingAry.length;i++){
frameMaskingAry[i] = receivedDataBuffer[dataStartIndex+i];
}
dataStartIndex += 4;
}

// 计算非空位置
int lastStation = receivedDataBuffer.length - 1;

// 利用掩码对org-data进行异或
int frame_masking_key = 0;


//保存数据的 数组
byte[] dataByte = new byte[lastStation-dataStartIndex+1];

if(mask){
for (int i = dataStartIndex; i <= lastStation; i++) {
//吧数据进行异或运算
receivedDataBuffer[i] = (byte) (receivedDataBuffer[i] ^ frameMaskingAry[frame_masking_key%4]);
//吧进行异或运算之后的 数据放入数组
dataByte[i-dataStartIndex]=receivedDataBuffer[i];
frame_masking_key++;
}
}



result = new String(dataByte, "UTF-8");
System.out.println(result);
return result;

}

/**
* @author 程欣伟
* 对传入数据进行无掩码转换
* @param msg
* @return
* @throws UnsupportedEncodingException
*/
private byte[] encode(String msg) throws UnsupportedEncodingException {
// 掩码开始位置
int masking_key_startIndex = 2;

byte[] msgByte = msg.getBytes("UTF-8");

// 计算掩码开始位置
if (msgByte.length <= 125) {
masking_key_startIndex = 2;
} else if (msgByte.length > 65536) {
masking_key_startIndex = 10;
} else if (msgByte.length > 125) {
masking_key_startIndex = 4;
}

// 创建返回数据
byte[] result = new byte[msgByte.length + masking_key_startIndex];

// 开始计算ws-frame
// frame-fin + frame-rsv1 + frame-rsv2 + frame-rsv3 + frame-opcode
result[0] = (byte) 0x81; // 129

// frame-masked+frame-payload-length
// 从第9个字节开始是 1111101=125,掩码是第3-第6个数据
// 从第9个字节开始是 1111110>=126,掩码是第5-第8个数据
if (msgByte.length <= 125) {
result[1] = (byte) (msgByte.length);
} else if (msgByte.length > 65536) {
result[1] = 0x7F; // 127
} else if (msgByte.length > 125) {
result[1] = 0x7E; // 126
result[2] = (byte) (msgByte.length >>;
result[3] = (byte) (msgByte.length % 256);
}

// 将数据编码放到最后
for (int i = 0; i < msgByte.length; i++) {
result[i + masking_key_startIndex] = msgByte[i];
}

decode(result);

String str = new String(result ,"utf-8");
System.out.println(str);
return result;
}

public Map<Long, IoSession> getIoSessionMap() {
return ioSessionMap;
}

public void setIoSessionMap(Map<Long, IoSession> ioSessionMap) {
this.ioSessionMap = ioSessionMap;
}

public Map<Integer, Long> getUserSessionMap() {
return userSessionMap;
}

public void setUserSessionMap(Map<Integer, Long> userSessionMap) {
this.userSessionMap = userSessionMap;
}

public static void main(String[] args) throws UnsupportedEncodingException {

byte b = 8;
  System.out.println(""
    + (byte) ((b >> 7) & 0x1) + (byte) ((b >> 6) & 0x1)
    + (byte) ((b >> 5) & 0x1) + (byte) ((b >> 4) & 0x1)
    + (byte) ((b >> 3) & 0x1) + (byte) ((b >> 2) & 0x1)
    + (byte) ((b >> 1) & 0x1) + (byte) ((b >> 0) & 0x1)
   );
 
 
byte[] a = {(byte)104,(byte)49};
System.out.println(new String(a,"utf-8"));
}



}