Netty Review - ServerBootstrap源码解析
文章目录
- 概述
- 源码分析
- 小结
概述
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG, 1024)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
//加入特殊分隔符分包解码器
pipeline.addLast(new DelimiterBasedFrameDecoder(10240, Unpooled.copiedBuffer("_".getBytes())));
//向pipeline加入解码器
pipeline.addLast("decoder", new StringDecoder());
//向pipeline加入编码器
pipeline.addLast("encoder", new StringEncoder());
//加入自己的业务处理handler
pipeline.addLast(new ChatServerHandler());
}
});
这段代码使用Netty构建了一个服务器。
-
ServerBootstrap bootstrap = new ServerBootstrap();- 创建一个ServerBootstrap实例，用于启动服务器。 -
bootstrap.group(bossGroup, workerGroup)- 指定了服务器使用的两个EventLoopGroup，分别是bossGroup和workerGroup。其中，bossGroup用于接受传入的连接，而workerGroup用于处理已接受连接的流量。 -
bootstrap.channel(NioServerSocketChannel.class)- 指定了服务器的Channel类型为NioServerSocketChannel，这表示使用NIO进行网络通信。 -
bootstrap.option(ChannelOption.SO_BACKLOG, 1024)- 设置服务器的配置选项。在这里，设置了SO_BACKLOG，表示服务器套接字的连接队列大小为1024。 -
bootstrap.childHandler(new ChannelInitializer- 指定了当一个新的连接被接受时，所要执行的ChannelInitializer。这个匿名内部类用于配置新接受的Channel的ChannelPipeline，即为每个新接受的连接设置处理器。() {...}) -
pipeline.addLast(new DelimiterBasedFrameDecoder(10240, Unpooled.copiedBuffer("_".getBytes())))- 向ChannelPipeline中添加了一个DelimiterBasedFrameDecoder，用于根据特殊分隔符进行分包解码，这里的特殊分隔符是下划线"_”。 -
pipeline.addLast("decoder", new StringDecoder())- 向ChannelPipeline中添加了一个StringDecoder，用于将接收到的ByteBuf解码为字符串。 -
pipeline.addLast("encoder", new StringEncoder())- 向ChannelPipeline中添加了一个StringEncoder，用于将字符串编码为ByteBuf。 -
pipeline.addLast(new ChatServerHandler())- 向ChannelPipeline中添加了一个ChatServerHandler，这是自定义的业务处理Handler，用于处理接收到的消息。
总的来说，这段代码创建了一个基于Netty的服务器，配置了服务器的事件处理流程，包括接受连接、解码、编码和业务处理。
源码分析
ServerBootstrap bootstrap = new ServerBootstrap();
ServerBootstrap类的构造函数。在这个构造函数中，没有参数，它是一个默认构造函数。
bootstrap.group(bossGroup, workerGroup)
这段代码是ServerBootstrap类中的group方法的实现。
/**
* Set the {@link EventLoopGroup} for the parent (acceptor) and the child (client). These
* {@link EventLoopGroup}'s are used to handle all the events and IO for {@link ServerChannel} and
* {@link Channel}'s.
*/
public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
// 调用父类的group方法，设置父EventLoopGroup
super.group(parentGroup);
// 检查子EventLoopGroup是否为空，如果为空则抛出NullPointerException
if (childGroup == null) {
throw new NullPointerException("childGroup");
}
// 检查是否已经设置了子EventLoopGroup，如果已经设置了则抛出IllegalStateException
if (this.childGroup != null) {
throw new IllegalStateException("childGroup set already");
}
// 将传入的子EventLoopGroup赋值给成员变量childGroup
this.childGroup = childGroup;
// 返回ServerBootstrap实例，用于链式调用
return this;
}
这段代码的作用是设置ServerBootstrap的父（acceptor）和子（client）EventLoopGroup。这两个EventLoopGroup分别用于处理服务器端（acceptor）和客户端（client）的事件和IO操作。具体来说，这个方法会将传入的父EventLoopGroup设置给父类AbstractBootstrap，并将传入的子EventLoopGroup赋值给ServerBootstrap的成员变量childGroup。
在方法的实现中，
- 首先调用了父类的group方法来设置父EventLoopGroup。
- 然后，检查传入的子EventLoopGroup是否为空，如果为空则抛出NullPointerException。接着，检查是否已经设置了子EventLoopGroup，如果已经设置了则抛出IllegalStateException。
- -最后，将传入的子EventLoopGroup赋值给成员变量childGroup，并返回ServerBootstrap实例，以支持链式调用。
总的来说，这段代码的目的是为ServerBootstrap设置父和子EventLoopGroup，以便于处理服务器和客户端的事件和IO操作，并提供了异常处理机制以确保参数的有效性。
我们看下 调用父类的group方法，设置父EventLoopGroup
super.group(parentGroup);
这段代码是一个泛型方法，通常用于在Netty的Bootstrap或ServerBootstrap中设置用于处理事件的EventLoopGroup。
/**
* The {@link EventLoopGroup} which is used to handle all the events for the to-be-created
* {@link Channel}
*/
public B group(EventLoopGroup group) {
// 检查传入的EventLoopGroup是否为空，如果为空则抛出NullPointerException
if (group == null) {
throw new NullPointerException("group");
}
// 检查是否已经设置了EventLoopGroup，如果已经设置了则抛出IllegalStateException
if (this.group != null) {
throw new IllegalStateException("group set already");
}
// 将传入的EventLoopGroup赋值给成员变量group
this.group = group;
// 返回调用该方法的实例，以支持链式调用
return self();
}
这个方法主要用于设置用于处理事件的EventLoopGroup，它会将传入的EventLoopGroup赋值给成员变量group。
在方法的实现中，
- 首先检查传入的EventLoopGroup是否为空，如果为空则抛出NullPointerException。
- 然后，检查是否已经设置了EventLoopGroup，如果已经设置了则抛出IllegalStateException。
- 最后，将传入的EventLoopGroup赋值给成员变量group，并返回调用该方法的实例，以支持链式调用。
总的来说，这段代码的作用是为Netty的Bootstrap或ServerBootstrap设置EventLoopGroup，以便于处理事件，并提供了异常处理机制以确保参数的有效性。
channel(NioServerSocketChannel.class)
这段代码是一个泛型方法，用于设置用于创建Channel实例的Class对象。
/**
* The {@link Class} which is used to create {@link Channel} instances from.
* You either use this or {@link #channelFactory(io.netty.channel.ChannelFactory)} if your
* {@link Channel} implementation has no no-args constructor.
*/
public B channel(Class<? extends C> channelClass) {
// 检查传入的channelClass是否为空，如果为空则抛出NullPointerException
if (channelClass == null) {
throw new NullPointerException("channelClass");
}
// 调用channelFactory方法，传入一个ReflectiveChannelFactory实例，该实例用于通过反射创建Channel实例
return channelFactory(new ReflectiveChannelFactory<C>(channelClass));
}
这个方法主要用于设置用于创建Channel实例的Class对象。它接受一个Class对象作为参数，并将其传递给channelFactory方法。
在这个方法内部，会创建一个ReflectiveChannelFactory实例，并将传入的Class对象作为参数传递给它。
在方法的实现中，
- 首先检查传入的channelClass是否为空，如果为空则抛出NullPointerException。
- 然后，创建一个ReflectiveChannelFactory实例，并将传入的Class对象作为参数传递给它。
- 最后，调用channelFactory方法，将ReflectiveChannelFactory实例传递给它，并返回调用该方法的实例，以支持链式调用。
总的来说，这段代码的作用是为Netty的Bootstrap或ServerBootstrap设置用于创建Channel实例的Class对象，并提供了异常处理机制以确保参数的有效性。
new ReflectiveChannelFactory
这段代码是ReflectiveChannelFactory类的构造函数实现。它接受一个Class对象作为参数，并使用反射机制获取该类的公共无参数构造方法。让我们逐步解释它：
public ReflectiveChannelFactory(Class<? extends T> clazz) {
// 检查传入的clazz是否为空，如果为空则抛出NullPointerException
ObjectUtil.checkNotNull(clazz, "clazz");
try {
// 使用反射获取传入的类的公共无参数构造方法
this.constructor = clazz.getConstructor();
} catch (NoSuchMethodException e) {
// 如果获取构造方法失败，则抛出IllegalArgumentException异常
throw new IllegalArgumentException("Class " + StringUtil.simpleClassName(clazz) +
" does not have a public non-arg constructor", e);
}
}
这个构造函数的作用是初始化ReflectiveChannelFactory实例。
它接受一个Class对象作为参数，该Class对象表示要实例化的Channel类。在构造函数内部，
- 首先检查传入的Class对象是否为空，如果为空则抛出NullPointerException。
- 然后，使用反射机制尝试获取传入类的公共无参数构造方法。如果获取构造方法失败，则抛出IllegalArgumentException异常，指示传入的类没有公共无参数构造方法。
总的来说，这段代码的作用是为ReflectiveChannelFactory类创建一个实例，并在构造函数中使用反射机制获取要实例化的Channel类的构造方法。
@Override
public T newChannel() {
try {
// 使用之前获取的构造方法实例化新的Channel对象
return constructor.newInstance();
} catch (Throwable t) {
// 如果实例化过程中出现异常，则抛出ChannelException异常
throw new ChannelException("Unable to create Channel from class " + constructor.getDeclaringClass(), t);
}
}
/**
* @deprecated Use {@link #channelFactory(io.netty.channel.ChannelFactory)} instead.
*/
@Deprecated
public B channelFactory(ChannelFactory<? extends C> channelFactory) {
// 检查传入的channelFactory是否为空，如果为空则抛出NullPointerException
if (channelFactory == null) {
throw new NullPointerException("channelFactory");
}
// 检查是否已经设置了channelFactory，如果已经设置了则抛出IllegalStateException
if (this.channelFactory != null) {
throw new IllegalStateException("channelFactory set already");
}
// 将传入的channelFactory赋值给成员变量channelFactory
this.channelFactory = channelFactory;
return self();
}
option(ChannelOption.SO_BACKLOG, 1024)
这段代码定义了一个方法，用于为创建的Channel实例设置ChannelOption。
/**
* Allow to specify a {@link ChannelOption} which is used for the {@link Channel} instances once they got
* created. Use a value of {@code null} to remove a previous set {@link ChannelOption}.
*/
public <T> B option(ChannelOption<T> option, T value) {
// 检查传入的option是否为空，如果为空则抛出NullPointerException
if (option == null) {
throw new NullPointerException("option");
}
// 如果value为空，则从options中移除之前设置的option
if (value == null) {
synchronized (options) {
options.remove(option);
}
} else {
// 否则，将option和对应的value放入options中
synchronized (options) {
options.put(option, value);
}
}
// 返回调用该方法的实例，以支持链式调用
return self();
}
这个方法的作用是允许指定一个ChannelOption，该选项在创建Channel实例后使用。如果value为null，则表示要移除之前设置的ChannelOption。否则，将option和对应的value放入options中。
在方法的实现中，
- 首先检查传入的option是否为空，如果为空则抛出NullPointerException。
- 然后，如果value为null，则从options中移除之前设置的option；否则，将option和对应的value放入options中。
- 最后，返回调用该方法的实例，以支持链式调用。
这个方法的灵活性在于它允许用户根据需要设置或删除特定的ChannelOption，以满足不同场景的需求。
childHandler()
这段代码定义了一个方法，用于设置用于处理连接到ServerBootstrap的每个子Channel的ChannelHandler。
/**
* Set the {@link ChannelHandler} which is used to serve the request for the {@link Channel}'s.
*/
public ServerBootstrap childHandler(ChannelHandler childHandler) {
// 检查传入的childHandler是否为空，如果为空则抛出NullPointerException
if (childHandler == null) {
throw new NullPointerException("childHandler");
}
// 将传入的childHandler赋值给成员变量childHandler
this.childHandler = childHandler;
// 返回ServerBootstrap实例，以支持链式调用
return this;
}
这个方法的作用是设置用于处理连接到ServerBootstrap的每个子Channel的ChannelHandler。传入的ChannelHandler将会被添加到每个新创建的子Channel的ChannelPipeline中，用于处理该子Channel的所有事件。
在方法的实现中，
- 首先检查传入的childHandler是否为空，如果为空则抛出NullPointerException。
- 然后，将传入的childHandler赋值给成员变量childHandler。
- 最后，返回ServerBootstrap实例，以支持链式调用。
这种设计模式允许用户通过链式调用一系列方法来配置ServerBootstrap的参数，从而更加简洁和灵活地构建Netty服务器。
小结
ServerBootstrap是Netty中用于创建服务器端应用程序的引导类。它的设计目的是提供一种简洁、灵活的方式来配置和启动服务器，并处理与客户端的连接。
以下是ServerBootstrap的设计要点总结：
-
引导配置链式调用：ServerBootstrap类提供了一系列方法，允许用户通过链式调用来配置服务器的各种参数，如设置EventLoopGroup、Channel类型、Channel选项、ChannelHandler等。这种设计模式使得配置过程更加简洁和灵活。
-
EventLoopGroup的配置：通过group方法，用户可以设置用于处理服务器端连接和客户端连接的EventLoopGroup。通常，一个用于接受连接的bossGroup和一个用于处理连接请求的workerGroup会被设置。
-
Channel类型的设置：用户可以通过channel方法设置用于创建Channel实例的类型，例如NioServerSocketChannel.class。这决定了服务器将使用的底层传输协议。
-
Channel选项的设置：option/childOption方法允许用户为创建的Channel实例设置各种选项，如SO_BACKLOG、TCP_NODELAY等。
-
ChannelHandler的配置：通过childHandler方法，用户可以设置用于处理连接到服务器的每个子Channel的ChannelHandler。这些ChannelHandler将被添加到每个新创建的子Channel的ChannelPipeline中，用于处理子Channel的所有事件。
-
灵活性和可扩展性：ServerBootstrap的设计允许用户根据具体需求灵活地配置服务器的各种参数，同时也提供了可扩展的接口和回调机制，使得用户可以根据需要自定义处理逻辑。
总的来说，ServerBootstrap的设计通过提供一系列简洁而灵活的配置方法，以及可扩展的接口和回调机制，使得用户能够轻松地构建高性能、可定制的服务器应用程序。
