Mina 框架源码解析-NioSocketAcceptor启动过程

Mina 框架源码解析-NioSocketAcceptor启动过程

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

// 创建一个非阻塞的server端的Socket
acceptor = new NioSocketAcceptor();

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

 

1，NioSocketAcceptor 类头声明

public final class NioSocketAcceptor
        extends AbstractPollingIoAcceptor<NioSession, ServerSocketChannel>
        implements SocketAcceptor {

 继承了AbstractPollingIoAcceptor 类，实现SocketAcceptor 接口

 

2，看AbstractPollingIoAcceptor 类，

类头声明

public abstract class AbstractPollingIoAcceptor<S extends AbstractIoSession, H>
        extends AbstractIoAcceptor {

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

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

 private final Queue<AcceptorOperationFuture> registerQueue = new ConcurrentLinkedQueue<AcceptorOperationFuture>();

 private final Queue<AcceptorOperationFuture> cancelQueue = new ConcurrentLinkedQueue<AcceptorOperationFuture>();

 private final Map<SocketAddress, H> boundHandles = Collections.synchronizedMap(new HashMap<SocketAddress, H>());

 private final ServiceOperationFuture disposalFuture = new ServiceOperationFuture();

    /** The thread responsible of accepting incoming requests */ 
 private AtomicReference<Acceptor> acceptorRef = new AtomicReference<Acceptor>();

 

3，AbstractIoAcceptor 类头声明

public abstract class AbstractIoAcceptor 
        extends AbstractIoService implements IoAcceptor {

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

public abstract class AbstractIoService implements IoService {

AbstractIoAcceptor 类在加载时初始化这些

    private final List<SocketAddress> defaultLocalAddresses =
        new ArrayList<SocketAddress>();
    private final List<SocketAddress> unmodifiableDefaultLocalAddresses =
        Collections.unmodifiableList(defaultLocalAddresses);
    private final Set<SocketAddress> boundAddresses =
        new HashSet<SocketAddress>();

    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 类，进入构造方法

    public NioSocketAcceptor() {
    	/** 使用默认的Socket配置 
    	 * 调用父类的构造器  ,将默认配置传入到父类中，第二个参数NioProcessor.class 是动态类加载，会放到线程池上运行
    	 * 在父类AbstractPollingIoAcceptor的构造方法中调用init()接口，在子类中会调用init（）接口的实现，因而初始化了selector
    	 * protected AbstractPollingIoAcceptor(IoSessionConfig sessionConfig,
         *     Class<? extends IoProcessor<S>> processorClass) {
         * 	this(sessionConfig, null, new SimpleIoProcessorPool<S>(processorClass),true);
    	 *	}
    	 * */
        super(new DefaultSocketSessionConfig(), NioProcessor.class);//标记2
      
        ((DefaultSocketSessionConfig) getSessionConfig()).init(this);
    }

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

protected AbstractPollingIoAcceptor(IoSessionConfig sessionConfig,
            Class<? extends IoProcessor<S>> processorClass) {
    	//初始化selector，捕获一些异常，将处理器类加载进来
        this(sessionConfig, null, new SimpleIoProcessorPool<S>(processorClass),
                true);//标记3
    }

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

 private AbstractPollingIoAcceptor(IoSessionConfig sessionConfig,
            Executor executor, IoProcessor<S> 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 的构造方法

   protected AbstractIoAcceptor(IoSessionConfig sessionConfig, Executor executor) {
        super(sessionConfig, executor);//标记5
        defaultLocalAddresses.add(null);
    }

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

/**
     * 构造器，必须提供一个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 <code>null</code>.
     */
    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 的实现