netty原始碼分析之服務端啟動
阿新 • • 發佈：2018-11-03
ServerBootstrap與Bootstrap分別是netty中服務端與客戶端的引導類，主要負責服務端與客戶端初始化、配置及啟動引導等工作，接下來我們就通過netty原始碼中的示例對ServerBootstrap與Bootstrap的原始碼進行一個簡單的分析。首先我們知道這兩個類都繼承自AbstractBootstrap類
接下來我們就通過netty原始碼中ServerBootstrap的例項入手對其進行一個簡單的分析。
// Configure the server.
EventLoopGroup bossGroup = new
接下來我們主要從服務端的socket在哪裡初始化與哪裡accept連線這兩個問題入手對netty服務端啟動的流程進行分析；
我們首先要知道，netty服務的啟動其實可以分為以下四步：
- 建立服務端Channel
- 初始化服務端Channel
- 註冊Selector
- 埠繫結
一、建立服務端Channel
1、服務端Channel的建立，主要為以下流程
我們通過跟蹤程式碼能夠看到
final ChannelFuture regFuture = initAndRegister();// 初始化並建立 NioServerSocketChannel
我們在initAndRegister()中可以看到channel的初始化。
channel = channelFactory.newChannel(); // 通過 反射工廠建立一個 NioServerSocketChannel
我進一步看newChannel()中的原始碼，在ReflectiveChannelFactory這個反射工廠中，通過clazz這個類的反射建立了一個服務端的channel。
@Override public T newChannel() { try { return clazz.getConstructor().newInstance();//反射建立 } catch (Throwable t) { throw new ChannelException("Unable to create Channel from class " + clazz, t); } }
既然通過反射，我們就要知道clazz類是什麼，那麼我我們來看下channelFactory這個工廠類是在哪裡初始化的，初始化的時候我們傳入了哪個channel。
這裡我們需要看下demo例項中初始化ServerBootstrap時.channel(NioServerSocketChannel.class)這裡的具體實現，我們看下原始碼
public B channel(Class<? extends C> channelClass) { if (channelClass == null) { throw new NullPointerException("channelClass"); } return channelFactory(new ReflectiveChannelFactory<C>(channelClass)); }
通過上面的程式碼我可以直觀的看出正是在這裡我們通過NioServerSocketChannel這個類構造了一個反射工廠。
那麼到這裡就很清楚了，我們建立的Channel就是一個NioServerSocketChannel，那麼具體的建立我們就需要看下這個類的建構函式。首先我們看下一個NioServerSocketChannel建立的具體流程
首先是newsocket(),我們先看下具體的程式碼，在NioServerSocketChannel的建構函式中我們建立了一個jdk原生的ServerSocketChannel
/** * Create a new instance */ public NioServerSocketChannel() { this(newSocket(DEFAULT_SELECTOR_PROVIDER));//傳入預設的SelectorProvider } 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. * * See <a href="https://github.com/netty/netty/issues/2308">#2308</a>. */ return provider.openServerSocketChannel();//可以看到建立的是jdk底層的ServerSocketChannel } catch (IOException e) { throw new ChannelException( "Failed to open a server socket.", e); } }
第二步是通過NioServerSocketChannelConfig配置服務端Channel的建構函式，在程式碼中我們可以看到我們把NioServerSocketChannel這個類傳入到了NioServerSocketChannelConfig的建構函式中進行配置
/** * Create a new instance using the given {@link ServerSocketChannel}. */ public NioServerSocketChannel(ServerSocketChannel channel) { super(null, channel, SelectionKey.OP_ACCEPT);//呼叫父類建構函式,傳入建立的channel config = new NioServerSocketChannelConfig(this, javaChannel().socket()); }
第三步在父類AbstractNioChannel的建構函式中把建立服務端的Channel設定為非阻塞模式
/** * Create a new instance * * @param parent the parent {@link Channel} by which this instance was created. May be {@code null} * @param ch the underlying {@link SelectableChannel} on which it operates * @param readInterestOp the ops to set to receive data from the {@link SelectableChannel} */ protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) { super(parent); this.ch = ch;//這個ch就是傳入的通過jdk建立的Channel this.readInterestOp = readInterestOp; try { ch.configureBlocking(false);//設定為非阻塞 } catch (IOException e) { try { ch.close(); } catch (IOException e2) { if (logger.isWarnEnabled()) { logger.warn( "Failed to close a partially initialized socket.", e2); } } throw new ChannelException("Failed to enter non-blocking mode.", e); } }
第四步呼叫AbstractChannel這個抽象類的建構函式設定Channel的id（每個Channel都有一個id，唯一標識）,unsafe（tcp相關底層操作），pipeline（邏輯鏈）等，而不管是服務的Channel還是客戶端的Channel都繼承自這個抽象類，他們也都會有上述相應的屬性。我們看下AbstractChannel的建構函式
/** * Creates a new instance. * * @param parent * the parent of this channel. {@code null} if there's no parent. */ protected AbstractChannel(Channel parent) { this.parent = parent; id = newId();//建立Channel唯一標識 unsafe = newUnsafe();//netty封裝的TCP 相關操作類 pipeline = newChannelPipeline();//邏輯鏈 }
2、初始化服務端建立的Channel
init(channel);// 初始化這個 NioServerSocketChannel
我們首先列舉下init(channel)中具體都做了哪了些功能：
- 設定ChannelOptions、ChannelAttrs ,配置服務端Channel的相關屬性；
- 設定ChildOptions、ChildAttrs，配置每個新連線的Channel的相關屬性；
- Config handler，配置服務端pipeline;
- add ServerBootstrapAcceptor,新增聯結器，對accpet接受到的新連線進行處理，新增一個nio執行緒；
那麼接下來我們通過程式碼，對每一步設定進行一下分析：
首先是在SeverBootstrap的init()方法中對ChannelOptions、ChannelAttrs 的配置的關鍵程式碼
final Map<ChannelOption<?>, Object> options = options0();//拿到你設定的option synchronized (options) { setChannelOptions(channel, options, logger);//設定NioServerSocketChannel相應的TCP引數，其實這一步就是把options設定到channel的config中 } final Map<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()); } }
然後是對ChildOptions、ChildAttrs配置的關鍵程式碼
//可以看到兩個都是區域性變數，會在下面設定pipeline時用到 final Entry<ChannelOption<?>, Object>[] currentChildOptions; final Entry<AttributeKey<?>, Object>[] currentChildAttrs; synchronized (childOptions) { currentChildOptions = childOptions.entrySet().toArray(newOptionArray(0)); } synchronized (childAttrs) { currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(0)); }
第三步對服務端Channel的handler進行配置
p.addLast(new ChannelInitializer<Channel>() { @Override public void initChannel(final Channel ch) throws Exception { final ChannelPipeline pipeline = ch.pipeline(); ChannelHandler handler = config.handler();//拿到我們自定義的hanler if (handler != null) { pipeline.addLast(handler); } ch.eventLoop().execute(new Runnable() { @Override public void run() { pipeline.addLast(new ServerBootstrapAcceptor( ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs)); } }); } });
第四步新增ServerBootstrapAcceptor聯結器，這個是netty向服務端Channel自定義新增的一個handler，用來處理新連線的新增與屬性配置，我們來看下關鍵程式碼
ch.eventLoop().execute(new Runnable() { @Override public void run() { //在這裡會把我們自定義的ChildGroup、ChildHandler、ChildOptions、ChildAttrs相關配置傳入到ServerBootstrapAcceptor建構函式中，並繫結到新的連線上 pipeline.addLast(new ServerBootstrapAcceptor( ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs)); } });
三、註冊Selector
一個服務端的Channel建立完畢後，下一步就是要把它註冊到一個事件輪詢器Selector上，在initAndRegister()中我們把上面初始化的Channel進行註冊
ChannelFuture regFuture = config().group().register(channel);//註冊我們已經初始化過的Channel
而這個register具體實現是在AbstractChannel中的AbstractUnsafe抽象類中的
/** * 1、先是一系列的判斷。 * 2、判斷當前執行緒是否是給定的 eventLoop 執行緒。注意：這點很重要，Netty 執行緒模型的高效能取決於對於當前執行的Thread 的身份的確定。如果不在當前執行緒，那麼就需要很多同步措施（比如加鎖），上下文切換等耗費效能的操作。 * 3、非同步（因為我們這裡直到現在還是 main 執行緒在執行，不屬於當前執行緒）的執行 register0 方法。 */ @Override public final void register(EventLoop eventLoop, final ChannelPromise promise) { if (eventLoop == null) { throw new NullPointerException("eventLoop"); } if (isRegistered()) { promise.setFailure(new IllegalStateException("registered to an event loop already")); return; } if (!isCompatible(eventLoop)) { promise.setFailure( new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName())); return; } AbstractChannel.this.eventLoop = eventLoop;//繫結執行緒 if (eventLoop.inEventLoop()) { register0(promise);//實際的註冊過程 } else { try { eventLoop.execute(new Runnable() { @Override public void run() { register0(promise); } }); } catch (Throwable t) { logger.warn( "Force-closing a channel whose registration task was not accepted by an event loop: {}", AbstractChannel.this, t); closeForcibly(); closeFuture.setClosed(); safeSetFailure(promise, t); } } }
首先我們對整個註冊的流程做一個梳理
接下來我們進入register0()方法看下注冊過程的具體實現
private void register0(ChannelPromise promise) { try { // check if the channel is still open as it could be closed in the mean time when the register // call was outside of the eventLoop if (!promise.setUncancellable() || !ensureOpen(promise)) { return; } boolean firstRegistration = neverRegistered; doRegister();//jdk channel的底層註冊 neverRegistered = false; registered = true; // 觸發繫結的handler事件 // Ensure we call handlerAdded(...) before we actually notify the promise. This is needed as the // user may already fire events through the pipeline in the ChannelFutureListener. pipeline.invokeHandlerAddedIfNeeded(); safeSetSuccess(promise); pipeline.fireChannelRegistered(); // Only fire a channelActive if the channel has never been registered. This prevents firing // multiple channel actives if the channel is deregistered and re-registered. if (isActive()) { if (firstRegistration) { pipeline.fireChannelActive(); } else if (config().isAutoRead()) { // This channel was registered before and autoRead() is set. This means we need to begin read // again so that we process inbound data. // // See https://github.com/netty/netty/issues/4805 beginRead(); } } } catch (Throwable t) { // Close the channel directly to avoid FD leak. closeForcibly(); closeFuture.setClosed(); safeSetFailure(promise, t); } }
AbstractNioChannel中doRegister()的具體實現就是把jdk底層的channel繫結到eventLoop的selecor上
@Override protected void doRegister() throws Exception { boolean selected = false; for (;;) { try { //把channel註冊到eventLoop上的selector上 selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this); return; } catch (CancelledKeyException e) { if (!selected) { // Force the Selector to select now as the "canceled" SelectionKey may still be // cached and not removed because no Select.select(..) operation was called yet. eventLoop().selectNow(); selected = true; } else { // We forced a select operation on the selector before but the SelectionKey is still cached // for whatever reason. JDK bug ? throw e; } } } }
到這裡netty就把服務端的channel註冊到了指定的selector上，下面就是服務埠的邦迪
三、埠繫結
首先我們梳理下netty中服務埠繫結的流程
我們來看下AbstarctUnsafe中bind()方法的具體實現
@Override public final void bind(final SocketAddress localAddress, final ChannelPromise promise) { assertEventLoop(); if (!promise.setUncancellable() || !ensureOpen(promise)) { return; } // See: https://github.com/netty/netty/issues/576 if (Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) && localAddress instanceof InetSocketAddress && !((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress() && !PlatformDependent.isWindows() && !PlatformDependent.maybeSuperUser()) { // Warn a user about the fact that a non-root user can't receive a // broadcast packet on *nix if the socket is bound on non-wildcard address. logger.warn( "A non-root user can't receive a broadcast packet if the socket " + "is not bound to a wildcard address; binding to a non-wildcard " + "address (" + localAddress + ") anyway as requested."); } boolean wasActive = isActive();//判斷繫結是否完成 try { doBind(localAddress);//底層jdk繫結埠 } catch (Throwable t) { safeSetFailure(promise, t); closeIfClosed(); return; } if (!wasActive && isActive()) { invokeLater(new Runnable() { @Override public void run() { pipeline.fireChannelActive();//觸發ChannelActive事件 } }); } safeSetSuccess(promise); }
在doBind(localAddress)中netty實現了jdk底層埠的繫結
@Override protected void doBind(SocketAddress localAddress) throws Exception { if (PlatformDependent.javaVersion() >= 7) { javaChannel().bind(localAddress, config.getBacklog()); } else { javaChannel().socket().bind(localAddress, config.getBacklog()); } }
在 pipeline.fireChannelActive()中會觸發pipeline中的channelActive()方法
@Override public void channelActive(ChannelHandlerContext ctx) throws Exception { ctx.fireChannelActive(); readIfIsAutoRead(); }
在channelActive中首先會把ChannelActive事件往下傳播，然後呼叫readIfIsAutoRead()方法出觸發channel的read事件，而它最終呼叫AbstractNioChannel中的doBeginRead()方法
@Override protected void doBeginRead() throws Exception { // Channel.read() or ChannelHandlerContext.read() was called final SelectionKey selectionKey = this.selectionKey; if (!selectionKey.isValid()) { return; } readPending = true; final int interestOps = selectionKey.interestOps(); if ((interestOps & readInterestOp) == 0) { selectionKey.interestOps(interestOps | readInterestOp);//readInterestOp為 SelectionKey.OP_ACCEPT } }
在doBeginRead()方法，netty會把accept事件註冊到Selector上。
到此我們對netty服務端的啟動流程有了一個大致的瞭解，整體可以概括為下面四步：
1、channelFactory.newChannel()，其實就是建立jdk底層channel，並初始化id、piepline等屬性；
2、init(channel)，新增option、attr等屬性，並新增ServerBootstrapAcceptor聯結器；
3、config().group().register(channel)，把jdk底層的channel註冊到eventLoop上的selector上；
4、doBind0(regFuture, channel, localAddress, promise)，完成服務端埠的監聽，並把accept事件註冊到selector上；
以上就是對netty服務端啟動流程進行的一個簡單分析，有很多細節沒有關注與深入，其中如有不足與不正確的地方還望指出與海涵。