mina框架分析---1
SocketAcceptor
本文分析中贴出的代码简化了原版的代码，方便查看。
使用Mina第一步是构造一个acceptor，第二部是设置acceptor相应的Handler事件处理器，第三部就是调用bind函数开始监听连接。下面一一分析。
本章分析Mina框架，主要分析NioSocketAcceptor。
NioSocketAcceptor属于Mina框架中的Acceptor，用来处理客户端的连接。首先看NioSocketAcceptor的继承关系，
public final class NioSocketAcceptor extends AbstractPollingIoAcceptor<NioSession, ServerSocketChannel> implements SocketAcceptor public abstract class AbstractPollingIoAcceptor<S extends AbstractIoSession, H> extends AbstractIoAcceptor public abstract class AbstractIoAcceptor extends AbstractIoService implements IoAcceptor public abstract class AbstractIoService implements IoServiceNioSocketAcceptor构造函数
再看NioSocketAcceptor的构造函数
public NioSocketAcceptor(int processorCount) {
super(new DefaultSocketSessionConfig(), NioProcessor.class, processorCount);
((DefaultSocketSessionConfig) getSessionConfig()).init(this);
}NioSocketAcceptor的父类AbstractPollingIoAcceptor的构造函数如下
protected AbstractPollingIoAcceptor(IoSessionConfig sessionConfig, Class<? extends IoProcessor<S>> processorClass, int processorCount) {
this(sessionConfig, null, new SimpleIoProcessorPool<S>(processorClass, processorCount), true, null);
}SimpleIoProcessorPool会根据Java虚拟机用到的cpu数量构造一个池，代码如下所示
public SimpleIoProcessorPool(Class<? extends IoProcessor<S>> processorType, Executor executor, int size, SelectorProvider selectorProvider) {
if (createdExecutor) {
this.executor = Executors.newCachedThreadPool();
((ThreadPoolExecutor) this.executor).setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
} else {
this.executor = executor;
}
pool = new IoProcessor[size];
boolean success = false;
Constructor<? extends IoProcessor<S>> processorConstructor = null;
boolean usesExecutorArg = true;
try {
try {
try {
processorConstructor = processorType.getConstructor(ExecutorService.class);
pool[0] = processorConstructor.newInstance(this.executor);
} catch () {
}
} catch () {
}
for (int i = 1; i < pool.length; i++) {
try {
if (usesExecutorArg) {
if(selectorProvider==null) {
pool[i] = processorConstructor.newInstance(this.executor);
} else {
pool[i] = processorConstructor.newInstance(this.executor, selectorProvider);
}
} else {
pool[i] = processorConstructor.newInstance();
}
} catch (Exception e) {
}
}
success = true;
} finally {
if (!success) {
dispose();
}
}
}newCachedThreadPool构造了一个线程池ThreadPoolExecutor。setRejectedExecutionHandler设置当拒绝执行任务时的回调函数，这和主线无关，因此不往下分析了。传入的参数processorType是NioProcessor，下面会利用Java反射机制调用它的构造函数，
public NioProcessor(Executor executor) {
super(executor);
try {
selector = Selector.open();
} catch (IOException e) {
}
}这里通过open创建了一个NIO的selector，关于NIO的源码分析不是本章的重点，因此就不往下分析了。回到SimpleIoProcessorPool构造函数中，接下来是一个for循环，继续构造相应的NioProcessor。
再回到AbstractPollingIoAcceptor构造函数中，接下来会调用AbstractPollingIoAcceptor的另一个构造函数，在该函数中，会调用其父类AbstractIoAcceptor的构造函数，再往上调用其父类AbstractIoService的构造函数，如下
protected AbstractIoService(IoSessionConfig sessionConfig, Executor executor) {
listeners = new IoServiceListenerSupport(this);
listeners.add(serviceActivationListener);
this.sessionConfig = sessionConfig;
ExceptionMonitor.getInstance();
if (executor == null) {
this.executor = Executors.newCachedThreadPool();
createdExecutor = true;
} else {
this.executor = executor;
createdExecutor = false;
}
threadName = getClass().getSimpleName() + '-' + id.incrementAndGet();
}这里主要是构造了一个监听器列表类IoServiceListenerSupport，serviceActivationListener是一个IoServiceListener监听器，把它添加到IoServiceListenerSupport中。传入的参数executor为null，因此这里还需调用newCachedThreadPool构造一个ThreadPoolExecutor。
setHandler
接下来调用NioSocketAcceptor设置处理函数，定义在其父类AbstractIoService中。
public final void setHandler(IoHandler handler) {
this.handler = handler;
}bind
bind函数最终会调用NioSocketAcceptor的父类AbstractIoAcceptor中的bind函数，如下
public final void bind(Iterable<? extends SocketAddress> localAddresses) throws IOException {
List<SocketAddress> localAddressesCopy = new ArrayList<SocketAddress>();
for (SocketAddress a : localAddresses) {
checkAddressType(a);
localAddressesCopy.add(a);
}
boolean activate = false;
synchronized (bindLock) {
synchronized (boundAddresses) {
if (boundAddresses.isEmpty()) {
activate = true;
}
}
try {
Set<SocketAddress> addresses = bindInternal(localAddressesCopy);
synchronized (boundAddresses) {
boundAddresses.addAll(addresses);
}
} catch (IOException e) {
throw e;
}
}
if (activate) {
getListeners().fireServiceActivated();
}
}这里主要会调用两个函数，一是bindInternal，二是调用监听器的fireServiceActivated函数。监听器由用户自定义实现。下面主要看bindInternal函数，定义在AbstractPollingIoAcceptor中，
protected final Set<SocketAddress> bindInternal(List<? extends SocketAddress> localAddresses) throws Exception {
AcceptorOperationFuture request = new AcceptorOperationFuture(localAddresses);
registerQueue.add(request);
startupAcceptor();
...
}AcceptorOperationFuture和信号有关系，这里不管它，到用到的时候再分析。重点看startupAcceptor这个函数，
private void startupAcceptor() throws InterruptedException {
if (!selectable) {
registerQueue.clear();
cancelQueue.clear();
}
Acceptor acceptor = acceptorRef.get();
if (acceptor == null) {
lock.acquire();
acceptor = new Acceptor();
if (acceptorRef.compareAndSet(null, acceptor)) {
executeWorker(acceptor);
} else {
lock.release();
}
}
}这里构造了一个Acceptor，添加到acceptorRef中，然后调用executeWorker启动线程执行该Acceptor。executeWorker就是启动一个线程，并执行Acceptor的run函数，
public void run() {
int nHandles = 0;
while (selectable) {
try {
int selected = select();
nHandles += registerHandles();
if (selected > 0) {
processHandles(selectedHandles());
}
nHandles -= unregisterHandles();
} catch (Exception e) {
}
}
}select定义在NioSocketAcceptor中，
protected int select() throws Exception {
return selector.select();
}该函数和NIO相关，其底层就是一个轮询，查看是否有事件发生。
registerHandles定义在AbstractPollingIoAcceptor中，用于设置Socket的连接，
private int registerHandles() {
for (;;) {
AcceptorOperationFuture future = registerQueue.poll();
Map<SocketAddress, H> newHandles = new ConcurrentHashMap<SocketAddress, H>();
List<SocketAddress> localAddresses = future.getLocalAddresses();
try {
for (SocketAddress a : localAddresses) {
H handle = open(a);
newHandles.put(localAddress(handle), handle);
}
boundHandles.putAll(newHandles);
future.setDone();
return newHandles.size();
} catch (Exception e) {
} finally {
}
}
}这里通过AcceptorOperationFuture得到的localAddress便是前面注册的主机地址，重点看这个open函数，定义在NioSocketAcceptor中，
protected ServerSocketChannel open(SocketAddress localAddress) throws Exception {
ServerSocketChannel channel = null;
if (selectorProvider != null) {
channel = selectorProvider.openServerSocketChannel();
} else {
channel = ServerSocketChannel.open();
}
boolean success = false;
try {
channel.configureBlocking(false);
ServerSocket socket = channel.socket();
socket.setReuseAddress(isReuseAddress());
try {
socket.bind(localAddress, getBacklog());
} catch (IOException ioe) {
}
channel.register(selector, SelectionKey.OP_ACCEPT);
success = true;
} finally {
}
return channel;
}这里就是构造openfire服务器监听连接的那个Socket，首先构造一个ServerSocketChannel，设置模式为非阻塞（因为NIO嘛），再调用bind函数绑定服务器地址，最后调用register注册OP_ACCEPT事件到selector中，这样后面调用select就可以监听该事件了。
回到registerHandles中，接下来就把对应的地址和刚刚构造的ServerSocketChannel注册到newHandles中。
再回到run函数中，先看一下unregisterHandles，定义在AbstractPollingIoAcceptor中，
private int unregisterHandles() {
int cancelledHandles = 0;
for (;;) {
AcceptorOperationFuture future = cancelQueue.poll();
if (future == null) {
break;
}
for (SocketAddress a : future.getLocalAddresses()) {
H handle = boundHandles.remove(a);
try {
close(handle);
} catch (Exception e) {
} finally {
cancelledHandles++;
}
}
future.setDone();
}
return cancelledHandles;
}这里就是检查cancelQueue是否有需要关闭的服务器地址，如果有，就取出前面注册进的ServerSocketChannel，调用close关闭它。
再看run函数，首先selectedHandles用于从NIO的Selector中获取的事件，保存在ServerSocketChannelIterator中，然后调用processHandles开始处理。该函数的分析放在下一章中。