远程通讯——Mina

目标：介绍基于Mina的来实现的远程通信、介绍dubbo-remoting-mina内的源码解析。

前言

Apache MINA是一个网络应用程序框架，可帮助用户轻松开发高性能和高可扩展性的网络应用程序。它通过Java NIO在各种传输（如TCP / IP和UDP / IP）上提供抽象的事件驱动异步API。它通常被称为NIO框架库、客户端服务器框架库或者网络套接字库。那么本问就要讲解在dubbo项目中，基于mina的API实现服务端和客户端来完成远程通讯这件事情。

下面是mina实现的包结构：

源码分析

（一）MinaChannel

该类继承了AbstractChannel，是基于mina实现的通道。

1.属性

private static final Logger logger = LoggerFactory.getLogger(MinaChannel.class);

/**
 * 通道的key
 */
private static final String CHANNEL_KEY = MinaChannel.class.getName() + ".CHANNEL";

/**
 * mina中的一个句柄，表示两个端点之间的连接，与传输类型无关
 */
private final IoSession session;

该类的属性除了封装了一个CHANNEL_KEY以外，还用到了mina中的IoSession，它封装着一个连接所需要的方法，比如获得远程地址等。

2.getOrAddChannel

static MinaChannel getOrAddChannel(IoSession session, URL url, ChannelHandler handler) {
    // 如果连接session为空，则返回空
    if (session == null) {
        return null;
    }
    // 获得MinaChannel实例
    MinaChannel ret = (MinaChannel) session.getAttribute(CHANNEL_KEY);
    // 如果不存在，则创建
    if (ret == null) {
        // 创建一个MinaChannel实例
        ret = new MinaChannel(session, url, handler);
        // 如果两个端点连接
        if (session.isConnected()) {
            // 把新创建的MinaChannel添加到session 中
            MinaChannel old = (MinaChannel) session.setAttribute(CHANNEL_KEY, ret);
            // 如果属性的旧值不为空，则重新设置旧值
            if (old != null) {
                session.setAttribute(CHANNEL_KEY, old);
                ret = old;
            }
        }
    }
    return ret;
}

该方法是一个获得MinaChannel对象的方法，其中每一个MinaChannel都会被放在session的属性值中。

3.removeChannelIfDisconnected

static void removeChannelIfDisconnected(IoSession session) {
    if (session != null && !session.isConnected()) {
        session.removeAttribute(CHANNEL_KEY);
    }
}

该方法是当没有连接时移除该通道，比较简单。

4.send

@Override
public void send(Object message, boolean sent) throws RemotingException {
    super.send(message, sent);

    boolean success = true;
    int timeout = 0;
    try {
        // 发送消息，返回future
        WriteFuture future = session.write(message);
        // 如果已经发送过了
        if (sent) {
            // 获得延迟时间
            timeout = getUrl().getPositiveParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
            // 等待timeout的连接时间后查看是否发送成功
            success = future.join(timeout);
        }
    } catch (Throwable e) {
        throw new RemotingException(this, "Failed to send message " + message + " to " + getRemoteAddress() + ", cause: " + e.getMessage(), e);
    }

    if (!success) {
        throw new RemotingException(this, "Failed to send message " + message + " to " + getRemoteAddress()
                + "in timeout(" + timeout + "ms) limit");
    }
}

该方法是最关键的发送消息，其中调用到了session的write方法，就是mina封装的发送消息。并且根据返回的WriteFuture对象来判断是否发送成功。

（二）MinaHandler

该类继承了IoHandlerAdapter，是通道处理器实现类，其中就是mina项目中IoHandler接口的几个 方法。

/**
 * url对象
 */
private final URL url;

/**
 * 通道处理器对象
 */
private final ChannelHandler handler;

该类有两个属性，上述提到的实现IoHandler接口方法都是调用了handler来实现的，我就举例讲一个，其他的都一样的写法：

@Override
public void sessionOpened(IoSession session) throws Exception {
    // 获得MinaChannel对象
    MinaChannel channel = MinaChannel.getOrAddChannel(session, url, handler);
    try {
        // 调用接连该通道
        handler.connected(channel);
    } finally {
        // 如果没有连接则移除通道
        MinaChannel.removeChannelIfDisconnected(session);
    }
}

该方法在IoHandler中叫做sessionOpened，其实就是连接方法，所以调用的是handler.connected。其他方法也一样，请自行查看。

（三）MinaClient

该类继承了AbstractClient类，是基于mina实现的客户端类。

1.属性

