MINA 网络黏包处理代码

本文完整代码，可以浏览：

https://github.com/hjj2017/xgame-code_server/blob/master/game_server/src/com/game/gameServer/framework/mina/MsgCumulativeFilter.java

 

我在网上查阅过的 MINA 黏包处理，一般都是放在 Decoder 中做的。也就是黏包处理和消息解码放在一起做，显得比较混乱不好打理。而以下这段代码，我是把黏包处理放在 Filter 中了。在具体使用时可以这样：

// 创建 IO 接收器
NioSocketAcceptor acceptor = new NioSocketAcceptor();

// 获取责任链
DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
// 处理网络粘包
chain.addLast("msgCumulative", new MsgCumulativeFilter());

// 添加自定义编解码器
chain.addLast("msgCodec", new ProtocolCodecFilter(
    new XxxEncoder(),
    new XxxDecoder()
));

// 获取会话配置
IoSessionConfig cfg = acceptor.getSessionConfig();

// 设置缓冲区大小
cfg.setReadBufferSize(4096);
// 设置 session 空闲时间
cfg.setIdleTime(IdleStatus.BOTH_IDLE, 10);

// 设置 IO 句柄
acceptor.setHandler(new XxxHandler());
acceptor.setReuseAddress(true);

try {
    // 绑定端口
    acceptor.bind(new InetSocketAddress("127.0.0.1", 4400));
} catch (Exception ex) {
    // 输出错误日志
    System.error.println(ex);
}

目前 Netty 框架要比 MINA 流行的多，而且 Netty 对网络黏包处理也做了很好的处理，不用开发者自己费那么大劲。我也考虑过迁移到 Netty 框架上，不过目前还没有找到特别充分的理由。闲话不多说了，以下就是黏包处理代码：

package com.game.gameServer.framework.mina;

import java.util.concurrent.ConcurrentHashMap;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.filterchain.IoFilterAdapter;
import org.apache.mina.core.session.IoSession;

import com.game.gameServer.framework.FrameworkLog;
import com.game.gameServer.msg.SpecialMsgSerialUId;
import com.game.part.msg.IoBuffUtil;

/**
 * 消息粘包处理
 * 
 * @author hjj2017
 * @since 2014/3/17
 * 
 */
class MsgCumulativeFilter extends IoFilterAdapter {
    /** 
     * 从客户端接收的消息估计长度,
     * {@value} 字节, 
     * 对于从客户端接收的数据来说, 都是简单的命令! 
     * 很少超过 {@value}B
     * 
     */
    private static final int DECODE_MSG_LEN = 64;
    /** 容器 Buff 字典 */
    private static final ConcurrentHashMap<Long, IoBuffer> _containerBuffMap = new ConcurrentHashMap<>();

    @Override
    public void sessionClosed(NextFilter nextFilter, IoSession sessionObj) throws Exception {
        if (nextFilter == null || 
            sessionObj == null) {
            // 如果参数对象为空, 
            // 则直接退出!
            FrameworkLog.LOG.error("null nextFilter or sessionObj");
            return;
        }

        // 移除容器 Buff
        removeContainerBuff(sessionObj);
        // 向下传递
        super.sessionClosed(nextFilter, sessionObj);
    }

    @Override
    public void messageReceived(
        NextFilter nextFilter, IoSession sessionObj, Object msgObj) throws Exception {
        if (nextFilter == null || 
            sessionObj == null) {
            // 如果参数对象为空, 
            // 则直接退出!
            FrameworkLog.LOG.error("null nextFilter or sessionObj");
            return;
        }

        // 获取会话 UId
        long sessionUId = sessionObj.getId();

        if (!(msgObj instanceof IoBuffer)) {
            // 如果消息对象不是 ByteBuff, 
            // 则直接向下传递!
            FrameworkLog.LOG.warn("msgObj is not a IoBuff, sessionUId = " + sessionUId);
            super.messageReceived(nextFilter, sessionObj, msgObj);
        }

        // 获取输入 Buff
        IoBuffer inBuff = (IoBuffer)msgObj;

        if (!inBuff.hasRemaining()) {
            // 如果没有剩余内容, 
            // 则直接退出!
            FrameworkLog.LOG.error("inBuff has not remaining, sessionUId = " + sessionUId);
            return;
        } else if (inBuff.remaining() <= 8) {
            // 如果 <= 8 字节, 
            // 那还是执行粘包处理过程吧 ...
            // 8 字节 = 消息长度 ( Short ) + 消息类型 ( Short ) + 时间戳 ( Int )
            // 如果比这个长度都小, 
            // 那肯定不是一条完整消息 ...
            this.msgRecv_0(nextFilter, sessionObj, inBuff);
            return;
        }

        // 获取消息长度
        final int msgSize = inBuff.getShort();
        inBuff.position(0);

        if (msgSize == inBuff.limit() && 
            containerBuffIsEmpty(sessionObj)) {
            // 
            // 如果消息长度和极限值刚好相同, 
            // 并且容器 Buff 中没有任何内容 ( 即, 上一次消息没有粘包 ),
            // 那么直接向下传递!
            // 
            super.messageReceived(
                nextFilter, sessionObj, inBuff
            );
        } else {
            // 
            // 如果消息长度和极限值不同, 
            // 则说明是网络粘包!
            // 这时候跳转到粘包处理过程 ...
            // 
            this.msgRecv_0(nextFilter, sessionObj, inBuff);
        }
    }

