background
Netty is an asynchronous event-driven network communication layer framework
Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers and clients. It greatly simplifies and streamlines network programming such as TCP and UDP socket server.
We choose Netty as the underlying network communication framework in SAILFISH (daily push message volume of 5 billion) and SHARK (daily throughput of 3 billion).
Since two such important systems at the bottom of the use of NetTY, so it is necessary to netTY mechanism, and even the source code if at all, so, it spawned netTY source code series articles. Later, I will unreservedly introduce what I have learned from the Netty source code, which is based on 4.1.6.Final, through a series of topics
why netty
Netty’s underlying NIO is based on JDK, why don’t we just base it on JDK NIO or another NIO framework? Here are my reasons
1. The NIO in JDK requires too many concepts to understand, and the programming is complex. 2. 4.NET TY solves a lot of bugs in JDK, including empty wheel training. 5.NET TY has done a lot of small optimization on threads and selectors. The well-designed Reactor thread can achieve very efficient concurrent processing 6. 8.NET TY has been extensively validated across RPC frameworks, message-oriented middleware, and distributed communication middleware lines, making it extremely robust
dive into netty
With that in mind, today we’ll start our journey through Netty source code with an example.
This article focuses on how Netty binds ports and starts services. As you start the service, you will learn about the core components of Netty. I won’t go into detail about these components, but I will tell you how they are strung together to form the core of Netty
example
Here is a very simple server startup code
public final class SimpleServer {
public static void main(String[] args) throws Exception {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.handler(new SimpleServerHandler())
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {}}); ChannelFuture f = b.bind(8888).sync();
f.channel().closeFuture().sync();
} finally{ bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); }}private static class SimpleServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println("channelActive");
}
@Override
public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
System.out.println("channelRegistered");
}
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
System.out.println("handlerAdded"); }}}Copy the codeIn a few simple lines of code, you can start a server, bind to port 8888, and use NIO mode. The details of each step are described below
An EventLoopGroup, which I have dissected in detail in other articles, is basically an infinite loop that continuously detects IO events, processes IO events, and executes tasks
ServerBootstrap is a bootstrap class on the server that binds ports to start the service by setting a set of parameters
Group (bossGroup, workerGroup) we need two types of people to do the work, one is the boss and the other is the worker, and the boss takes the work from the outside, gets the work from the workers, puts it in here, and the bossGroup’s function is to constantly accept new connections, Throw the new connection to the workerGroup for processing
Channel (NioServerSocketChannel. Class) said the server startup is nio related channel, the channel is a core concept in netty, can be understood as a channel is a connection or a server bind action, More on that later
.handler(new SimpleServerHandler() indicates the process that SimpleServerHandler needs to go through during server startup. Here, SimpleServerHandler’s final top-level interface is ChannelHander, which is a core concept of Netty. The processor that represents the data flow through can be thought of as each level in the pipeline
childHandler(new ChannelInitializer
)… After a new connection comes in, how to deal with it, that is, what the boss said above, how to match the workers
ChannelFuture f = b.bind(8888).sync(); Here is the real startup process, bind port 8888, wait for the server startup, will enter the downstream code
f.channel().closeFuture().sync(); Wait for the server to close the socket
bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); Close both sets of infinite loops
The above code can easily run locally again, and the final console output is:
handlerAdded
channelRegistered
channelActive
Copy the codeIt’s easy to dig a little deeper into why this is being sequential, right
Further details
ServerBootstrap is a set of parameters that are stored using method chaining to start the server. Our focus falls on the following code
b.bind(8888).sync();
Copy the codeHere’s a sentence: If we are just beginning to look at the source code, we can use the IDE debug function step by step, one step one test, or binary test to determine which line of code is the final entry to start the service. In this case, we have determined that the bind method is the entry. Let’s go in there and analyze
public ChannelFuture bind(int inetPort) {
return bind(new InetSocketAddress(inetPort));
}
Copy the codeCreate an InetSocketAddress with the port number and continue with the bind
public ChannelFuture bind(SocketAddress localAddress) {
validate();
if (localAddress == null) {
throw new NullPointerException("localAddress");
}
return doBind(localAddress);
}
Copy the codeValidate () validates the necessary parameters needed to start the service, and then calls doBind()
private ChannelFuture doBind(final SocketAddress localAddress) {
/ /...
final ChannelFuture regFuture = initAndRegister();
/ /...
final Channel channel = regFuture.channel();
/ /...
doBind0(regFuture, channel, localAddress, promise);
/ /...
return promise;
}
Copy the codeI’m going to cut out the details here, let’s focus on the core methods, but there are really two core methods initAndRegister() and doBind0()
In fact, we already know a little bit from the method name, init-> initialize, register-> register, so what do we register to? To get to the registration of the polisher in NIO, maybe you initialize something and then you register it with a selector, and then you bind, you know, the port number locally, so with that in mind, we’re going to go a little bit further
initAndRegister()
final ChannelFuture initAndRegister(a) {
Channel channel = null;
// ...
channel = channelFactory.newChannel();
/ /...
init(channel);
/ /...
ChannelFuture regFuture = config().group().register(channel);
/ /...
return regFuture;
}
Copy the codeStill focusing on the core code, leaving aside the bits and pieces, we see that initAndRegister() does a few things: 1. New a channel; 2. Init the channel 3. Register the channel into an object
Let’s analyze these three things step by step
1. A new channel
Netty defines a channel as follows
A nexus to a network socket or a component which is capable of I/O operations such as read, write, connect, and bind
In this case, since the channel is created when the service is started, we can represent a pipeline through which the server is bound, corresponding to the ServerSocket in normal Socket programming
It turns out that this channel is channelFactory new, which has a very simple interface
public interface ChannelFactory<T extends Channel> extends io.netty.bootstrap.ChannelFactory<T> {
/** * Creates a new channel. */
@Override
T newChannel(a);
}
Copy the codeWith just one method, let’s look at where channelFactory is assigned
AbstractBootstrap.java
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 (B) this;
}
Copy the codeIt’s assigned here, and we go back and look at where this function was called, and it turns out that it’s in this function that ChannelFactory is new
public B channel(Class<? extends C> channelClass) {
if (channelClass == null) {
throw new NullPointerException("channelClass");
}
return channelFactory(new ReflectiveChannelFactory<C>(channelClass));
}
Copy the codeHere, when our demo calls the channel(channelClass) method, it uses channelClass as the constructor of ReflectiveChannelFactory to create a ReflectiveChannelFactory
The code of the Demo is as follows:
.channel(NioServerSocketChannel.class);
Copy the codeAnd then we go back to the beginning of this section
channelFactory.newChannel();
Copy the codeWe can infer that, in the end, is calling to ReflectiveChannelFactory. NewChannel () method, follow up
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(a) {
try {
return clazz.newInstance();
} catch (Throwable t) {
throw new ChannelException("Unable to create Channel from class "+ clazz, t); }}}Copy the codeSee clazz. NewInstance (); , we understand, is to create an object by means of reflection, and this class is our incoming in ServerBootstrap NioServerSocketChannel. Class
As a result, it goes all the way around and creating a channel is equivalent to calling the default constructor new to create a NioServerSocketChannel object
Details here, read the source code, there are two ways of reading, one kind is back, can use an object step by step back, for example, will find at the beginning of the object is to create the code block, there is a kind of way is a top-down, stepwise analysis, generally with the analysis of the specific method, skilled and magical craftsmanship, the last piece together a complete process
We can then focus on the default constructor of the NioServerSocketChannel
private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();
public NioServerSocketChannel(a) {
this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}
Copy the code
private static ServerSocketChannel newSocket(SelectorProvider provider) {
/ /...
return provider.openServerSocketChannel();
}
Copy the codeThrough SelectorProvider. OpenServerSocketChannel () to create a server side channel, then into the following method
public NioServerSocketChannel(ServerSocketChannel channel) {
super(null, channel, SelectionKey.OP_ACCEPT);
config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}
Copy the codeHere is the first line of code and ran into the parent class, the second line, a NioServerSocketChannelConfig new comes out, its top level interface for ChannelConfig, netty official described as follows
A set of configuration properties of a Channel.
Basically can determine, ChannelConfig is also a netty inside a core module, first look at the source code, see here, we don’t need to dig into this object, but when used to come back to dig, as long as remember, this object is created when the NioServerSocketChannel object
We continue to trace the NioServerSocketChannel’s parent class
AbstractNioMessageChannel.java
protected AbstractNioMessageChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
super(parent, ch, readInterestOp);
}
Copy the codeKeep chasing
AbstractNioChannel.java
protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
super(parent);
this.ch = ch;
this.readInterestOp = readInterestOp;
/ /...
ch.configureBlocking(false);
/ /...
}
Copy the codeHere, simply to front the provider. OpenServerSocketChannel (); Create a ServerSocketChannel and save it to a member variable, then call ch.configureBlocking(false); Set the channel to non-blocking mode, standard JDK NIO programming play
Selectionkey.op_accept; selectionKey.op_accept; super(parent); (Parent is null and passed in)
AbstractChannel.java
protected AbstractChannel(Channel parent) {
this.parent = parent;
id = newId();
unsafe = newUnsafe();
pipeline = newChannelPipeline();
}
Copy the codeHere, we have three new components, and we assign values to member variables, which are
id = newId();
protected ChannelId newId(a) {
return DefaultChannelId.newInstance();
}
Copy the codeThe ID is the unique identifier of each channel in Netty
unsafe = newUnsafe();
protected abstract AbstractUnsafe newUnsafe(a);
Copy the codeLook at the definition for Unsafe
Unsafe operations that should never be called from user-code. These methods are only provided to implement the actual transport, and must be invoked from an I/O thread
After capturing another big component of Netty, we can forget what TA does, except that the newUnsafe method here finally belongs to the NioServerSocketChannel class
The last
pipeline = newChannelPipeline();
protected DefaultChannelPipeline newChannelPipeline(a) {
return new DefaultChannelPipeline(this);
}
protected DefaultChannelPipeline(Channel channel) {
this.channel = ObjectUtil.checkNotNull(channel, "channel");
succeededFuture = new SucceededChannelFuture(channel, null);
voidPromise = new VoidChannelPromise(channel, true);
tail = new TailContext(this);
head = new HeadContext(this);
head.next = tail;
tail.prev = head;
}
Copy the codeWhen we first look at this code, we may not know what DefaultChannelPipeline is for. We still use the above method to look at the definition of the top-level interface ChannelPipeline
A list of ChannelHandlers which handles or intercepts inbound events and outbound operations of a Channel
As you can see from the documentation for this class, this interface is basically one of the core modules of Netty
At this point, we have finally created a server channel. When we put these details together, we have extracted the basic components of Netty, summarized as follows
- Channel
- ChannelConfig
- ChannelId
- Unsafe
- Pipeline
- ChannelHander
When we first look at the code, our goal is to follow the line of code that the server starts. We will write down the above components first, and when the code is finished, we can analyze them from top to bottom, layer by layer. I will go into each component in the source code series later
In conclusion, the user calls the method bootstrap.bind (port) to create a New NioServerSocketChannel object by means of reflection. In the process of creating the new object, a series of core components are created
2. The init this channel
At this point, you might want to skip to the very beginning of the article and remember, the first step, the newChannel, we’re going to do init on that channel, and what does init do? We’re going to go deeper
@Override
void init(Channel channel) throws Exception {
finalMap<ChannelOption<? >, Object> options = options0();synchronized (options) {
channel.config().setOptions(options);
}
finalMap<AttributeKey<? >, Object> attrs = attrs0();synchronized (attrs) {
for(Entry<AttributeKey<? >, Object> e: attrs.entrySet()) {@SuppressWarnings("unchecked")
AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
channel.attr(key).set(e.getValue());
}
}
ChannelPipeline p = channel.pipeline();
final EventLoopGroup currentChildGroup = childGroup;
final ChannelHandler currentChildHandler = childHandler;
finalEntry<ChannelOption<? >, Object>[] currentChildOptions;finalEntry<AttributeKey<? >, Object>[] currentChildAttrs;synchronized (childOptions) {
currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
}
synchronized (childAttrs) {
currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
}
p.addLast(new ChannelInitializer<Channel>() {
@Override
public void initChannel(Channel ch) throws Exception {
final ChannelPipeline pipeline = ch.pipeline();
ChannelHandler handler = config.handler();
if(handler ! =null) {
pipeline.addLast(handler);
}
ch.eventLoop().execute(new Runnable() {
@Override
public void run(a) {
pipeline.addLast(newServerBootstrapAcceptor( currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs)); }}); }}); }Copy the codeWhen you first see this, you might think, wow, that’s a long way to go. Is that how you look at it? Do you still remember what we said before? Step-by-step disassembly and finally normalization. The following is my disassembly steps
1. Set Option and attr
finalMap<ChannelOption<? >, Object> options = options0();synchronized (options) {
channel.config().setOptions(options);
}
finalMap<AttributeKey<? >, Object> attrs = attrs0();synchronized (attrs) {
for(Entry<AttributeKey<? >, Object> e: attrs.entrySet()) {@SuppressWarnings("unchecked") AttributeKey<Object> key = (AttributeKey<Object>) e.getKey(); channel.attr(key).set(e.getValue()); }}Copy the codeWe call options0() and attrs0(), and then inject the options and attrs into channelConfig or channel. You don’t need to know much about options and attr. Just look at ChannelOption, the top interface, and look at the specific inheritance of channel, which I’ll save for the source analysis series later
2. Set the option and attR of the new access channel
final EventLoopGroup currentChildGroup = childGroup;
final ChannelHandler currentChildHandler = childHandler;
finalEntry<ChannelOption<? >, Object>[] currentChildOptions;finalEntry<AttributeKey<? >, Object>[] currentChildAttrs;synchronized (childOptions) {
currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
}
synchronized (childAttrs) {
currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
}
Copy the codeHere, similar to above, except that instead of setting these two properties for the current channel, we set the corresponding channel for the new incoming connection. Since we are only concerned with how the server is started in this article, the access connection will be analyzed in detail in the next article, okay
3. Add a new connection processor
p.addLast(new ChannelInitializer<Channel>() {
@Override
public void initChannel(Channel ch) throws Exception {
final ChannelPipeline pipeline = ch.pipeline();
ChannelHandler handler = config.handler();
if(handler ! =null) {
pipeline.addLast(handler);
}
ch.eventLoop().execute(new Runnable() {
@Override
public void run(a) {
pipeline.addLast(newServerBootstrapAcceptor( currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs)); }}); }});Copy the codeAs a final step, p.adddlast () adds a ServerBootstrapAcceptor to the Pipeline of the serverChannel. As you can see from the name, this is an accessor that accepts new requests and throws them to an event loop. Let’s not do too much analysis
To sum up, init does not start the service. It just initializes some basic configuration and properties, and adds an accessor to the pipeline to accept new connections
3. Register the channel to an object
In this step, we are analyzing the following methods
ChannelFuture regFuture = config().group().register(channel);
Copy the codeCall register in NioEventLoop
@Override
public ChannelFuture register(Channel channel) {
return register(new DefaultChannelPromise(channel, this));
}
Copy the code@Override
public ChannelFuture register(final ChannelPromise promise) {
ObjectUtil.checkNotNull(promise, "promise");
promise.channel().unsafe().register(this, promise);
return promise;
}
Copy the codeOkay, now that WE’re at this point, remember what object should be returned from unsafe()? Now, if you don’t remember, you can look at the previous description of unsafe, or the fastest way to do that is to debug over here, follow the register method, and see what type of unsafe it is
We followed in and found out it was
AbstractUnsafe.java
@Override
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
// ...
AbstractChannel.this.eventLoop = eventLoop;
// ...
register0(promise);
}
Copy the codeAgain, we just need to focus, bind the EventLoop EventLoop to the NioServerSocketChannel, and then call register0()
private void register0(ChannelPromise promise) {
try {
boolean firstRegistration = neverRegistered;
doRegister();
neverRegistered = false;
registered = true;
pipeline.invokeHandlerAddedIfNeeded();
safeSetSuccess(promise);
pipeline.fireChannelRegistered();
if (isActive()) {
if (firstRegistration) {
pipeline.fireChannelActive();
} else if(config().isAutoRead()) { beginRead(); }}}catch(Throwable t) { closeForcibly(); closeFuture.setClosed(); safeSetFailure(promise, t); }}Copy the codeThis one is actually pretty clear, so call doRegister(); , specific do speak again later, and then call invokeHandlerAddedIfNeeded (), as a result, the console the first line is printed
handlerAdded
Copy the codeHow does it end up being called, which we’ll talk about later when we parse the pipeline
Then call pipeline. FireChannelRegistered (); After the call, the console displays as
handlerAdded
channelRegistered
Copy the codeKeep going
if (isActive()) {
if (firstRegistration) {
pipeline.fireChannelActive();
} else if(config().isAutoRead()) { beginRead(); }}Copy the codeAt this point, you might think that the last line on the console
pipeline.fireChannelActive();
Copy the codeWith this line of code output, let’s first look at the isActive() method
@Override
public boolean isActive(a) {
return javaChannel().socket().isBound();
}
Copy the codeIt’s finally called into the JDK
ServerSocket.java
/**
* Returns the binding state of the ServerSocket.
*
* @return true if the ServerSocket succesfuly bound to an address
* @since1.4 * /
public boolean isBound(a) {
// Before 1.3 ServerSockets were always bound during creation
return bound || oldImpl;
}
Copy the codeHere isBound() returns false, but from the process we’ve followed so far, we haven’t bound a ServerSocket to an address, so isActive() returns false, We don’t have successfully into the pipeline. FireChannelActive (); Method, so who is the last line of output, we are a little crazy, in fact, as long as you are familiar with the IDE, to locate the function call stack, it is very easy
Here’s how I use Intellij to locate function calls
We put a breakpoint on this line of code where the final output text is, and we debug, and we run to this line, and intellij automatically pulls up the call stack for us, and the only thing we have to do is move the arrow keys, and we see the full chain of calls to the function
If you see that the most recent initiate of a method is the run method of a thread Runnable, then put a breakpoint where the Runnable object method was committed, remove other breakpoints, and debug again. For example, we first debug the latest Runnable in the call stack as follows
if(! wasActive && isActive()) { invokeLater(new Runnable() {
@Override
public void run(a) { pipeline.fireChannelActive(); }}); }Copy the codeWe stopped at the line of the pipeline. FireChannelActive (); If we want to look at the initial call, we have to jump out and break at if (! WasActive && isActive()), because many tasks in Netty are called by the asynchronous (reactor) thread (see the last step in the Reactor thread trilogy). If we want to look at the first method call, We have to look at where the Runnable was committed, recursively, to find the line of “missing code.”
Finally, in this way, finally find the pipeline. The fireChannelActive (); The code that makes the call, unfortunately, happens to be the doBind0() method below
doBind0()
private static void doBind0(
final ChannelFuture regFuture, final Channel channel,
final SocketAddress localAddress, final ChannelPromise promise) {
channel.eventLoop().execute(new Runnable() {
@Override
public void run(a) {
if (regFuture.isSuccess()) {
channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
} else{ promise.setFailure(regFuture.cause()); }}}); }Copy the codeWe find that when calling doBind0(…) Netty source code Analysis: Unlocking the mask of the Reactor thread
Ok, next we go to the channel.bind() method
AbstractChannel.java
@Override
public ChannelFuture bind(SocketAddress localAddress) {
return pipeline.bind(localAddress);
}
Copy the codeDiscovery is a call to the PIPELINE’s bind method
@Override
public final ChannelFuture bind(SocketAddress localAddress) {
return tail.bind(localAddress);
}
Copy the codeIf you don’t know what tail is, you can go back to the beginning. Tail was used to create pipelines. I will explain the tail classes later in the source code series, but the only good way to know where the code is going is to debug step in. For reasons of space, I won’t go into detail
Finally, we come to the following area
HeadContext.java
@Override
public void bind( ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise)
throws Exception {
unsafe.bind(localAddress, promise);
}
Copy the codeUnsafe should be AbstractUnsafe, or NioMessageUnsafe
We go to its bind method
@Override
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
// ...
boolean wasActive = isActive();
// ...
doBind(localAddress);
if(! wasActive && isActive()) { invokeLater(new Runnable() {
@Override
public void run(a) { pipeline.fireChannelActive(); }}); } safeSetSuccess(promise); }Copy the codeObviously following the normal process, we have already analyzed isActive(); Method returns false, into the doBind (), if the channel is activated, it launched a pipeline. The fireChannelActive (); Calls, eventually calls the user method, prints out the last line on the console, so now you see why you end up printing out those three lines in order on the console
The doBind() method is also simple
protected void doBind(SocketAddress localAddress) throws Exception {
if (PlatformDependent.javaVersion() >= 7) {
//noinspection Since15
javaChannel().bind(localAddress, config.getBacklog());
} else{ javaChannel().socket().bind(localAddress, config.getBacklog()); }}Copy the codeFinally, you get to the BIND method in the JDK, and after that line of code, normally, you actually bind the port.
In addition, through the way of the top-down analysis of pipeline. The call fireChannelActive (); Method, the following method is called
HeadContext.java
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelActive();
readIfIsAutoRead();
}
Copy the codeEnter the readIfIsAutoRead
private void readIfIsAutoRead(a) {
if(channel.config().isAutoRead()) { channel.read(); }}Copy the codeAnalyze the isAutoRead method
private volatile int autoRead = 1;
public boolean isAutoRead(a) {
return autoRead == 1;
}
Copy the codeAs you can see, the isAutoRead method returns true by default, which leads to the following method
public Channel read(a) {
pipeline.read();
return this;
}
Copy the codeThe final call is to
AbstractNioUnsafe.java
protected void doBeginRead(a) throws Exception {
final SelectionKey selectionKey = this.selectionKey;
if(! selectionKey.isValid()) {return;
}
readPending = true;
final int interestOps = selectionKey.interestOps();
if ((interestOps & readInterestOp) == 0) { selectionKey.interestOps(interestOps | readInterestOp); }}Copy the codeThis. SelectionKey is the object that we returned in the register step. When we register, the ops is 0
Remember registration
AbstractNioChannel
selectionKey = javaChannel().register(eventLoop().selector, 0.this)
Copy the codeSo this is the equivalent of taking the registered OPS, passing the if condition, and calling it
selectionKey.interestOps(interestOps | readInterestOp);
Copy the codeSelectionkey.op_accept, selectionKey.op_Accept, selectionKey.op_Accept, selectionKey.op_Accept
summary
Finally, let’s wrap up the process 1 through which Netty starts a service. Set to start the class parameter, the most important thing is to set the channel 2. Create a server corresponding channel, create the major components, including ChannelConfig, ChannelId, ChannelPipeline, ChannelHandler, Unsafe, etc. 3. Initialize the corresponding channel of the server, set some attr and option, and set attr and option of sub-channel, add new channel accessor to the server channel, and start addHandler,register and other events 4. Call the underlying JDK to do the port binding, and trigger the active event, when the active trigger, the actual service port binding
In addition, the article to read the source code in detail may also be able to bring you some help.
If you want to learn Netty systematically, my small book “Netty Introduction and actual Practice: Imitation wechat IM instant messaging system” can help you, if you want to learn Netty principles systematically, then you must not miss my Netty source analysis series of videos: Coding.imooc.com/class/230.h…