首先看一下它们的关系

AbstractBootstrap源码如下↓

//AbstractBootstrap是一个辅助类,很容易引导一个通道。
//它支持方法链接提供一个简单的方法来配置AbstractBootstrap。
//当不使用ServerBootstrap上下文,bind()方法是有用的等无连接传输数据报(UDP)。
public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
	//EventLoopGroup 作为服务端 Acceptor 线程，负责处理客户端的请求接入
	//作为客户端 Connector 线程，负责注册监听连接操作位，用于判断异步连接结果
	volatile EventLoopGroup group;
	
	//创建Channer 工厂 根据传入的类型来创建不同的Channer
	//服务器传入的是：NioServerSocketChannel.class
	//客户端传入：NioSocketChannel.class 
    @SuppressWarnings("deprecation")
    private volatile ChannelFactory<? extends C> channelFactory;
	//用来绑定一个服务端口
    private volatile SocketAddress localAddress;
    // ChannelOptions应用的顺序很重要,他们会互相依赖进行验证
    // ChannelOption 可以添加Channer 添加一些配置信息.
    private final Map<ChannelOption<?>, Object> options = new LinkedHashMap<ChannelOption<?>, Object>();
    private final Map<AttributeKey<?>, Object> attrs = new ConcurrentHashMap<AttributeKey<?>, Object>();

	//ChannelHandler 是具体怎么处理Channer 的IO事件
	private volatile ChannelHandler handler;
	
	// 绑定EventLoopGroup
    public B group(EventLoopGroup group) {
        ObjectUtil.checkNotNull(group, "group");
        if (this.group != null) {
            throw new IllegalStateException("group set already");
        }
        this.group = group;
        return self();
    }
    //返回对象自己
    private B self() {
        return (B) this;
    }
	
     //设置服务端的Channel,Netty通过Channel工厂类创建不同的Channel。
     //对于服务端传入:Netty需要创建NioServerSocketChannel
     //对于客户端传入:NioSocketChannel.class
    public B channel(Class<? extends C> channelClass) {
        if (channelClass == null) {
            throw new NullPointerException("channelClass");
        }
        return channelFactory(new ReflectiveChannelFactory<C>(channelClass));
    }
	
     //创建好Channel后，返回对象本身
    public B channelFactory(ChannelFactory<? extends C> channelFactory) {
        if (channelFactory == null) {
            throw new NullPointerException("channelFactory");
        }
        if (this.channelFactory != null) {
            throw new IllegalStateException("channelFactory set already");
        }

        this.channelFactory = channelFactory;
        return self();
    }
    
     // 设置一些Channel相关参数
    public <T> B option(ChannelOption<T> option, T value) {
        if (option == null) {
            throw new NullPointerException("option");
        }
        if (value == null) {
            synchronized (options) {
                options.remove(option);
            }
        } else {
            synchronized (options) {
                options.put(option, value);
            }
        }
        return self();
    }

     //服务端方法: 绑定端口 对该端口进行监听
    public ChannelFuture bind(int inetPort) {
        return bind(new InetSocketAddress(inetPort));
    }
}

	//需要传入访问的地址和端口
    public ChannelFuture bind(String inetHost, int inetPort) {
        return bind(SocketUtils.socketAddress(inetHost, inetPort));
    }
    //重载
    public ChannelFuture bind(SocketAddress localAddress) {

        if (localAddress == null) {
            throw new NullPointerException("localAddress");
        }
        return doBind(localAddress);
    }
	
	//设置父类的Handler,父类的handler是客户端新接入的接连SocketChannel对应的ChannelPipeline 的handler
	public B handler(ChannelHandler handler) {
        if (handler == null) {
            throw new NullPointerException("handler");
        }
        this.handler = handler;
        return self();
    }

先说一下有哪些Channel类型吧↓

- NioSocketChannel, 代表异步的客户端 TCP Socket 连接.
- NioServerSocketChannel, 异步的服务器端 TCP Socket 连接.
- NioDatagramChannel, 异步的 UDP 连接
- NioSctpChannel, 异步的客户端 Sctp 连接.
- NioSctpServerChannel, 异步的 Sctp 服务器端连接.
- OioSocketChannel, 同步的客户端 TCP Socket 连接.
- OioServerSocketChannel, 同步的服务器端 TCP Socket 连接.
- OioDatagramChannel, 同步的 UDP 连接
- OioSctpChannel, 同步的 Sctp 服务器端连接.
- OioSctpServerChannel, 同步的客户端 TCP Socket 连接.