    /**
     * 接收连包消息
     * 
     * @param nextFilter
     * @param sessionObj
     * @param inBuff
     * @throws Exception 
     * 
     */
    private void msgRecv_0(
        NextFilter nextFilter, IoSession sessionObj, IoBuffer inBuff) throws Exception {
        if (nextFilter == null || 
            sessionObj == null) {
            // 如果参数对象为空, 
            // 则直接退出!
            FrameworkLog.LOG.error("null nextFilter or sessionObj");
            return;
        }

        // 获取会话 UId
        long sessionUId = sessionObj.getId();
        // 获取容器 Buff
        IoBuffer containerBuff = getContainerBuff(sessionObj);

        // 添加新 Buff 到容器 Buff 的末尾
        IoBuffUtil.append(containerBuff, inBuff);
        // 令 position = 0
        containerBuff.position(0);

//        // 记录调试信息
//        FrameworkLog.LOG.debug("\nin = [ " + inBuff.getHexDump() + " ]");

        for (int i = 0; ; i++) {
//            // 记录调试信息
//            FrameworkLog.LOG.debug(
//                "i = " + i 
//                + "\nco = [ " + containerBuff.getHexDump() + " ]"
//                + "\nco.pos = " + containerBuff.position() 
//                + "\nco.lim = " + containerBuff.limit()
//            );

            if (containerBuff.remaining() < 4) {
                // 
                // 如果剩余字节数 < 4, 
                // 这样根本无法识别出消息类型 msgSerialUId ...
                // 直接退出!
                // 在退出前, 
                // 准备好接收下一次消息!
                // 
                IoBuffUtil.readyToNext(containerBuff);
                return;
            }

            // 获取原始位置
            final int oldPos = containerBuff.position();
            // 获取消息长度和类型
            final int msgSize = containerBuff.getShort();
            final int msgSerialUId = containerBuff.getShort();

//            // 记录调试信息
//            FrameworkLog.LOG.debug(
//                "i = " + i 
//                + "\nmsgSize = " + msgSize
//                + "\nmsgSerialUId = " + msgSerialUId
//            );

            // 还原原始位置
            containerBuff.position(oldPos);

            if (msgSerialUId == SpecialMsgSerialUId.CG_FLASH_POLICY || 
                msgSerialUId == SpecialMsgSerialUId.CG_QQ_TGW) {
                // 
                // 如果是 Flash 安全策略消息, 
                // 或者是腾讯网关消息, 
                // 则尝试找一下 0 字节的位置 ...
                // 
                int pos0 = IoBuffUtil.indexOf(containerBuff, (byte)0);

                if (pos0 <= -1) {
                    // 如果找不到 0 字节的位置, 
                    // 则说明消息还没接收完, 
                    // 准备接受下次消息并直接退出!
                    IoBuffUtil.readyToNext(containerBuff);
                    return;
                }

                // 复制 Buff 内容
                containerBuff.position(0);
                IoBuffer realBuff = IoBuffUtil.copy(containerBuff, pos0);

                // 更新 Buff 位置
                final int newPos = containerBuff.position() + pos0;
                containerBuff.position(newPos);
                // 压缩容器 Buff
                IoBuffUtil.compact(containerBuff);

                // 向下传递
                super.messageReceived(
                    nextFilter, sessionObj, realBuff
                );
                continue;
            }

            if (msgSize <= 0) {
                // 
                // 如果消息长度 <= 0, 
                // 则直接退出!
                // 这种情况可能是消息已经乱套了 ...
                // 还是重新来过吧!
                // 
                FrameworkLog.LOG.error("i = " + i + ", msgSize = " + msgSize + ", sessionUId = " + sessionUId);
                // 将容器 Buff 内容清空
                containerBuff.position(0);
                containerBuff.flip();
                // 压缩容器 Buff
                IoBuffUtil.compact(containerBuff);
                return;
            }

            if (containerBuff.remaining() < msgSize) {
                // 
                // 如果消息长度不够, 
                // 则可能是出现网络粘包情况了 ...
                // 直接退出就可以了!
                // 
                FrameworkLog.LOG.warn(
                    "i = " + i
                    + ", msgSize = " + msgSize 
                    + ", containerBuff.remaining = " + containerBuff.remaining()
                    + ", sessionUId = " + sessionUId
                );

                // 准备接受下一次消息
                IoBuffUtil.readyToNext(containerBuff);
                return;
            }

            // 创建新 Buff 并复制字节内容
            IoBuffer realBuff = IoBuffUtil.copy(containerBuff, msgSize);

            if (realBuff == null) {
                // 
                // 如果真实的 Buff 为空, 
                // 则直接退出!
                // 这种情况可能也是消息乱套了 ...
                // 记录一下错误信息
                // 
                FrameworkLog.LOG.error("i = " + i + ", null realBuff, sessionUId = " + sessionUId);
            } else {
//                // 记录调试信息
//                FrameworkLog.LOG.debug(
//                    "i = " + i
//                    + "\nreal = [ " + realBuff.getHexDump() + " ]"
//                    + "\nreal.pos = " + realBuff.position()
//                    + "\nreal.lim = " + realBuff.limit()
//                );

                // 向下传递
                super.messageReceived(
                    nextFilter, sessionObj, realBuff
                );
            }

            // 更新位置
            containerBuff.position(containerBuff.position() + msgSize);
            // 压缩容器 Buff
            IoBuffUtil.compact(containerBuff);
        }
    }
    