/**
 * 套接字连接集合
 */
private static final Map<String, SocketConnector> connectors = new ConcurrentHashMap<String, SocketConnector>();

/**
 * 连接的key
 */
private String connectorKey;
/**
 * 套接字连接者
 */
private SocketConnector connector;

/**
 * 一个句柄
 */
private volatile IoSession session; // volatile, please copy reference to use

该类中的属性都跟mina项目中封装类有关系。

2.doOpen

@Override
protected void doOpen() throws Throwable {
    // 用url来作为key
    connectorKey = getUrl().toFullString();
    // 先从集合中取套接字连接
    SocketConnector c = connectors.get(connectorKey);
    if (c != null) {
        connector = c;
        // 如果为空
    } else {
        // set thread pool. 设置线程池
        connector = new SocketConnector(Constants.DEFAULT_IO_THREADS,
                Executors.newCachedThreadPool(new NamedThreadFactory("MinaClientWorker", true)));
        // config 获得套接字连接配置
        SocketConnectorConfig cfg = (SocketConnectorConfig) connector.getDefaultConfig();
        cfg.setThreadModel(ThreadModel.MANUAL);
        // 启用TCP_NODELAY
        cfg.getSessionConfig().setTcpNoDelay(true);
        // 启用SO_KEEPALIVE
        cfg.getSessionConfig().setKeepAlive(true);
        int timeout = getConnectTimeout();
        // 设置连接超时时间
        cfg.setConnectTimeout(timeout < 1000 ? 1 : timeout / 1000);
        // set codec.
        // 设置编解码器
        connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new MinaCodecAdapter(getCodec(), getUrl(), this)));
        // 加入集合
        connectors.put(connectorKey, connector);
    }
}

该方法是打开客户端，在mina中用套接字连接者connector来表示。其中的操作就是新建一个connector，并且设置相应的属性，然后加入集合。

3.doConnect

@Override
protected void doConnect() throws Throwable {
    // 连接服务器
    ConnectFuture future = connector.connect(getConnectAddress(), new MinaHandler(getUrl(), this));
    long start = System.currentTimeMillis();
    final AtomicReference<Throwable> exception = new AtomicReference<Throwable>();
    // 用于对线程的阻塞和唤醒
    final CountDownLatch finish = new CountDownLatch(1); // resolve future.awaitUninterruptibly() dead lock
    // 加入监听器
    future.addListener(new IoFutureListener() {
        @Override
        public void operationComplete(IoFuture future) {
            try {
                // 如果已经读完了
                if (future.isReady()) {
                    // 创建获得该连接的IoSession实例
                    IoSession newSession = future.getSession();
                    try {
                        // Close old channel 关闭旧的session
                        IoSession oldSession = MinaClient.this.session; // copy reference
                        if (oldSession != null) {
                            try {
                                if (logger.isInfoEnabled()) {
                                    logger.info("Close old mina channel " + oldSession + " on create new mina channel " + newSession);
                                }
                                // 关闭连接
                                oldSession.close();
                            } finally {
                                // 移除通道
                                MinaChannel.removeChannelIfDisconnected(oldSession);
                            }
                        }
                    } finally {
                        // 如果MinaClient关闭了
                        if (MinaClient.this.isClosed()) {
                            try {
                                if (logger.isInfoEnabled()) {
                                    logger.info("Close new mina channel " + newSession + ", because the client closed.");
                                }
                                // 关闭session
                                newSession.close();
                            } finally {
                                MinaClient.this.session = null;
                                MinaChannel.removeChannelIfDisconnected(newSession);
                            }
                        } else {
                            // 设置新的session
                            MinaClient.this.session = newSession;
                        }
                    }
                }
            } catch (Exception e) {
                exception.set(e);
            } finally {
                // 减少数量，释放所有等待的线程
                finish.countDown();
            }
        }
    });
    try {
        // 当前线程等待，直到锁存器倒计数到零，除非线程被中断，或者指定的等待时间过去
        finish.await(getConnectTimeout(), TimeUnit.MILLISECONDS);
    } catch (InterruptedException e) {
        throw new RemotingException(this, "client(url: " + getUrl() + ") failed to connect to server " + getRemoteAddress() + " client-side timeout "
                + getConnectTimeout() + "ms (elapsed: " + (System.currentTimeMillis() - start)
                + "ms) from netty client " + NetUtils.getLocalHost() + " using dubbo version "
                + Version.getVersion() + ", cause: " + e.getMessage(), e);
    }
    Throwable e = exception.get();
    if (e != null) {
        throw e;
    }
}

