网络篇 - netty实现高并发安全聊天客户端

网络篇的这几篇文章都在谈理论,这篇文章我将带大家来分析一个实战例子:基于 netty 的高并发安全聊天客户端。这是我工作中的一个项目,这篇文章将带大家了解 IM 的实现逻辑。

 

目录:

  1. netty 介绍
  2. 数据库设计
  3. 聊天的 JNI 封包解包
  4. 长连接的实现
  5. 消息异常处理

 

 

1. netty 介绍

 

  • 1.1 简介

Netty 是一个高性能、异步事件驱动的 NIO 框架,它提供了对 TCP、UDP 和文件传输的支持。作为一个异步 NIO 框架,Netty 的全部 IO 操作都是异步非堵塞的,通过 Future-Listener 机制,用户能够方便的主动获取或者通过通知机制获得 IO 操作结果。

作为当前最流行的 NIO 框架。Netty 在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用,一些业界著名的开源组件也基于 Netty 的 NIO 框架构建。

 

  • 1.2 传统 RPC 调用性能差的三宗罪

网络传输方式问题:传统的 RPC 框架或者基于 RMI 等方式的远程服务(过程)调用采用了同步堵塞 IO。当 client 的并发压力或者网络时延增大之后,同步堵塞 IO 会因为频繁的 wait 导致 IO 线程经常性的堵塞。因为线程无法高效的工作,IO 处理能力自然下降。

采用 BIO 通信模型的服务端,通常由一个独立的 Acceptor 线程负责监听 client 的连接。接收到 client 连接之后为 client 连接创建一个新的线程处理请求消息,处理完毕之后,返回应答消息给 client,线程销毁,这就是典型的一请求一应答模型。该架构最大的问题就是不具备弹性伸缩能力,当并发访问量添加后,服务端的线程个数和并发访问数成线性正比,因为线程是 Java 虚拟机很宝贵的系统资源,当线程数膨胀之后,系统的性能急剧下降。随着并发量的继续添加,可能会发生句柄溢出、线程堆栈溢出等问题,并导致 server 宕机。

序列化方式问题:Java 序列化存在例如以下几个典型问题:

  • 1. Java 序列化机制是 Java 内部的一种对象编解码技术,无法跨语言使用。比如对于异构系统之间的对接,Java 序列化后的码流须要可以通过其他语言反序列化成原始对象,眼下非常难支持。
  • 2. 相比于其他开源的序列化框架,Java 序列化后的码流太大,不管是网络传输还是持久化到磁盘,都会导致额外的资源占用。
  • 3. 序列化性能差(CPU 资源占用高)。

线程模型问题:因为采用同步堵塞 IO,这会导致每一个 TCP 连接都占用1个线程,因为线程资源是 JVM 虚拟机很宝贵的资源,当 IO 读写堵塞导致线程无法及时释放时,会导致系统性能急剧下降,严重的甚至会导致虚拟机无法创建新的线程。

 

  • 1.3  Netty 高性能之道

(1)  异步非堵塞通信

在 IO 编程过程中,当须要同一时候处理多个 client 接入请求时,能够利用多线程或者 IO 多路复用技术进行处理。IO 多路复用技术通过把多个 IO 的堵塞复用到同一个 select 的堵塞上,从而使得系统在单线程的情况下能够同一时候处理多个 client 请求。

与传统的多线程/多进程模型比,I/O 多路复用的最大优势是系统开销小。系统不须要创建新的额外进程或者线程,也不须要维护这些进程和线程的执行,减少了系统的维护工作量,节省了系统资源。JDK1.4 提供了对非堵塞IO(NIO)的支持。JDK1.5_update10 版本使用 epoll 替代了传统的 select/poll,极大的提升了 NIO 通信的性能。

Netty 采用了异步通信模式,一个 IO 线程能够并发处理N个 client 连接和读写操作,这从根本上攻克了传统同步堵塞 IO 一连接一线程模型,架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。

(2) 零拷贝