    /**
     * 获取玩家的 Buff, 如果为空则新建一个!
     * 
     * @param sessionObj
     * @return 
     * 
     */
    private static IoBuffer getContainerBuff(IoSession sessionObj) {
        if (sessionObj == null) {
            // 如果参数对象为空, 
            // 则直接退出!
            return null;
        }

        // 获取会话 UId
        long sessionUId = sessionObj.getId();
        // 获取容器 Buff
        IoBuffer containerBuff = _containerBuffMap.get(sessionUId);

        if (containerBuff == null) {
            // 创建缓存 Buff
            containerBuff = IoBuffer.allocate(DECODE_MSG_LEN);
            containerBuff.setAutoExpand(true);
            containerBuff.setAutoShrink(true);
            containerBuff.position(0);
            containerBuff.flip();
            // 缓存  Buff 对象
            Object oldVal = _containerBuffMap.putIfAbsent(sessionUId, containerBuff);

            if (oldVal != null) {
                FrameworkLog.LOG.warn("exists oldVal");
            }
        }

        return containerBuff;
    }

    /**
     * 移除容器 Buff
     * 
     * @param sessionObj
     * 
     */
    private static void removeContainerBuff(IoSession sessionObj) {
        if (sessionObj == null) {
            // 如果参数对象为空, 
            // 则直接退出!
            return;
        }

        // 获取会话 UId
        long sessionUId = sessionObj.getId();
        // 获取容器 Buff
        IoBuffer containerBuff = _containerBuffMap.get(sessionUId);

        if (containerBuff != null) {
            // 是否所占资源
            containerBuff.clear();
        }

        // 移除玩家的 Buff 对象
        _containerBuffMap.remove(sessionUId);
    }

    /**
     * 容器 Buff 为空 ?
     * 
     * @param sessionObj
     * @return 
     * 
     */
    private static boolean containerBuffIsEmpty(IoSession sessionObj) {
        if (sessionObj == null) {
            // 如果参数对象为空, 
            // 则直接退出!
            return false;
        }

        // 获取容器 Buff
        IoBuffer containerBuff = getContainerBuff(sessionObj);

        if (containerBuff == null) {
            // 如果容器为空, 
            // 则直接退出!
            FrameworkLog.LOG.error("null containerBuff, sessionUId = " + sessionObj.getId());
            return false;
        } else {
            // 如果当前位置和极限值都为 0, 
            // 则判定为空!
            return (containerBuff.position() == 0 
                 && containerBuff.limit() == 0);
        }
    }
}