该方法是客户端连接服务器的实现方法。其中用到了CountDownLatch来代表完成完成事件，它来做一个线程等待，直到1个线程完成上述的动作，也就是连接完成结束，才释放等待的线程。保证每次只有一条线程去连接，解决future.awaitUninterruptibly（）死锁问题。

其他方法请自行查看我写的注释。

（四）MinaServer

该类继承了AbstractServer，是基于mina实现的服务端实现类。

1.属性

private static final Logger logger = LoggerFactory.getLogger(MinaServer.class);

/**
 * 套接字接收者对象
 */
private SocketAcceptor acceptor;

2.doOpen

@Override
protected void doOpen() throws Throwable {
    // set thread pool.
    // 创建套接字接收者对象
    acceptor = new SocketAcceptor(getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS),
            Executors.newCachedThreadPool(new NamedThreadFactory("MinaServerWorker",
                    true)));
    // config
    // 设置配置
    SocketAcceptorConfig cfg = (SocketAcceptorConfig) acceptor.getDefaultConfig();
    cfg.setThreadModel(ThreadModel.MANUAL);
    // set codec. 设置编解码器
    acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new MinaCodecAdapter(getCodec(), getUrl(), this)));

    // 开启服务器
    acceptor.bind(getBindAddress(), new MinaHandler(getUrl(), this));
}

该方法是创建服务器，并且打开服务器。关键就是调用了acceptor的方法。

3.doClose

@Override
protected void doClose() throws Throwable {
    try {
        if (acceptor != null) {
            // 取消绑定，也就是关闭服务器
            acceptor.unbind(getBindAddress());
        }
    } catch (Throwable e) {
        logger.warn(e.getMessage(), e);
    }
}

该方法是关闭服务器，就是调用了acceptor.unbind方法。

4.getChannels

@Override
public Collection<Channel> getChannels() {
    // 获得连接到该服务器到所有连接句柄
    Set<IoSession> sessions = acceptor.getManagedSessions(getBindAddress());
    Collection<Channel> channels = new HashSet<Channel>();
    for (IoSession session : sessions) {
        if (session.isConnected()) {
            // 每次都用一个连接句柄创建一个通道
            channels.add(MinaChannel.getOrAddChannel(session, getUrl(), this));
        }
    }
    return channels;
}

该方法是获得所有连接该服务器的通道。

5.getChannel

@Override
public Channel getChannel(InetSocketAddress remoteAddress) {
    // 获得连接到该服务器到所有连接句柄
    Set<IoSession> sessions = acceptor.getManagedSessions(getBindAddress());
    // 遍历所有句柄，找到要找的通道
    for (IoSession session : sessions) {
        if (session.getRemoteAddress().equals(remoteAddress)) {
            return MinaChannel.getOrAddChannel(session, getUrl(), this);
        }
    }
    return null;
}

该方法是获得地址对应的单个通道。

（五）MinaTransporter

public class MinaTransporter implements Transporter {

    public static final String NAME = "mina";

    @Override
    public Server bind(URL url, ChannelHandler handler) throws RemotingException {
        // 创建MinaServer实例
        return new MinaServer(url, handler);
    }

    @Override
    public Client connect(URL url, ChannelHandler handler) throws RemotingException {
        // 创建MinaClient实例
        return new MinaClient(url, handler);
    }

}

该类实现了Transporter接口，是基于mina的传输层实现。可以看到，bind和connect方法分别就是创建了MinaServer和MinaClient实例。这里我建议查看一下《dubbo源码解析（九）远程通信——Transport层》。

（六）MinaCodecAdapter

该类是基于mina实现的编解码类，实现了ProtocolCodecFactory。

1.属性

/**
 * 编码对象
 */
private final ProtocolEncoder encoder = new InternalEncoder();

/**
 * 解码对象
 */
private final ProtocolDecoder decoder = new InternalDecoder();

/**
 * 编解码器
 */
private final Codec2 codec;

/**
 * url对象
 */
private final URL url;

/**
 * 通道处理器对象
 */
private final ChannelHandler handler;

/**
 * 缓冲区大小
 */
private final int bufferSize;

属性比较好理解，该编解码器用到了ProtocolEncoder和ProtocolDecoder，而InternalEncoder和InternalDecoder两个类是该类的内部类，它们实现了ProtocolEncoder和ProtocolDecoder，关键的编解码逻辑在这两个类中实现。

2.构造方法

