Netty中ReflectiveChannelFactory

在Netty中，ReflectiveChannelFactory是用来生产Channel的工厂/**
* A {@link ChannelFactory} that instantiates a new {@link Channel} by invoking its default constructor reflectively.
 * 这个ChannelFactory会利用传入的泛型的默认的构造方法实例化一个channel.
 */
public class ReflectiveChannelFactory<T extends Channel> implements ChannelFactory<T> {

private final Class<? extends T> clazz;

public ReflectiveChannelFactory(Class<? extends T> clazz) {
if (clazz == null) {
throw new NullPointerException("clazz");
}
this.clazz = clazz;
}

@Override
public T newChannel() {
try {
return clazz.getConstructor().newInstance();
} catch (Throwable t) {
throw new ChannelException("Unable to create Channel from class " + clazz, t);
}
}

@Override
public String toString() {
return StringUtil.simpleClassName(clazz) + ".class";
}
}
实际上我们可以看出，这个Channel工厂也只是去调用了一个泛型的的无参构造器，那在我们的实际代码中，我们调用serverBootStrap的channel方法进行channelFactory配置的时候，传入的是一个NioServerSocketChannel的类，所以这个无参的构造器也就是NioServerSocketChannel的无参构造器；/**
* A {@link io.netty.channel.socket.ServerSocketChannel} implementation which uses
* NIO selector based implementation to accept new connections.
* 一个ServerSocketChannel的实例使用了Nio的selector的基本实现来接收一个新的连接。
*/
public class NioServerSocketChannel extends AbstractNioMessageChannel
implements io.netty.channel.socket.ServerSocketChannel {

private static final ChannelMetadata METADATA = new ChannelMetadata(false, 16);
private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();

private static final InternalLogger logger = InternalLoggerFactory.getInstance(NioServerSocketChannel.class);

private static ServerSocketChannel newSocket(SelectorProvider provider) {
try {
/**
* Use the {@link SelectorProvider} to open {@link SocketChannel} and so remove condition in
* {@link SelectorProvider#provider()} which is called by each ServerSocketChannel.open() otherwise.
* 直接使用SelectorProvider来打开一个SocketChannel,这样就移除掉了每次调用ServerSocketChannel.open()的造成的问题，
* 具体原因：
* See <a href="https://github.com/netty/netty/issues/2308">#2308</a>.
*/
return provider.openServerSocketChannel();
} catch (IOException e) {
throw new ChannelException(
"Failed to open a server socket.", e);
}
}

private final ServerSocketChannelConfig config;

/**
* Create a new instance
* 这个构造方法被Channel工厂所使用的，用于创建Channel实例，内部调用了一个传入了JAVA nio中的ServerSocketChannel的对象的方法
*/
public NioServerSocketChannel() {
this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}

/**
* Create a new instance using the given {@link SelectorProvider}.
*/
public NioServerSocketChannel(SelectorProvider provider) {
this(newSocket(provider));
}

/**
* Create a new instance using the given {@link ServerSocketChannel}.
* 从这就可以看出，我们看到了NIO中的SelectionKey.OP_ACCEPT,这就是Netty与NIO拥有紧密联系的证据
* 这里面还是对这个类进行配置，保存了ServerSocketChannel的有引用，。
*/
public NioServerSocketChannel(ServerSocketChannel channel) {
        //使用它的一些父类的构造方法会对它的一些属性进行初始化：
        //config:channel的配置信息对象 NioServerSocketChannelConfig
        //ch： serverSocketChannel在NioServerSocketChannel的引用,并设置channel为非阻塞。
        //readInterestOp： Channel所感兴趣的key
        //id:channel的id对象，DefaultChannelId
        //unsafe：channel的unsafe对象 NioMessageUnsafe
        //pipeline：channel的pipeline对象 DefaultChannelPipeline
        
         super(null, channel, SelectionKey.OP_ACCEPT);
//获取这个ServerSocketChannel的socket,目的可想而知，就是要bind某一个端口
config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

/**
* 下面的代码都是对这个类进行配置，最终都会交给ServerSocketChannel。
*/
}