Netty 的零拷贝主要体如今例如以下三个方面:

  • 1. Netty 的接收和发送 ByteBuffer 采用 DIRECT BUFFERS,使用堆外直接内存进行 Socket 读写,不需要进行字节缓冲区的二次拷贝。假设使用传统的堆内存(HEAP BUFFERS)进行 Socket 读写,JVM 会将堆内存 Buffer 拷贝一份到直接内存中,然后才写入 Socket 中。相比于堆外直接内存,消息在发送过程中多了一次缓冲区的内存拷贝。
  • 2. Netty 提供了组合 Buffer 对象,能够聚合多个 ByteBuffer 对象,用户能够像操作一个 Buffer 那样方便的对组合 Buffer 进行操作,避免了传统通过内存拷贝的方式将几个小 Buffer 合并成一个大的 Buffer。
  • 3. Netty 的文件传输採用了 transferTo 方法,它能够直接将文件缓冲区的数据发送到目标 Channel,避免了传统通过循环write 方式导致的内存拷贝问题。

(3) 内存池

随着 JVM 虚拟机和 JIT 即时编译技术的发展,对象的分配和回收是个很轻量级的工作。可是对于缓冲区 Buffer,情况却少有不同,特别是对于堆外直接内存的分配和回收,是一件耗时的操作。为了尽量重用缓冲区,Netty 提供了基于内存池的缓冲区重用机制。

 

 

2. 数据库设计

接下来看看客户端消息相关的数据库设计。

会话表:

  • sessionKey    会话key,由服务器返回
  • peerId    用户聊天id
  • peerType    单聊,群聊标识
  • unreadNum    未读消息数
  • lastMsgType    最后一条消息的类型
  • lastMsgId    最后一条消息的id
  • lastMsgData    最后一条消息的数据
  • updateTime    会话更新时间戳
  • talkId    对话id
     

消息表:

  • id    消息数据库id
  • msgId    消息id(服务器)
  • fromId    消息来源用户id
  • toId    消息送达用户id
  • content    消息内容
  • displayType    消息显示类型
  • category    消息分类
  • media    消息附带数据
  • lg    经度
  • la    纬度
  • time    消息时间
  • status    消息状态
  • sessionKey    消息会话key,属于哪个会话
     

群组表:

  • peerId    群组id
  • mainName    群组名称
  • avatar    群组头像 
  • userNums    用户数
  • userIds    用户id列表
  • creatorId    群主id
     

用户表:

  • peerId    用户id
  • mainName    用户昵称
  • avatar    用户头像
  • gender    性别
  • realName    真实姓名
  • pinyinName    昵称的拼音
  • phone    用户手机号
  • email    用户邮箱
     

 

 

3. 聊天的 JNI 封包解包

 

  • 3.1 Java 层

Java 层通过该类进行封包解包的数据传输。

public final class GdpPack implements NoProGuard, Serializable {

    private int len;
    private short seq;
    private int opCode;
    private int bodyLen;

    private byte messageType;

    private String bodyBuffer;

    private byte[] buffer;

    static {
        loadLibrary("ucgpac");
    }

    public GdpPack() {
    }

    public GdpPack(int len) {
        this.len = len;
    }

    public GdpPack(short seq, int opCode, String bodyBuffer) {
        this.seq = seq;
        this.opCode = opCode;
        this.bodyBuffer = bodyBuffer;
        this.bodyLen = bodyBuffer.length();
        // 在默认情况下,messageType是请求
        this.messageType = 1;
    }

    public GdpPack(short seq, int opCode, byte messageType, String bodyBuffer) {
        this.seq = seq;
        this.opCode = opCode;
        this.messageType = messageType;
        this.bodyBuffer = bodyBuffer;
        this.bodyLen = bodyBuffer.length();
    }

    public void parse(byte[] buffer, byte[] randomKey) {
        if (buffer != null && randomKey != null) {
            parse(buffer, randomKey, this);
        }
    }

    public byte[] fill(byte[] randomKey) {
        return randomKey != null ? fill(randomKey, this) : null;
    }

    private native void parse(byte[] buffer, byte[] randomKey, GdpPack gdpPack);

    private native byte[] fill(byte[] randomKey, GdpPack gdpPack);

    get/set functions ...
}