public MinaCodecAdapter(Codec2 codec, URL url, ChannelHandler handler) {
    this.codec = codec;
    this.url = url;
    this.handler = handler;
    int b = url.getPositiveParameter(Constants.BUFFER_KEY, Constants.DEFAULT_BUFFER_SIZE);
    // 如果缓存区大小在16字节以内，则设置配置大小，如果不是，则设置8字节的缓冲区大小
    this.bufferSize = b >= Constants.MIN_BUFFER_SIZE && b <= Constants.MAX_BUFFER_SIZE ? b : Constants.DEFAULT_BUFFER_SIZE;
}

3.InternalEncoder

private class InternalEncoder implements ProtocolEncoder {

    @Override
    public void dispose(IoSession session) throws Exception {
    }

    @Override
    public void encode(IoSession session, Object msg, ProtocolEncoderOutput out) throws Exception {
        // 动态分配一个1k的缓冲区
        ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(1024);
        // 获得通道
        MinaChannel channel = MinaChannel.getOrAddChannel(session, url, handler);
        try {
            // 编码
            codec.encode(channel, buffer, msg);
        } finally {
            // 检测是否断开连接，如果断开，则移除
            MinaChannel.removeChannelIfDisconnected(session);
        }
        // 写数据到out中
        out.write(ByteBuffer.wrap(buffer.toByteBuffer()));
        out.flush();
    }
}

该内部类是编码类，其中的encode方法中写到了编码核心调用的是codec.encode。

4.InternalDecoder

private class InternalDecoder implements ProtocolDecoder {

    private ChannelBuffer buffer = ChannelBuffers.EMPTY_BUFFER;

    @Override
    public void decode(IoSession session, ByteBuffer in, ProtocolDecoderOutput out) throws Exception {
        int readable = in.limit();
        if (readable <= 0) return;

        ChannelBuffer frame;

        // 如果缓冲区还有可读字节数
        if (buffer.readable()) {
            // 如果缓冲区是DynamicChannelBuffer类型的
            if (buffer instanceof DynamicChannelBuffer) {
                // 往buffer中写入数据
                buffer.writeBytes(in.buf());
                frame = buffer;
            } else {
                // 缓冲区大小
                int size = buffer.readableBytes() + in.remaining();
                // 动态分配一个缓冲区
                frame = ChannelBuffers.dynamicBuffer(size > bufferSize ? size : bufferSize);
                // buffer的数据把写到frame
                frame.writeBytes(buffer, buffer.readableBytes());
                // 把流中的数据写到frame
                frame.writeBytes(in.buf());
            }
        } else {
            // 否则是基于Java NIO的ByteBuffer生成的缓冲区
            frame = ChannelBuffers.wrappedBuffer(in.buf());
        }

        // 获得通道
        Channel channel = MinaChannel.getOrAddChannel(session, url, handler);
        Object msg;
        int savedReadIndex;

        try {
            do {
                // 获得读索引
                savedReadIndex = frame.readerIndex();
                try {
                    // 解码
                    msg = codec.decode(channel, frame);
                } catch (Exception e) {
                    buffer = ChannelBuffers.EMPTY_BUFFER;
                    throw e;
                }
                // 拆包
                if (msg == Codec2.DecodeResult.NEED_MORE_INPUT) {
                    frame.readerIndex(savedReadIndex);
                    break;
                } else {
                    if (savedReadIndex == frame.readerIndex()) {
                        buffer = ChannelBuffers.EMPTY_BUFFER;
                        throw new Exception("Decode without read data.");
                    }
                    if (msg != null) {
                        // 把数据写到输出流里面
                        out.write(msg);
                    }
                }
            } while (frame.readable());
        } finally {
            // 如果frame还有可读数据
            if (frame.readable()) {
                //丢弃可读数据
                frame.discardReadBytes();
                buffer = frame;
            } else {
                buffer = ChannelBuffers.EMPTY_BUFFER;
            }
            MinaChannel.removeChannelIfDisconnected(session);
        }
    }

    @Override
    public void dispose(IoSession session) throws Exception {
    }

    @Override
    public void finishDecode(IoSession session, ProtocolDecoderOutput out) throws Exception {
    }
}

该内部类是解码类，其中decode方法中关键的是调用了codec.decode，其余的操作是利用缓冲区对数据的冲刷流转。

后记

该部分相关的源码解析地址：https://github.com/CrazyHZM/i...

该文章讲解了基于mina的来实现的远程通信、介绍dubbo-remoting-mina内的源码解析，关键需要对mina有所了解。下一篇我会讲解基于netty3实现远程通信部分。