Cobar源码解析（二）

摘要：如果数据库检测到是连续的，则表明没有串包，如果不连续，则表示串包，数据库会直接丢弃该连接。源码分析上一节我们分析到，当一个前端连接过来，并不是直接和绑定，而是先插入到线程的注册队列中这样能释放的压力处理更多前端连接。

这一节我们来讲Cobar Handshake的过程。

MySQL服务端和客户端交互的所有的包格式都是统一的，报文格式如下图：

MySQL报文的消息头共有4个字节，前3字节表示的是实际数据的长度(不包含消息头)，并且字节是按照小端模式排放的。

第四个字节MySQL为了防止串包用的，其原理是每收到一个报文，都在sequence id上加1。如果数据库检测到sequence id是连续的，则表明没有串包，如果不连续，则表示串包，数据库会直接丢弃该连接。

小端模式就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。

大端模式则相反。

下面是Handshake包的结构，括号内表示该字段的字节数：

seed部分是加密种子,分为前后两个部分，通过随机数生成。

上一节我们分析到，当一个前端连接过来，并不是直接和selector绑定，而是先插入到R线程的注册队列中,这样能释放NIOAcceptor的压力,处理更多前端连接。所以，连接和selector的绑定过程是在R线程中进行的，由register方法实现，代码如下：

private void register(Selector selector) {
            NIOConnection c = null;
            while ((c = registerQueue.poll()) != null) {
                try {
                    c.register(selector);
                } catch (Throwable e) {
                    c.error(ErrorCode.ERR_REGISTER, e);
                }
            }
        }

实际的绑定操作是由NIOConnection的register方法实现的，NIOConnection接口的抽象类是AbstractConnection，我们来看它实现的register方法：

@Override
    public void register(Selector selector) throws IOException {
        try {
            // 该连接只监听socket可读事件
            processKey = channel.register(selector, SelectionKey.OP_READ, this);
            isRegistered = true;
        } finally {
            if (isClosed.get()) {
                clearSelectionKey();
            }
        }
    }

我们发现，前端连接注册选择器时，只监听了可读事件。这是考虑到，Java的NIO属于水平触发LT（只要满足条件，就触发一个事件），使用水平触发时，如果应用程序不需要写就不要关注socket可写的事件，否则就会无限次地立即返回write ready notification，长期关注socket可写事件会出现CPU打满的情况，所以在使用JDK的NIO编程时，如果没有数据往外写，就取消写事件，有数据往外写时再注册写事件。

FrontendConnection继承了AbstractConnection，它又重新实现了register方法，代码如下：

@Override
    public void register(Selector selector) throws IOException {
        // 调用父类的register方法
        super.register(selector);
        if (!isClosed.get()) {
            // 生成认证数据
            byte[] rand1 = RandomUtil.randomBytes(8);
            byte[] rand2 = RandomUtil.randomBytes(12);

            // 保存认证数据
            byte[] seed = new byte[rand1.length + rand2.length];
            System.arraycopy(rand1, 0, seed, 0, rand1.length);
            System.arraycopy(rand2, 0, seed, rand1.length, rand2.length);
            this.seed = seed;

            // 发送握手数据包
            HandshakePacket hs = new HandshakePacket();
            hs.packetId = 0;
            hs.protocolVersion = Versions.PROTOCOL_VERSION;
            hs.serverVersion = Versions.SERVER_VERSION;
            hs.threadId = id;
            hs.seed = rand1;
            hs.serverCapabilities = getServerCapabilities();
            hs.serverCharsetIndex = (byte) (charsetIndex & 0xff);
            hs.serverStatus = 2;
            hs.restOfScrambleBuff = rand2;
            // 异步写入Handshake包
            hs.write(this);
        }
    }

该方法生成了HandShake包，和上面结构图相一致，关键是最后异步写入HandShake包的write方法，代码如下：

public void write(FrontendConnection c) {
        // 分配缓存
        ByteBuffer buffer = c.allocate();
        
        // 将HandShake包写入缓存
        BufferUtil.writeUB3(buffer, calcPacketSize());
        buffer.put(packetId);
        buffer.put(protocolVersion);
        BufferUtil.writeWithNull(buffer, serverVersion);
        BufferUtil.writeUB4(buffer, threadId);
        BufferUtil.writeWithNull(buffer, seed);
        BufferUtil.writeUB2(buffer, serverCapabilities);
        buffer.put(serverCharsetIndex);
        BufferUtil.writeUB2(buffer, serverStatus);
        buffer.put(FILLER_13);
        // buffer.position(buffer.position() + 13);
        BufferUtil.writeWithNull(buffer, restOfScrambleBuff);
        
        // 将ByteBuffer中的数据异步写入Socket
        c.write(buffer);
    }

我们再来看最后一行的write方法:

@Override
    public void write(ByteBuffer buffer) {
        // 检查连接是否关闭,若关闭则将缓存回收
        if (isClosed.get()) {
            processor.getBufferPool().recycle(buffer);
            return;
        }
        if (isRegistered) {
            try {
                // 将缓存先插入对队列中,其实就是一个循环数组,如数组已满,则 wait;
                // 这个队列是AbstractConnection的一个成员变量
                writeQueue.put(buffer);
            } catch (InterruptedException e) {
                error(ErrorCode.ERR_PUT_WRITE_QUEUE, e);
                return;
            }
            // 插入队列后，调用NIOProcessor的postWrite方法，其实就是NIOReacor的postWrite方法
            processor.postWrite(this);
        } else {
            // 若连接未注册,也回收缓存
            processor.getBufferPool().recycle(buffer);
            close();
        }
    }

我们看NIOReactor的postWrite方法：

final void postWrite(NIOConnection c) {
        reactorW.writeQueue.offer(c);
    }

其实是将连接插入到W线程的writeQueue阻塞队列中，我们再来看W线程的run方法,

@Override
        public void run() {
            NIOConnection c = null;
            for (;;) {
                try {
                    if ((c = writeQueue.take()) != null) {
                        write(c);
                    }
                } catch (Throwable e) {
                    LOGGER.warn(name, e);
                }
            }
        }
        
private void write(NIOConnection c) {
            try {
                c.writeByQueue();
            } catch (Throwable e) {
                c.error(ErrorCode.ERR_WRITE_BY_QUEUE, e);
            }
        }

轮询阻塞队列，若队列不为空，则取出连接，基于队列写方法writeByQueue将缓存中的数据写入socket，下一节再分析writeByQueue方法。

阅读源码后，发现Cobar从前端连接的accept并注册selector到发送Handshake包都是异步，本质是将连接插入到R线程和W线程的阻塞队列中，不立即进行注册和写操作，从而实现整个过程的异步化，提高了Cobar的吞吐量。

以上。

https://segmentfault.com/a/11...