变量说明:

  • len: 数据长度。
  • seq: 本地请求返回标识码。
  • opCode: 与服务器交互标识码。
  • bodyLen: 数据 body 长度。
  • messageType: 消息类型。
  • bodyBuffer: 数据 body 字符串。
  • buffer: 数据 body 字节流数组。

JNI 函数:

private native void parse(byte[] buffer, byte[] randomKey, GdpPack gdpPack);

将 buffer 字节数据和 randomKey 解析并填充到 GdpPack 对象。

private native byte[] fill(byte[] randomKey, GdpPack gdpPack);

将 randomKey 填充到 GdpPack 对象。

 

  • 3.2 JNI 函数
extern "C" {
    JNIEXPORT void JNICALL Java_waterhole_im_GdpPack_parse(JNIEnv *env, jobject jobj, jbyteArray buffer, jbyteArray randomKey, jobject gdpPack) {
        GdpPack * pack = new GdpPack();
        char * tmpBuffer = jByteArray2chars(env, buffer);
        char * tmpRandom = jByteArray2chars(env, randomKey);
        pack->parse(tmpBuffer, tmpRandom);
        delete tmpBuffer;
        delete tmpRandom;

        jclass cls = env->FindClass("waterhole/im/GdpPack");
        jfieldID bodyBufferF = env->GetFieldID(cls, "bodyBuffer", "Ljava/lang/String;");
        char * resTemp = new char[pack->getBodyLen() * sizeof(char)];
        memset(resTemp, 0x00, pack->getBodyLen() * sizeof(char));
        memcpy(resTemp, pack->getBodyBuffer(), pack->getBodyLen());
        env->SetObjectField(gdpPack, bodyBufferF, string2Jstring(env, resTemp));
        delete resTemp;

        jfieldID bodyLenF = env->GetFieldID(cls, "bodyLen", "I");
        env->SetIntField(gdpPack, bodyLenF, pack->getBodyLen());

        jfieldID seqF = env->GetFieldID(cls, "seq", "S");
        env->SetShortField(gdpPack, seqF, pack->getSeq());

        jfieldID opCodeF = env->GetFieldID(cls, "opCode", "I");
        env->SetIntField(gdpPack, opCodeF, pack->getOpCode());

        env->DeleteLocalRef(cls);
        //delete pack;
    }

    JNIEXPORT jbyteArray JNICALL Java_waterhole_im_GdpPack_fill(JNIEnv *env, jobject jobc, jbyteArray randomKey, jobject gdpPack) {
        jclass cls = env->FindClass("waterhole/im/GdpPack");
        jfieldID bodyBufferF = env->GetFieldID(cls, "bodyBuffer", "Ljava/lang/String;");

        char* bodyBuffer = jstring2String(env, (jstring) env->GetObjectField(gdpPack, bodyBufferF));
        jfieldID seqF = env->GetFieldID(cls, "seq", "S");

        short seq = env->GetShortField(gdpPack, seqF);
        jfieldID opCodeF = env->GetFieldID(cls, "opCode", "I");
        int opCode = env->GetIntField(gdpPack, opCodeF);
        jfieldID msgTypeF = env->GetFieldID(cls, "messageType", "B");
        char msgType = env->GetByteField(gdpPack, msgTypeF);

        GdpPack * pack = new GdpPack(seq, opCode, msgType, bodyBuffer, strlen(bodyBuffer));
        char * tmpRandom = jByteArray2chars(env, randomKey);
        char * resStr = pack->fill(tmpRandom);
        delete bodyBuffer;
        delete tmpRandom;

        jbyteArray ret = chars2jByteArray(env, resStr, pack->getLen());

        env->DeleteLocalRef(cls);
        //delete pack;

        return ret;
    }
}

JNI 设置对象参数,核心在于 parse() 和 fill()  实现:

