java socketacceptor_Mina 框架源码解析-NioSocketAcceptor启动过程 | 学步园

在HeartBeatServer 中，有一句启动Server端的代码

Java代码  

// 创建一个非阻塞的server端的Socket

acceptor = new NioSocketAcceptor();

下面分析这个 new NioSocketAcceptor的过程：

1，NioSocketAcceptor 类头声明

Java代码  

public final class NioSocketAcceptor

extends AbstractPollingIoAcceptor

implements SocketAcceptor {

继承了AbstractPollingIoAcceptor 类，实现SocketAcceptor 接口

2，看AbstractPollingIoAcceptor 类，

类头声明

Java代码  

public abstract class AbstractPollingIoAcceptor

extends AbstractIoAcceptor {

继承了AbstractIoAcceptor 类，AbstractIoAcceptor 类说明请看第3点

在AbstractPollingIoAcceptor 类加载的时候初始化了这些

Java代码  

private final Queue registerQueue = new ConcurrentLinkedQueue();

private final Queue cancelQueue = new ConcurrentLinkedQueue();

private final Map boundHandles = Collections.synchronizedMap(new HashMap());

private final ServiceOperationFuture disposalFuture = new ServiceOperationFuture();

/** The thread responsible of accepting incoming requests */

private AtomicReference acceptorRef = new AtomicReference();

3，AbstractIoAcceptor 类头声明

Java代码  

public abstract class AbstractIoAcceptor

extends AbstractIoService implements IoAcceptor {

继承AbstractIoService 类，AbstractIoService类实现IoService接口

Java代码  

public abstract class AbstractIoService implements IoService {

AbstractIoAcceptor 类在加载时初始化这些

Java代码  

private final List defaultLocalAddresses =

new ArrayList();

private final List unmodifiableDefaultLocalAddresses =

Collections.unmodifiableList(defaultLocalAddresses);

private final Set boundAddresses =

new HashSet();

private boolean disconnectOnUnbind = true;

/**

* 当bind或unbind操作的时候需要获得的锁对象

* The lock object which is acquired while bind or unbind operation is performed.

* Acquire this lock in your property setters which shouldn't be changed while

* the service is bound.

*/

protected final Object bindLock = new Object();

4，SocketAcceptor 接口，AbstractPollingIoAcceptor 构造函数等先不看，那只不过是实现一种规范而已。

5，回到NioSocketAcceptor 类，进入构造方法

Java代码  

public NioSocketAcceptor() {

/** 使用默认的Socket配置

* 调用父类的构造器  ,将默认配置传入到父类中，第二个参数NioProcessor.class 是动态类加载，会放到线程池上运行

* 在父类AbstractPollingIoAcceptor的构造方法中调用init()接口，在子类中会调用init()接口的实现，因而初始化了selector

* protected AbstractPollingIoAcceptor(IoSessionConfig sessionConfig,

*     Class extends IoProcessor> processorClass) {

*  this(sessionConfig, null, new SimpleIoProcessorPool(processorClass),true);

*  }

* */

super(new DefaultSocketSessionConfig(), NioProcessor.class);//标记2

((DefaultSocketSessionConfig) getSessionConfig()).init(this);

}

super方法(标记2)，调用父类AbstractPollingIoAcceptor 构造方法，初始化了DefaultSocketSessionConfig 类，并和NioProcessor .class 传递给上一级构造方法,构造方法如下

Java代码  

protected AbstractPollingIoAcceptor(IoSessionConfig sessionConfig,

Class extends IoProcessor> processorClass) {

//初始化selector，捕获一些异常，将处理器类加载进来

this(sessionConfig, null, new SimpleIoProcessorPool(processorClass),

true);//标记3

}

this使用(标记3)，接收到下级传来的DefaultSocketSessionConfig和NioProcessor， 并用SimpleIoProcessorPool初始化，(SimpleIoProcessorPool将在下一节介绍)，再次传递给AbstractPollingIoAcceptor 类的构造方法

Java代码  

private AbstractPollingIoAcceptor(IoSessionConfig sessionConfig,

Executor executor, IoProcessor processor,

boolean createdProcessor) {

super(sessionConfig, executor);//标记4

if (processor == null) {

throw new IllegalArgumentException("processor");

}

this.processor = processor;//new SimpleIoProcessorPool()

this.createdProcessor = createdProcessor;//是否创建新的处理池

try {

// Initialize the selector

init();//初始化selector，因此在此处是抽象类，所以最终执行的是实体类的init()，也就是继承了此抽象类的实体类NioSocketAcceptor

// The selector is now ready, we can switch the

// flag to true so that incoming connection can be accepted

selectable = true;

} catch (RuntimeException e) {

throw e;

} catch (Exception e) {

throw new RuntimeIoException("Failed to initialize.", e);

} finally {

if (!selectable) {

try {

destroy();

} catch (Exception e) {

ExceptionMonitor.getInstance().exceptionCaught(e);

}

}

}

}

super方法(标记4)，调用父类AbstractIoAcceptor 的构造方法

Java代码  

protected AbstractIoAcceptor(IoSessionConfig sessionConfig, Executor executor) {

super(sessionConfig, executor);//标记5

defaultLocalAddresses.add(null);

}

此处super方法(标记5)，调用父类AbstractIoService 的构造方法，线程池等在此处初始化

Java代码  

/**

* 构造器，必须提供一个session配置和一个线程执行器，如果线程执行器为空，则会自动创建一个新的线程池

* Constructor for {@link AbstractIoService}. You need to provide a default

* session configuration and an {@link Executor} for handling I/O events. If

* a null {@link Executor} is provided, a default one will be created using

* {@link Executors#newCachedThreadPool()}.

*

* @param sessionConfig

*            the default configuration for the managed {@link IoSession}

* @param executor

*            the {@link Executor} used for handling execution of I/O

*            events. Can be null.

*/

protected AbstractIoService(IoSessionConfig sessionConfig, Executor executor) {

if (sessionConfig == null) {

throw new IllegalArgumentException("sessionConfig");

}

if (getTransportMetadata() == null) {

throw new IllegalArgumentException("TransportMetadata");

}

if (!getTransportMetadata().getSessionConfigType().isAssignableFrom(

sessionConfig.getClass())) {

throw new IllegalArgumentException("sessionConfig type: "

+ sessionConfig.getClass() + " (expected: "

+ getTransportMetadata().getSessionConfigType() + ")");

}

// Create the listeners, and add a first listener : a activation listener

// for this service, which will give information on the service state.

listeners = new IoServiceListenerSupport(this);

listeners.add(serviceActivationListener);

// Stores the given session configuration

this.sessionConfig = sessionConfig;

// Make JVM load the exception monitor before some transports

// change the thread context class loader.

ExceptionMonitor.getInstance();

if (executor == null) {

this.executor = Executors.newCachedThreadPool();

createdExecutor = true;

} else {

this.executor = executor;

createdExecutor = false;

}

threadName = getClass().getSimpleName() + '-' + id.incrementAndGet();

}

初始化Listener监听机制，就完成了new NioSocketAcceptor()的过程，Listener监听机制将在以后讲解，下一节是

Mina SimpleIoProcessor 的实现