void GdpPack::parse(char * buffer, char * key)
{
	_buffer = buffer;
	_len = readInt(_buffer);

	_stackVersion = readShort(_buffer + 8);
	_encryptType = readChar(_buffer + 10);
	_compressType = readChar(_buffer + 11);
	_messageType = readChar(_buffer + 12);
	_seq = readShort(_buffer + 13);
	_bodyFormat = readChar(_buffer + 15);;
	_bodyModelVersion = readShort(_buffer + 16);
	_time = readLong(_buffer + 18);
	_statusCode = readShort(_buffer + 26);
	_opCode = readInt(_buffer + 28);
	_bodyLen = readInt(_buffer + 32);

	if(_bodyLen > 0)
		_bodyBuffer = readChars(_buffer + 36, _bodyLen);

	if(_encryptType > 0)
	{
	   decrypt(_bodyBuffer, _bodyLen, key);
    }
}

char* GdpPack::fill(char * key)
{
	_buffer = new char[_len + 4];//85
	memset(_buffer, 0x00, _len+4);
	writeInt(_len, _buffer);
	writeChars(_label, _buffer + 4, 4);
        
	writeShort(_stackVersion, _buffer + 8);
	writeChar(_encryptType, _buffer + 10);
	
	writeChar(_compressType, _buffer + 11);
	writeChar(_messageType, _buffer + 12);
	writeShort(_seq, _buffer + 13);
	writeChar(_bodyFormat, _buffer + 15);
	writeShort(_bodyModelVersion, _buffer + 16);
	writeLong(_time, _buffer + 18);
	writeShort(_statusCode, _buffer + 26);
	writeInt(_opCode, _buffer + 28);
	writeInt(_bodyLen, _buffer + 32);

	if(_encryptType > 0)
	{
		encrypt(_bodyBuffer, _bodyLen, key);
	}

	writeChars(_bodyBuffer, _buffer + 36, _bodyLen);
	return _buffer;
}

就是将字节按位取参数,加密和解密封装成 GdpPack 对象,这边的 bodyBuffer 做了数据加密,加解密算法这边就不说了。这一层也保证了数据安全,位于表示层。

 

 

 

4. 长连接的实现

这边只讲讲连接的实现逻辑。

 

  • 4.1 封包和解包

数据封包:

public final class GdpPackageEncoder extends OneToOneEncoder {

    private static final String TAG = "GdpPackageEncoder";

    private final SocketManager mSocketManager = SocketManager.instance();

    @Override
    protected Object encode(ChannelHandlerContext channelHandlerContext, Channel channel, Object o)
            throws Exception {
        if (!(o instanceof GdpPack)) {
            return o;
        }

        final GdpPack packet = (GdpPack) o;
        final ChannelBuffer buffer;

        // 在确定总长度前,如果body为空则总长度设置为0不再发送后续协议头部
        if (packet.getBodyBuffer() == null || packet.getBodyBuffer().length() == 0) {
            buffer = wrappedBuffer(new byte[]{0, 0, 0, 0});
        } else {
            buffer = wrappedBuffer(packet.fill(mSocketManager.getRandomKey()));
        }

        // e是为了日志醒目
        error(TAG,
                "@GdpPackageEncoder " + packet.getBodyBuffer() + "-OpCode:" + packet.getOpCode());
        return buffer;
    }
}

调用 JNI 填充方法。

 

数据解包:

public final class GdpPackageDecoder extends FrameDecoder {

    private static final String TAG = "GdpPackageDecoder";

    // 跳过的字节长度
    private static final short DECODER_SKIP_LEN = 4;
    // RandomKey的字节长度
    private static final short DECODER_RANDOM_KEY_LEN = 36;
    // GdpPack包最小字节长度
    private static final short DECODER_MIN_PACKET_LEN = 32;

    @Override
    protected Object decode(ChannelHandlerContext channelHandlerContext, Channel channel,
                            ChannelBuffer channelBuffer) throws Exception {
        try {
            info(TAG, "Decode just in len:" + channelBuffer.readableBytes());
            // 错误的信息
            if (channelBuffer.readableBytes() < DECODER_SKIP_LEN) {
                return null;
            }
            final int totalLen = channelBuffer.getInt(channelBuffer.readerIndex());
            // 还没有解码成完整的包
            if (channelBuffer.readableBytes() < totalLen + DECODER_SKIP_LEN) {
                return null;
            }

            switch (totalLen) {
                case 0:
                    // 是否是心跳包或randomKey包
                    readHeartbeat(channelBuffer);
                    return null;
                case DECODER_RANDOM_KEY_LEN:
                    // Random Key String
                    channelBuffer.readInt();
                    byte[] randomKeyBytes = new byte[DECODER_RANDOM_KEY_LEN];
                    channelBuffer.readBytes(randomKeyBytes);
                    error(TAG, "decoder RandomKey:" + new String(randomKeyBytes));
                    // 保存本次的randomKey
                    mSocketManager.setRandomKey(randomKeyBytes);
                    mSocketManager.setRandomNumber(GdpPack.auth(randomKeyBytes, randomKeyBytes.length));
                    // 更新session状态,抛给上层去处理
                    EventBus.getDefault().post(POST_UPDATE_SESSION);
                    return null;
                default:
                    break;
            }

            // 最终拿到的是完整的GdpPack包,将数据通过jni拼装成GdpPack对象
            return isTokenUnsafely(channelBuffer, totalLen) ? null : assemeGdpPack(channelBuffer, totalLen);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 为了保障token的安全  在连接成功后 会发送一些混淆包
     * 这些包的长度会小于 DECODER_MIN_PACKET_LEN ,而且不等于 DECODER_RANDOM_KEY_LEN
     * 对这些包不用进行任何的处理
     */
    private boolean isTokenUnsafely(ChannelBuffer channelBuffer, int totalLen) {
        if (totalLen <= DECODER_MIN_PACKET_LEN) {
            channelBuffer.readInt();
            channelBuffer.readBytes(totalLen);
            return true;
        }
        return false;
    }

    private final SocketManager mSocketManager = SocketManager.instance();

    @NonNull
    private GdpPack assemeGdpPack(ChannelBuffer channelBuffer, int totalLen) {
        GdpPack packet = new GdpPack();
        byte[] bufferBytes = new byte[totalLen + DECODER_SKIP_LEN];
        channelBuffer.readBytes(bufferBytes);
        packet.parse(bufferBytes, mSocketManager.getRandomKey());

        /**
         * Below is a patch
         * In certain occasion,the json string returned from server is followed by
         * few strange characters.not find the solution so add this patch to prevent
         * that from happening
         */
        if (packet.getBodyLen() != packet.getBodyBuffer().length()) {
            packet.setBodyBuffer(packet.getBodyBuffer().substring(0, packet.getBodyLen()));
        }
        error(TAG, "@GdpPackageDecoder:" + packet.getBodyBuffer() + "-opCode:" + packet.getOpCode());
        return packet;
    }

    /**
     * 数据读完后,判断是不是心跳包或返回randomKey的包
     * 如果是心跳包,则将心跳包的回调从队列中移除掉,如果是randomKey的包,保存这次的randomKey,
     * 并且拿这个randomKey是服务器刷新session,session 刷新成功后才是有效的连接
     *
     * @see #readHeartbeat(ChannelBuffer)
     */
    private void readHeartbeat(ChannelBuffer channelBuffer) {
        // Heart beat
        channelBuffer.readInt();
        // 异常心跳包回调
        mSocketManager.popHeartbeat(0);
    }
}

解析数据包,分为无效包、心跳包、randomKey 包、消息收发数据包的解析填充。

 

4.2 连接

public final class SocketThread extends Thread {

    private static final String TAG = "SocketThread";

    private ClientBootstrap mClientBootstrap = null;
    private ChannelFuture mChannelFuture = null;
    private Channel mChannel = null;

    private String mStrHost;
    private final int mPort;

    private final SocketManager mSocketManager = SocketManager.instance();

    public SocketThread(String strHost, int nPort, SimpleChannelUpstreamHandler handler) {
        mStrHost = strHost;
        mPort = nPort;

        init(handler);
    }

    @Override
    public void run() {
        doConnect();
    }

    private void init(final SimpleChannelUpstreamHandler handler) {
        try {
            // only one IO thread
            ChannelFactory channelFactory = new NioClientSocketChannelFactory(
                    newCachedThreadPool(), newCachedThreadPool());
            mClientBootstrap = new ClientBootstrap(channelFactory);
            mClientBootstrap.setOption("connectTimeoutMillis", CONNECT_TIMEOUT);
            mClientBootstrap.setPipelineFactory(new ChannelPipelineFactory() {

                public ChannelPipeline getPipeline() throws Exception {
                    ChannelPipeline pipeline = Channels.pipeline();
                    SSLEngine engine = getClientContext().createSSLEngine();
                    engine.setUseClientMode(true);
                    SslHandler sslHandler = new SslHandler(engine, getDefaultBufferPool(),
                            false, new HashedWheelTimer(), HAND_SHAKE_TIMEOUT);
                    sslHandler.setCloseOnSSLException(true);
                    pipeline.addFirst("tls", sslHandler);
                    pipeline.addLast("decoder", new GdpPackageDecoder());
                    pipeline.addLast("encoder", new GdpPackageEncoder());
                    pipeline.addLast("handler", handler);
                    return pipeline;
                }
            });

            mClientBootstrap.setOption("tcpNoDelay", true);
            mClientBootstrap.setOption("keepAlive", true);
        } catch (OutOfMemoryError e) {
            mSocketManager.onMsgServerDisconnect();
            System.gc();
        } catch (ChannelException e) {
            mSocketManager.onMsgServerDisconnect();
        }
    }

    private boolean doConnect() {
        if (mClientBootstrap == null) {
            mSocketManager.onMsgServerDisconnect();
            return false;
        }
        // 优先IPV4,因为IPV6在一些机器上有问题
        try {
            for (InetAddress addr : InetAddress.getAllByName(mStrHost)) {
                if (addr instanceof Inet4Address) {
                    mStrHost = addr.getHostAddress();
                    break;
                }
            }
        } catch (UnknownHostException e) {
            error(TAG, e.getMessage());
        }

        mClientBootstrap.setOption("remoteAddress", new InetSocketAddress(mStrHost, mPort));

        try {
            InetSocketAddress address;
            if ((null == mChannel || !mChannel.isConnected()) && null != mStrHost && mPort > 0) {
                // Start the connection attempt
                address = mClientBootstrap == null ? null : (InetSocketAddress)
                        mClientBootstrap.getOption("remoteAddress");
                mChannelFuture = mClientBootstrap.connect(address);

                // Wait until the connection attempt succeeds or fails
                mChannel = mChannelFuture.awaitUninterruptibly().getChannel();
                if (!mChannelFuture.isSuccess()) {
                    mClientBootstrap.releaseExternalResources();
                    mSocketManager.onMsgServerDisconnect();
                    return false;
                }
            }

            if (this.mChannel != null && this.mChannel.isConnected()) {
                mSocketManager.initSocketSuccess();
            } else {
                mSocketManager.onMsgServerDisconnect();
            }

            // Wait until the connection is closed or the connection attemp fails
            mChannelFuture.getChannel().getCloseFuture().awaitUninterruptibly();
            mClientBootstrap.releaseExternalResources();
            return true;
        } catch (Throwable e) {
            // 交换域名备用
            swapServerAddress();
            mSocketManager.onMsgServerDisconnect();
            return false;
        }
    }

    public void close() {
        if (mChannelFuture != null) {
            try {
                if (mChannelFuture.getChannel() != null) {
                    mChannelFuture.getChannel().close();
                }
                mChannelFuture.cancel();
            } catch (Exception e) {
                error(TAG, e.getMessage());
            }
        }
    }

    @Deprecated
    public boolean isClose() {
        return mChannelFuture == null || mChannelFuture.getChannel() == null ||
                !mChannelFuture.getChannel().isConnected() ||
                !mChannelFuture.getChannel().isWritable();
    }

    public boolean sendReqPacket(GdpPack gdpPack) {
        if (mChannelFuture != null && null != mChannelFuture.getChannel()) {
            Channel currentChannel = mChannelFuture.getChannel();
            if (!(currentChannel.isWritable() && currentChannel.isConnected())) {
                mSocketManager.onMsgServerDisconnect();
                return false;
            }
            mChannelFuture.getChannel().write(gdpPack);
            return true;
        } else {
            return false;
        }
    }
}

这个就是连接的核心代码,一个线程就能维护整个长连接,进行包的收发。里面涉及到连接,SSL 配置。

 

  • 4.3 连接 handler
public final class IMClientHandler extends SimpleChannelUpstreamHandler {

    // 上下文对象
    private final Context mContext = ContextWrapper.getInstance().obtainContext();

    @Override
    public void channelConnected(final ChannelHandlerContext ctx, final ChannelStateEvent e) throws Exception {
        info(TAG, "channelConnected");
        SslHandler sslHandler = ctx.getPipeline().get(SslHandler.class);
        sslHandler.handshake().addListener(new ChannelFutureListener() {
            public void operationComplete(ChannelFuture future) throws Exception {
                info(TAG, "future.isSuccess():" + future.isSuccess());
                if (!future.isSuccess()) {
                    swapServerAddress();
                    // java.util.concurrent.RejectedExecutionException: Worker has already been shutdown
                    try {
                        future.getChannel().close();
                    } catch (Exception e1) {
                        SocketManager.instance().onMsgServerDisconnect();
                    }
                } else {
                    SocketManager.instance().onMsgServerConnected();
                }
            }
        });
    }

    @Override
    public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
        super.channelDisconnected(ctx, e);
        info(TAG, "channelDisconnected");
        SocketManager.instance().onMsgServerDisconnect();
        HeartBeatManager.instance().onMsgServerDisconnect();
        ConnectManager.instance().onMsgServerDisconnect();
    }

    @Override
    public void messageReceived(ChannelHandlerContext ctx, final MessageEvent e) throws Exception {
        final GdpPack pack = (GdpPack) e.getMessage();
        if (pack != null) {
            AsyncTaskAssistant.executeOnThreadPool(new Runnable() {
                @Override
                public void run() {
                    try {
                        SocketManager.instance().packetDispatch(pack);
                    } catch (Exception e1) {
                        error(TAG, e1.getMessage());
                    }
                }
            });
        }
    }

    @Override
    public void exceptionCaught(final ChannelHandlerContext ctx, ExceptionEvent e) {
        try {
            super.exceptionCaught(ctx, e);
            if (e != null) {
                Throwable throwable = e.getCause();
                if (throwable != null) {
                    final String errorMsg = throwable.getMessage();
                    if (!TextUtils.isEmpty(errorMsg)) {
                        error(TAG, errorMsg);
                        MobclickAgent.reportError(mContext, errorMsg);
                        if (errorMsg.contains("timed out")) {
                            swapServerAddress();
                        }
                    }
                }
                // 异常时手动关闭channel, @see http://netty.io/3.8/guide/
                if (e.getChannel() != null) {
                    e.getChannel().close();
                }
            }
        } catch (Exception e1) {
            error(TAG, e1.getMessage());
        }
    }
}

连接成功、连接断开、连接异常和收到消息的回调。这边因为使用了 SSL 加密,所以必须判断握手成功再刷新 Session,此时才是真正连接成功,能进行消息收发。

 

 

 

5. 消息异常处理

 

  • (1) 如果使用过程中,由于网络原因连接断开,那么消息列表如何处理呢?

当重新连接成功后,这个聊天对话可能在服务器堆积了大量的未读消息,此时应该用本地存储的最后一条消息 id,去服务器获取未读。因为聊天都会滑动到最新的消息,所以先去获取最新的20条消息。拉取成功后插入数据库,然后显示给用户,同时显示所有未读消息数。当用户下拉旧的消息时,从数据库获取之前的消息,如果之前的消息 id 存在断层,则从服务器获取并插入显示,如果没有,则直接用数据库的记录显示。

 

  • (2) 如果发送过程中,由于网络问题,堆积了很多未发送消息,如何保证重发后的显示顺序?

客户端这边是以服务器最终确定成功的消息 id 作为排序,所以如果之前发送失败的消息,即使客户端发送时间再早,最后都会以服务器接收成功的时间为准 (服务接收成功会给一个唯一的消息 id,按顺序排列)。

 

 

 

发布了125 篇原创文章 · 获赞 211 · 访问量 6万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 像素格子 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览