赐我白日梦
赐我白日梦

Netty-Pipeline组件

首先我们知道,在NIO网络编程模型中,IO操作直接和channel相关,比如客户端的请求连接,或者向服务端发送数据, 服务端都要从客户端的channel获取这个数据

那么channelPipeline是什么?

其实,这个channelPepiline是Netty增加给原生的channel的组件,在ChannelPipeline接口的上的注解阐述了channelPipeline的作用,这个channelPipeline是高级过滤器的实现,netty将chanenl中数据导向channelPipeline,进而给了用户对channel中数据的百分百的控制权, 此外,channelPipeline数据结构是双向链表,每一个节点都是channelContext,channelContext里面维护了对应的handler和pipeline的引用, 大概总结一下: 通过chanelPipeline,用户客户轻松的往channel写数据,从channel读数据

创建pipeline

通过前面几篇博客的追踪,我们知道无论我们是通过反射创建出服务端的channel也好,还是直接new创建客户端的channel也好,随着父类构造函数的逐层调用,最终我们都会在Channel体系的顶级抽象类AbstractChannel中,创建出Channel的一大组件 channelPipeline

于是我们程序的入口,AbstractChannel的pipeline = newChannelPipeline(); ,跟进去,看到他的源码如下:

protected DefaultChannelPipeline newChannelPipeline() {
    // todo 跟进去
    return new DefaultChannelPipeline(this);
}

可以看到,它创建了一个DefaultChannelPipeline(thisChannel)
DefaultChannelPipeline是channelPipeline的默认实现,他有着举足轻重的作用,我们看一下下面的 Channel ChannelContext ChannelPipeline的继承体系图,我们可以看到图中两个类,其实都很重要,

Netty-Pipeline组件_第1张图片

他们之间有什么关系呢?

当我们看完了DefaultChannelPipeline()构造中做了什么自然就知道了

// todo 来到这里
protected DefaultChannelPipeline(Channel channel) {
    this.channel = ObjectUtil.checkNotNull(channel, "channel");
    // todo 把当前的Channel 保存起来
    succeededFuture = new SucceededChannelFuture(channel, null);
    voidPromise =  new VoidChannelPromise(channel, true);

    // todo  这两方法很重要
    // todo 设置尾
    tail = new TailContext(this);
    // todo 设置头
    head = new HeadContext(this);

    // todo 双向链表关联
    head.next = tail;
    tail.prev = head;
}

主要做了如下几件事:

  • 初始化succeededFuture
  • 初始化voidPromise
  • 创建尾节点
  • 创建头节点
  • 关联头尾节点

其实,到现在为止,pipiline的初始化已经完成了,我们接着往下看

此外,我们看一下DefaultChannelPipeline的内部类和方法,如下图()

Netty-Pipeline组件_第2张图片

我们关注我圈出来的几部分

  • 两个重要的内部类
    • 头结点 HeaderContext
    • 尾节点 TailContext
    • PendingHandlerAddedTask 添加完handler之后处理的任务
    • PendingHandlerCallBack 添加完handler的回调
    • PengdingHandlerRemovedTask 移除Handler之后的任务
  • 大量的addXXX方法,
 final AbstractChannelHandlerContext head;
 final AbstractChannelHandlerContext tail;

跟进它的封装方法:

TailContext(DefaultChannelPipeline pipeline) {
        super(pipeline, null, TAIL_NAME, true, false);
        setAddComplete();
    }
// todo 来到这里
AbstractChannelHandlerContext(DefaultChannelPipeline pipeline, EventExecutor executor, String name,
                              boolean inbound, boolean outbound) {
    this.name = ObjectUtil.checkNotNull(name, "name");
    // todo 为ChannelContext的pipeline附上值了
    this.pipeline = pipeline;
    this.executor = executor;
    this.inbound = inbound;
    this.outbound = outbound;
    // Its ordered if its driven by the EventLoop or the given Executor is an instanceof OrderedEventExecutor.
    ordered = executor == null || executor instanceof OrderedEventExecutor;
}

我们可以看到,这个tail节点是inbound类型的处理器,一开始确实很纳闷,难道header不应该是Inbound类型的吗? 我也不买关子了,直接说为啥,

因为,对netty来说用发送过来的数据,要就从header节点开始往后传播,怎么传播呢? 因为是双向链表,直接找后一个节点,什么类型的节点呢? inbound类型的,于是数据msg就从header之后的第一个结点往后传播,如果说,一直到最后,都只是传播数据而没有任何处理就会传播到tail节点,因为tail也是inbound类型的, tail节点会替我们释放掉这个msg,防止内存泄露,当然如果我们自己使用了msg,而没往后传播,也没有释放,内存泄露是早晚的时,这就是为啥tail是Inbound类型的, header节点和它相反,在下面说

ok,现在知道了ChannelPipeline的创建了吧

Channelpipeline与ChannelHandler和ChannelHandlerContext之间的关系

它三者的关系也直接说了, 在上面pipeline的创建的过程中, DefaultChannelPipeline中的头尾节点都是ChannelHandlerContext, 这就意味着, 在pipeline双向链表的结构中,每一个节点都是一个ChannelHandlerContext, 而且每一个 ChannelHandlerContext维护一个handler,这一点不信可以看上图,ChannelHandlerContext的实现类DefaultChannelHandlerContext的实现类, 源码如下:

final class DefaultChannelHandlerContext extends AbstractChannelHandlerContext {
// todo  Context里面有了 handler的引用
private final ChannelHandler handler;

// todo 创建默认的 ChannelHandlerContext,
DefaultChannelHandlerContext(
        DefaultChannelPipeline pipeline, EventExecutor executor, String name, ChannelHandler handler) {
    super(pipeline, executor, name, isInbound(handler), isOutbound(handler));
    if (handler == null) {
        throw new NullPointerException("handler");
    }
    this.handler = handler;

ChannelHandlerContext 接口同时继承ChannelOutBoundInvoker和和ChannelInBoundInvoker使得他同时拥有了传播入站事件和出站事件的能力, ChannelHandlerContext把事件传播之后,是谁处理的呢? 当然是handler 下面给出ChannelHandler的继承体系图,可以看到针对入站出来和出站处理ChannelHandler有不同的继承分支应对

Netty-Pipeline组件_第3张图片

添加一个新的节点:

一般我们都是通过ChanelInitialezer动态的一次性添加多个handler, 下面就去看看,在服务端启动过程中,ServerBootStrap的init(),如下源码:解析我写在代码下面

// todo 这是ServerBootStrapt对 他父类初始化 channel的实现, 用于初始化 NioServerSocketChannel
@Override
void init(Channel channel) throws Exception {
// todo ChannelOption 是在配置 Channel 的 ChannelConfig 的信息
final Map, Object> options = options0();
synchronized (options) {
    // todo 把 NioserverSocketChannel 和 options Map传递进去, 给Channel里面的属性赋值
    // todo 这些常量值全是关于和诸如TCP协议相关的信息
    setChannelOptions(channel, options, logger);
}
    // todo 再次一波 给Channel里面的属性赋值  attrs0()是获取到用户自定义的业务逻辑属性 --  AttributeKey
final Map, Object> attrs = attrs0();
// todo 这个map中维护的是 程序运行时的 动态的 业务数据 , 可以实现让业务数据随着netty的运行原来存进去的数据还能取出来
synchronized (attrs) {
    for (Entry, Object> e : attrs.entrySet()) {
        @SuppressWarnings("unchecked")
        AttributeKey key = (AttributeKey) e.getKey();
        channel.attr(key).set(e.getValue());
    }
}
// todo-------   options   attrs :   都可以在创建BootStrap时动态的传递进去
// todo ChannelPipeline   本身 就是一个重要的组件, 他里面是一个一个的处理器, 说他是高级过滤器,交互的数据 会一层一层经过它
// todo 下面直接就调用了 p , 说明,在channel调用pipeline方法之前, pipeline已经被创建出来了!,
// todo 到底是什么时候创建出来的 ?  其实是在创建NioServerSocketChannel这个通道对象时,在他的顶级抽象父类(AbstractChannel)中创建了一个默认的pipeline对象
/// todo 补充: ChannelHandlerContext 是 ChannelHandler和Pipeline 交互的桥梁
ChannelPipeline p = channel.pipeline();

// todo  workerGroup 处理IO线程
final EventLoopGroup currentChildGroup = childGroup;
// todo 我们自己添加的 Initializer
final ChannelHandler currentChildHandler = childHandler;

final Entry, Object>[] currentChildOptions;
final Entry, Object>[] currentChildAttrs;


// todo 这里是我们在Server类中添加的一些针对新连接channel的属性设置, 这两者属性被acceptor使用到!!!
synchronized (childOptions) {
    currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
}
synchronized (childAttrs) {
    currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
}

// todo 默认 往NioServerSocketChannel的管道里面添加了一个 ChannelInitializer  ,
// todo  ( 后来我们自己添加的ChildHandler 就继承了的这个ChannelInitializer , 而这个就继承了的这个ChannelInitializer 实现了ChannelHandler)
p.addLast(new ChannelInitializer() { // todo 进入addlast
    // todo  这个ChannelInitializer 方便我们一次性往pipeline中添加多个处理器
    @Override
        public void initChannel(final Channel ch) throws Exception {
            final ChannelPipeline pipeline = ch.pipeline();
            // todo  获取bootStrap的handler 对象, 没有返回空
            // todo  这个handler 针对bossgroup的Channel  , 给他添加上我们在server类中添加的handler()里面添加处理器
            ChannelHandler handler = config.handler();
            if (handler != null) {
                pipeline.addLast(handler);
            }

            // todo ServerBootstrapAcceptor 接收器, 是一个特殊的chanelHandler
             ch.eventLoop().execute(new Runnable() {
                @Override
                public void run() {
                    // todo !!! --   这个很重要,在ServerBootStrap里面,netty已经为我们生成了接收器  --!!!
                    // todo 专门处理新连接的接入, 把新连接的channel绑定在 workerGroup中的某一条线程上
                    // todo 用于处理用户的请求, 但是还有没搞明白它是怎么触发执行的
                    pipeline.addLast(new ServerBootstrapAcceptor(
                            // todo 这些参数是用户自定义的参数
                            // todo NioServerSocketChannel, worker线程组  处理器   关系的事件
                            ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                }
            });
    }
});
 
 
这个函数真的是好长,但是我们的重点放在ChannelInitializer身上, 现在的阶段, 当前的channel还没有注册上EventLoop上的Selector中
 
 
还有不是分析怎么添加handler? 怎么来这里了? 其实下面的 ServerBootstrapAcceptor就是一个handler
 
 
我们看一下上面的代码做了啥
 
 
ch.eventLoop().execute(new Runnable() {
    @Override
    public void run() {
        // todo !!! --   这个很重要,在ServerBootStrap里面,netty已经为我们生成了接收器  --!!!
        // todo 专门处理新连接的接入, 把新连接的channel绑定在 workerGroup中的某一条线程上
        // todo 用于处理用户的请求, 但是还有没搞明白它是怎么触发执行的
        pipeline.addLast(new ServerBootstrapAcceptor(
                // todo 这些参数是用户自定义的参数
                // todo NioServerSocketChannel, worker线程组  处理器   关系的事件
                ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
    }
});
 
 
懵逼不? 当时真的是给我整蒙圈了, 还没有关联上 EventLoop呢!!! 哪来的ch.eventLoop()....
 
 
后来整明白了,这其实是一个回调,netty提供给用户在任意时刻都可以往pipeline中添加handler的实现手段
 
 
那么在哪里回调呢? 其实是在 jdk原生的channel组册进EventLoop中的Selector后紧接着回调的,源码如下
 
 
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;
        // todo 进入这个方法doRegister()
        // todo 它把系统创建的ServerSocketChannel 注册进了选择器
        doRegister();
        neverRegistered = false;
        registered = true;
        
        // 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.
        // todo 确保在 notify the promise前调用 handlerAdded(...)
        // todo 这是必需的，因为用户可能已经通过ChannelFutureListener中的管道触发了事件。
        // todo 如果需要的话,执行HandlerAdded()方法
        // todo 正是这个方法, 回调了前面我们添加 Initializer 中添加 Accpter的重要方法
        pipeline.invokeHandlerAddedIfNeeded();
 
 
回调函数在pipeline.invokeHandlerAddedIfNeeded();, 看它的命名, 如果需要的话,执行handler已经添加完成了操作 哈哈,我们现在当然需要,刚添加了个ServerBootstrapAcceptor
 
 
在跟进入看源码之间,注意,方法是pipeline调用的, 那个pipeline呢? 就是上面我们说的DefaultChannelPipeline, ok,跟进源码,进入 DefaultChannelPipeline
 
 
// todo 执行handler的添加,如果 需要的话
final void invokeHandlerAddedIfNeeded() {
    assert channel.eventLoop().inEventLoop();
    if (firstRegistration) {
        firstRegistration = false;
        // todo 现在我们的channel已经注册在bossGroup中的eventLoop上了, 是时候回调执行那些在注册前添加的 handler了
        callHandlerAddedForAllHandlers();
    }
}
 
 
调用本类方法callHandlerAddedForAllHandlers(); 继续跟进下
 
 

// todo 回调原来在没有注册完成之前添加的handler
private void callHandlerAddedForAllHandlers() {
    final PendingHandlerCallback pendingHandlerCallbackHead;
    synchronized (this) {
        assert !registered;

        // This Channel itself was registered.
        registered = true;

        pendingHandlerCallbackHead = this.pendingHandlerCallbackHead;
        // Null out so it can be GC'ed.
        this.pendingHandlerCallbackHead = null;
    }
  PendingHandlerCallback task = pendingHandlerCallbackHead;
    while (task != null) {
        task.execute();
        task = task.next;
    }
}
 
 
我们它的动作task.execute();
 
 
其中的task是谁? pendingHandlerCallbackHead 这是DefaultChannelPipeline的内部类, 它的作用就是辅助完成 添加handler之后的回调, 源码如下:
 
 
private abstract static class PendingHandlerCallback implements Runnable {
    final AbstractChannelHandlerContext ctx;
    PendingHandlerCallback next;

    PendingHandlerCallback(AbstractChannelHandlerContext ctx) {
        this.ctx = ctx;
    }

    abstract void execute();
}
 
 
我们跟进上一步的task.execute()就会看到它的抽象方法,那么是谁实现的呢? 实现类是PendingHandlerAddedTask同样是DefaultChannelPipeline的内部类, 既然不是抽象类了, 就得同时实现他父类PendingHandlerCallback的抽象方法,其实有两个一是个excute()另一个是run() --Runable
 
 
我们进入看它是如何实现excute,源码如下:
 
 
@Override
void execute() {
EventExecutor executor = ctx.executor();
if (executor.inEventLoop()) {
    callHandlerAdded0(ctx);
} else {
    try {
        executor.execute(this);
    } catch (RejectedExecutionException e) {
        if (logger.isWarnEnabled()) {
            logger.warn(
                    "Can't invoke handlerAdded() as the EventExecutor {} rejected it, removing handler {}.",
                    executor, ctx.name(), e);
        }
        remove0(ctx);
        ctx.setRemoved();
    }
}
 
 
HandlerAdded()的回调时机
 
 
我们往下追踪, 调用类本类方法callHandlerAdded0(ctx); 源码如下:
 
 
// todo 重点看看这个方法 , 入参是刚才添加的  Context
private void callHandlerAdded0(final AbstractChannelHandlerContext ctx) {
try {
    // todo 在channel关联上handler之后并且把Context添加到了 Pipeline之后进行调用!!!
    ctx.handler().handlerAdded(ctx); // todo 他是诸多的回调方法中第一个被调用的
    ctx.setAddComplete();  // todo 修改状态
}
...
 
 
继续往下追踪
 
 
     
  
  • ctx.handler() -- 获取到了当前的channel
    •  
  
  • 调用channel的.handlerAdded(ctx);
    •  
 
 
 
这个handlerAdded()是定义在ChannelHandler中的回调方法, 什么时候回调呢? 当handler添加后回调, 因为我们知道,当服务端的channel在启动时,会通过 channelInitializer 添加那个ServerBootstrapAcceptor,所以ServerBootstrapAcceptor的handlerAdded（）的回调时机就在上面代码中的ctx.handler().handlerAdded(ctx);
 
 
如果直接点击去这个函数,肯定就是ChannelHandler接口中去; 那么 新的问题来了,谁是实现类? 答案是抽象类 ChannelInitializer`就在上面我们添加ServerBootstrapAcceptor就创建了一个ChannelInitializer`的匿名对象
 
 
它的继承体系图如下:
 
 
Netty-Pipeline组件_第4张图片
 
 
介绍这个ChannelInitializer 他是Netty提供的辅助类,用于提供针对channel的初始化工作,什么工作呢? 批量初始化channel
 
 
这个中有三个重要方法,如下
 
 
     
  
  • 重写的channel的handlerAdded(), 这其实也是handlerAdded()的回调的体现
    •  
  
  • 自己的initChannel()
    •  
  
  • 自己的remove()
    •  
 
 
 
继续跟进我们上面的handlerAdded(ChannelHandlerContext ctx) 源码如下:
 
 
   @Override
        public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
                initChannel(ctx); // todo 这个方法在上面, 进入 可以在 finally中 找到移除Initializer的逻辑
            }
    }
 
 
调用本类的initChannel(ctx); 源码如下:
 
 
  private boolean initChannel(ChannelHandlerContext ctx) throws Exception {
        if (initMap.putIfAbsent(ctx, Boolean.TRUE) == null) { // Guard against re-entrance.
            try {
                initChannel((C) ctx.channel());
            } catch (Throwable cause) {
                // Explicitly call exceptionCaught(...) as we removed the handler before calling initChannel(...).
                // We do so to prevent multiple calls to initChannel(...).
                exceptionCaught(ctx, cause);
            } finally {
                // todo    remove(ctx);  删除 ChannelInitializer
                remove(ctx);
            }
            return true;
        }
        return false;
    }
 
 
两个点
 
 
     
  
  • 第一: 继续调用本类的抽象方法initChannel((C) ctx.channel());
    •  
  
  • 第二: 移除了remove(ctx);
    •  
 
 
 
分开进行第一步
 
 
initChannel((C) ctx.channel()); 初始化channel,这个函数被设计成了抽象的, 问题来了, 实现类是谁? 实现类其实刚才说了,就是netty在添加ServerBootStrapAcceptor时创建的那个匿名内部类,我们跟进去看他的实现: 源码如下:
 
 
 @Override
    public void initChannel(final Channel ch) throws Exception {
        final ChannelPipeline pipeline = ch.pipeline();
        // todo  获取bootStrap的handler 对象, 没有返回空
        // todo  这个handler 针对bossgroup的Channel  , 给他添加上我们在server类中添加的handler()里面添加处理器
        ChannelHandler handler = config.handler();
        if (handler != null) {
            pipeline.addLast(handler);
        }

        // todo ServerBootstrapAcceptor 接收器, 是一个特殊的chanelHandler
         ch.eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                // todo !!! --   这个很重要,在ServerBootStrap里面,netty已经为我们生成了接收器  --!!!
                // todo 专门处理新连接的接入, 把新连接的channel绑定在 workerGroup中的某一条线程上
                // todo 用于处理用户的请求, 但是还有没搞明白它是怎么触发执行的
                pipeline.addLast(new ServerBootstrapAcceptor(
                        // todo 这些参数是用户自定义的参数
                        // todo NioServerSocketChannel, worker线程组  处理器   关系的事件
                        ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
            }
        });
}
 
 
实际上就是完成了一次方法的回调,成功添加了ServerBootstrapAcceptor处理器
 
 
删除一个节点
 
 
回来看第二步
 
 
remove(ctx); 删除一个节点, 把Initializer删除了? 是的, 把这个初始化器删除了, 为啥要把它删除呢, 说了好多次, 其实他是一个辅助类, 目的就是通过他往channel中一次性添加多个handler, 现在handler也添加完成了, 留着他也没啥用,直接移除了
 
 
我们接着看它的源码
 
 
 // todo 删除当前ctx 节点
    private void remove(ChannelHandlerContext ctx) {
        try {
            ChannelPipeline pipeline = ctx.pipeline();
            if (pipeline.context(this) != null) {
                pipeline.remove(this);
            }
        } finally {
            initMap.remove(ctx);
        }
    }
 
 
从pipeline中移除, 一路看过去,就会发现地城删除链表节点的操作
 
 
private static void remove0(AbstractChannelHandlerContext ctx) {
    AbstractChannelHandlerContext prev = ctx.prev;
    AbstractChannelHandlerContext next = ctx.next;
    prev.next = next;
    next.prev = prev;
}
 
 
 
 
inbound事件的传播
 
 
什么是inbound事件
 
 
inbound事件其实就是客户端主动发起事件,比如说客户端请求连接,连接后客户端有主动的给服务端发送需要处理的有效数据等,只要是客户端主动发起的事件,都算是Inbound事件,特征就是事件触发类型,当channel处于某个节点,触发服务端传播哪些动作
 
 
netty如何对待inbound
 
 
netty为了更好的处理channel中的数据,给jdk原生的channel添加了pipeline组件,netty会把原生jdk的channel中的数据导向这个pipeline,从pipeline中的header开始 往下传播, 用户对这个过程拥有百分百的控制权,可以把数据拿出来处理, 也可以往下传播,一直传播到tail节点,tail节点会进行回收,如果在传播的过程中,最终没到尾节点,自己也没回收,就会面临内存泄露的问题
 
 
一句话总结,面对Inbound的数据, 被动传播
 
 
netty知道客户端发送过来的数据是啥类型吗?
 
 
比如一个聊天程序,客户端可能发送的是心跳包,也可能发送的是聊天的内容,netty又不是人,他是不知道数据是啥的,他只知道来了数据,需要进一步处理,怎么处理呢? 把数据导向用户指定的handler链条
 
 
开始读源码
 
 
这里书接上一篇博客的尾部,事件的传播
 重点步骤如下
 
 
第一步: 等待服务端启动完成
 
 
第二步: 使用telnet模拟发送请求 --- > 新连接的接入逻辑
 
 
第三步: register0(ChannelPromise promise)方法中会传播channel激活事件 --> 目的是二次注册端口,
 
 
第三个也是我们程序的入手点: fireChannelActive() 源码如下:
 
 
@Override
public final ChannelPipeline fireChannelActive() {
    // todo ChannelActive从head开始传播
    AbstractChannelHandlerContext.invokeChannelActive(head);
    return this;
}
 
 
调用了AbstractChannelHandlerContext的invokeChannelActive方法
 
 
 
  
在这里,我觉得特别有必须有必要告诉自己 AbstractChannelHandlerContext的重要性,现在的DefaultChannelPipeline中的每一个节点,包括header,tail,以及我们自己的添加的,都是AbstractChannelHandlerContext类型,事件的传播围绕着AbstractChannelHandlerContext的方法开始,温习它的继承体系如下图
 
 
 
 
Netty-Pipeline组件_第5张图片
 
 
接着回到AbstractChannelHandlerContext.invokeChannelActive(head); , 很显然,这是个静态方法, 跟进去,源码如下:
 
 
// todo 来这
static void invokeChannelActive(final AbstractChannelHandlerContext next) {
EventExecutor executor = next.executor();
if (executor.inEventLoop()) {
    next.invokeChannelActive();
...
}
 
 
     
  
  • 第一点: inbound类型的事件是从header开始传播的 , next --> HeaderContext
    •  
  
  • 第二点: HeaderContext其实就是 AbstractChannelHandlerContext类型的,所以 invokeChannelActive()其实是当前类的方法
    •  
 
 
 
ok,跟进入看看他干啥了,源码:
 
 
// todo 使Channel活跃
private void invokeChannelActive() {
// todo 继续进去
((ChannelInboundHandler) handler()).channelActive(this);
}
 
 
我们看, 上面的代码做了如下几件事
 
 
     
  
  • handler() -- 返回当前的 handler, 就是从HandlerContext中拿出handler
    •  
  
  • 强转成ChannelInboundHandler类型的,因为他是InBound类型的处理器
    •  
 
 
 
如果我们用鼠标点击channelActive(this), 毫无疑问会进入ChannelInboundHandler,看到的是抽象方法
 
 
那么问题来了, 谁实现的它?
 
 
其实是headerContext 头结点做的, 之前说过,Inbound事件,是从header开始传播的,继续跟进去, 看源码:
 
 
// todo 来到这里, 分两步, 1. 把ChannelActive事件继续往下传播, 传播结束之后,做第二件事
// todo                  2.     readIfIsAutoRead();
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
// todo  fireChannelActive是在做了实际的端口绑定之后才触发回调
ctx.fireChannelActive();

// todo 默认方式注册一个read事件
// todo 跟进去， readIfIsAutoRead 作用是 把已经注册进selector上的事件， 重新注册绑定上在初始化NioServerSocketChannel时添加的Accept事件
// todo 目的是 新连接到来时， selector轮询到accept事件， 使得netty可以进一步的处理这个事件
readIfIsAutoRead();
}
 
 
其实这里有两种重要的事情 , 上面我们也看到了:
 
 
     
  
  • 向下传播channelActive() 目的是让header后面的用户添加的handler中的channelActive()被回调
    •  
  
  • readIfIsAutoRead(); 就是去注册Netty能看懂的感兴趣的事件
    •  
 
 
 
下面我们看它的事件往下传播, 于是重新回到了AbstractChannelHandlerContext, 源码如下:
 
 
public ChannelHandlerContext fireChannelActive() {
        invokeChannelActive(findContextInbound());
        return this;
    }
 
 
     
  
  • findContextInbound()找出下一个Inbound类型的处理器, 我们去看他的实现,源码如下:
    •  
 
 
 
 private AbstractChannelHandlerContext findContextInbound() {
    AbstractChannelHandlerContext ctx = this;
    do {
        ctx = ctx.next;
    } while (!ctx.inbound);
    return ctx;
}
 
 
是不是明明白白的? 从当前节点开始,往后变量整个链表, 下一个节点是谁呢? 在新链接接入的逻辑中,调用的ChannelInitializer我手动 批量添加了三个InboundHandler,按照我添加的顺序,他们会依次被找到
 
 
继续跟进本类方法invokeChannelActive(findContextInbound()),源码如下
 
 
  // todo 来这
static void invokeChannelActive(final AbstractChannelHandlerContext next) {
    EventExecutor executor = next.executor();
    if (executor.inEventLoop()) {
        next.invokeChannelActive();
...
 
 
一开始的next--> HeaderContext
 现在的 next就是header之后,我手动添加的Inbound的handler
 
 
同样是调用本类方法invokeChannelActive(),源码如下:
 
 
// todo 使Channel活跃
private void invokeChannelActive() {
    // todo 继续进去
    ((ChannelInboundHandler) handler()).channelActive(this);
 
 
再次看到,回调, 我添加的handler.channelActive(this); ,进入查看
 
 
public class MyServerHandlerA extends ChannelInboundHandlerAdapter {
// todo  当服务端的channel绑定上端口之后,就是 传播 channelActive 事件
// todo   事件传播到下面后,我们手动传播一个 channelRead事件
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    ctx.channel().pipeline().fireChannelRead("hello MyServerHandlerA");
}
 
 
在我处理器中,继续往下传播手动添加的数据"hello MyServerHandlerA"
 
 
同样她会按找上面的顺序依次传播下去
 
 
最终她会来到tail , 在tail做了如下的工作, 源码如下
 
 
 @Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    // todo channelRead
    onUnhandledInboundMessage(msg);
}

protected void onUnhandledInboundException(Throwable cause) {
try {
    logger.warn(
            "An exceptionCaught() event was fired, and it reached at the tail of the pipeline. " +
                    "It usually means the last handler in the pipeline did not handle the exception.",
            cause);
} finally {
    ReferenceCountUtil.release(cause);
}
}  

 
 
为什么Tail节点是 Inbound 类型的处理器?
 
 
上一步就说明了为什么Tail为什么设计成Inbound, channel中的数据,无论服务端有没有使用,最终都要被释放掉,tail可以做到收尾的工作, 清理内存
 
 
 
 
outbound事件的传播
 
 
什么是outBound事件
 
 
创建的outbound事件如: connect,disconnect,bind,write,flush,read,close,register,deregister, outbound类型事件更多的是服务端主动发起的事件,如给主动channel绑定上端口,主动往channel写数据,主动关闭用户的的连接
 
 
开始读源码
 
 
最典型的outbound事件,就是服务端往客户端写数据,准备测试用例如下:
 
 
public class OutBoundHandlerB extends ChannelOutboundHandlerAdapter {
    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        System.out.println( "hello OutBoundHandlerB");
        ctx.write(ctx, promise);
    }
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        ctx.executor().schedule(()->{
            // todo 模拟给 客户端一个响应
            ctx.channel().write("Hello World");
            // 写法二 :  ctx.write("Hello World");
        },3, TimeUnit.SECONDS);
    }
}
public class OutBoundHandlerA extends ChannelOutboundHandlerAdapter {
    // todo  当服务端的channel绑定上端口之后,就是 传播 channelActive 事件
    // todo   事件传播到下面后,我们手动传播一个 channelRead事件
    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        System.out.println( "hello OutBoundHandlerA");
        ctx.write(ctx, promise);
    }
}
public class OutBoundHandlerC extends ChannelOutboundHandlerAdapter {
    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        System.out.println( "hello OutBoundHandlerC");
        ctx.write(ctx, promise);
    }
}
 
 
下面我们把断点调试,把断点打在OutBoundHandlerB的handlerAdded上, 模拟向客户端发送数据, 启动程序,大概的流程如下
 
 
     
  
  • 等待服务端的启动
    •  
  
  • 服务端Selector轮询服务端channel可能发生的感兴趣的事件
    •  
  
  • 使用telnet向服务端发送请求
    •  
  
  • 服务端创建客户端的channel,在给客户端的原生的chanenl注册到 Selector上
    •  
  
  • 通过invokeChannelAddedIfNeeded()将我们添加在Initializer中的handler添加到pipeline中 
   
       
    
    • 挨个回调这些handler中的channelAdded()方法 
     
         
      
      • 和我们添加进去的顺序相反
        •  
      
      • C --> B --->A
        •  
     
      •  
    
    • 这些childHandler,会添加在每一条客户端的channel的pipeline
      •  
   
    •  
  
  • 传播channel注册完成事件
    •  
  
  • 传播channelActive事件 
   
       
    
    • readIfAutoRead() 完成二次注册netty可以处理的感兴趣的事件
      •  
   
    •  
 
 
 
此外,我们上面的write以定时任务的形式提交,当用ctx中的唯一的线程执行器三秒后去执行任务,所以程序会继续下去绑定端口, 过了三秒后把定时任务聚合到普通任务队列中,那时才会执行我们OutBoundHandlerB中的ctx.channel().write("Hello World");
 
 
outBound类型的handler添加顺序和执行顺序有什么关系
 
 
因为Outbound类型的事件是从链表的tail开始传播的,所以执行的顺序和我们的添加进去的顺序相反
 
 
篇幅太长了,重写补一张图
 
 
Netty-Pipeline组件_第6张图片
 
 
从ctx.channel().write("Hello World");开始跟源码, 鼠标直接跟进去,进入的是ChannelOutboundInvoker, 往channel中写,我们进入DefaultChannelPipeline的实现,源码如下
 
 
@Override
public final ChannelFuture write(Object msg) {
    return tail.write(msg);
}
 
 
再一次的验证了,出站的事件是从尾部往前传递的, 我们知道,tail节点是DefaultChannelHandlerContext类型的,所以我们看它的write()方法是如何实现的
 
 
@Override
public ChannelFuture write(Object msg) {
    return write(msg, newPromise());
}
 
 
其中msg-->我们要写会客户端的内容, newPromise()默认的promise()
 ,继续跟进本类方法write(msg, newPromise()),源码如下:
 
 
@Override
public ChannelFuture write(final Object msg, final ChannelPromise promise) {
    if (msg == null) {
        throw new NullPointerException("msg");
    }

    try {
        if (isNotValidPromise(promise, true)) {
            ReferenceCountUtil.release(msg);
            // cancelled
            return promise;
        }
    } catch (RuntimeException e) {
        ReferenceCountUtil.release(msg);
        throw e;
    }
    write(msg, false, promise);

    return promise;
}
 
 
上面做了很多判断,其中我们只关心write(msg, false, promise); 源码如下:
 
 
private void write(Object msg, boolean flush, ChannelPromise promise) {
    AbstractChannelHandlerContext next = findContextOutbound();
    final Object m = pipeline.touch(msg, next);
    EventExecutor executor = next.executor();
    if (executor.inEventLoop()) {
        if (flush) {
            next.invokeWriteAndFlush(m, promise);
        } else {
            next.invokeWrite(m, promise);
        }
 
 
我们可以看到,重要的逻辑findContextOutbound(); 它的源码如下, 从尾节点开始遍历链表,找到前一个outbound类型的handler
 
 
private AbstractChannelHandlerContext findContextOutbound() {
    AbstractChannelHandlerContext ctx = this;
    do {
        ctx = ctx.prev;
    } while (!ctx.outbound);
    return ctx;
}
 
 
找到后,因为我们使用函数是write而不是writeAndFlush所以进入上面的else代码块invokeWrite
 
 
private void invokeWrite(Object msg, ChannelPromise promise) {
    if (invokeHandler()) {
        invokeWrite0(msg, promise);
    } else {
        write(msg, promise);
    }
}
 
 
继续跟进invokeWrite0(msg, promise); 终于看到了handler的write逻辑
 
 
private void invokeWrite0(Object msg, ChannelPromise promise) {
    try {
        ((ChannelOutboundHandler) handler()).write(this, msg, promise);
    } catch (Throwable t) {
        notifyOutboundHandlerException(t, promise);
    }
}
 
 
其中:
 
 
     
  
  • (ChannelOutboundHandler) handler() -- 是tail前面的节点
    •  
  
  • 调用当前节点的write函数
    •  
 
 
 
实际上就是回调我们自己的添加的handler的write函数,我们跟进去,源码如下:
 
 
public class OutBoundHandlerC extends ChannelOutboundHandlerAdapter {
    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        System.out.println( "hello OutBoundHandlerC");
        ctx.write(msg, promise);
    }
}
 
 
我们继续调用write, 按照相同的逻辑,msg会继续往前传递
 
 
一直传递到HeadContext节点, 因为这个节点也是Outbound类型的, 这就是Outbound事件的传播,我们直接看HeaderContext是如何收尾的, 源码如下:
 
 
@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
    unsafe.write(msg, promise);
}
 
 
Header使用了unsafe类,这没毛病,和数据读写有关的操作,最终都离不开unsafe
 
 
为什么Header节点是outBound类型的处理器?
 
 
拿上面的write事件来说,msg经过这么多handler的加工,最终的目的是传递到客户端,所以netty把header设计为outBound类型的节点,由他完成往客户端的写
 
 
context.write()与context.channel().write()的区别
 
 
     
  
  • context.write(),会从当前的节点开始往前传播
    •  
  
  • context.channel().write() 从尾节点开始依次往前传播
    •  
 
 
 
异常的传播
 
 
netty中如果发生了异常的话,异常事件的传播和当前的节点是 入站和出站处理器是没关系的,一直往下一个节点传播,如果一直没有handler处理异常,最终由tail节点处理
 
 
最佳的异常处理解决方法
 
 
既然异常的传播和入站和出站类型的处理器没关系,那么我们就在pipeline的最后,也就是tail之前,添加我们的统一异常处理器就好了, 就像下面:
 
 
public class MyServerInitializer extends ChannelInitializer {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
      // todo 异常处理的最佳实践, 最pipeline的最后添加异常处理handler
      channelPipeline.addLast(new myExceptionCaughtHandler());
    }
}

public class myExceptionCaughtHandler extends ChannelInboundHandlerAdapter {
// 最终全部的异常都会来到这里
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    if (cause instanceof 自定义异常1){
    }else if(cause instanceof  自定义异常2){
    }
    // todo 下面不要往下传播了
     // super.exceptionCaught(ctx, cause);
}
}
 
 
SimpleChannelInboundHandler 的特点 
 
 
通过前面的分析,我们知道如果客户端的msg一味的往后传播,最终会传播到tail节点,由tail节点处理释放,从而避免了内存的泄露
 
 
如果我们的handler使用了msg之后没有往后传递就要倒霉了,时间久了就会出现内存泄露的问题
 
 
netty人性化的为我们提供的指定泛型的 SimpleChannelInboundHandler ,可以为我们自动的释放内存,我们看他是如何做到的
 
 
/ todo 直接继承于ChanelInboundHandlerAdapter的实现 抽象类
// todo 我们自己的处理器, 同样可以继承SimpleChannelInboundHandler适配器,达到相同的效果
public abstract class SimpleChannelInboundHandler extends ChannelInboundHandlerAdapter {

    private final TypeParameterMatcher matcher;
    private final boolean autoRelease;
    protected SimpleChannelInboundHandler() {
        this(true);
    }
    protected SimpleChannelInboundHandler(boolean autoRelease) {
        matcher = TypeParameterMatcher.find(this, SimpleChannelInboundHandler.class, "I");
        this.autoRelease = autoRelease;
    }

    protected SimpleChannelInboundHandler(Class inboundMessageType) {
        this(inboundMessageType, true);
    }

    protected SimpleChannelInboundHandler(Class inboundMessageType, boolean autoRelease) {
        matcher = TypeParameterMatcher.get(inboundMessageType);
        this.autoRelease = autoRelease;
    }

    public boolean acceptInboundMessage(Object msg) throws Exception {
        return matcher.match(msg);
    }

    // todo  channelRead 完全被改写了
    // todo 这其实又是一种设计模式 ,   模板方法设计模式
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        boolean release = true;
        try {
            if (acceptInboundMessage(msg)) {
                @SuppressWarnings("unchecked")
                // todo 把消息进行了强转
                I imsg = (I) msg;
                //  todo channelRead0()在他的父类中是抽象的,因此我们自己写handler时,需要重写它的这个抽象的 方法 , 在下面
                // todo 这其实又是一种设计模式 ,   模板方法设计模式
                channelRead0(ctx, imsg);
            } else {
                release = false;
                ctx.fireChannelRead(msg);
            }
        } finally {// todo 对msg的计数减一, 表示对消息的引用减一. 也就意味着我们不要在任何
            if (autoRelease && release) {
                ReferenceCountUtil.release(msg);
            }
        }
    }
    protected abstract void channelRead0(ChannelHandlerContext ctx, I msg) throws Exception;
}
 
 
     
  
  • 它本身是抽象类,抽象方法是channelRead0,意味着我们需要重写这个方法
    •  
  
  • 他继承了ChannelInboundHandlerAdapter 这是个适配器类,使他可以仅实现部分自己需要的方法就ok
    •  
 
 
 
我们看它实现的channelRead, 模板方法设计模式 主要做了如下三件事
 
 
     
  
  • 将msg 强转成特定的泛型类型的数据
    •  
  
  • 将ctx和msg传递给自己的chanenlRead0使用msg和ctx(ctx,msg) 
   
       
    
    • chanenlRead0使用msg和ctx
      •  
   
    •  
  
  • 在finally代码块中,将msg释放
    •  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Netty-Pipeline组件)

        

            

                
    
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    
                    
    • 
                    
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络
                        落叶无声9
区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
                        
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
    
                    
    • 
                    
  • ES聚合分析原理与代码实例讲解
                        光剑书架上的书
大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
                        
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • uniapp map组件自定义markers标记点
                        以对_
uni-app学习记录uni-appjavascript前端
                        
    需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
    
                    
    • 
                    
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程
                        极客小张
stm32qt机器人物联网人机交互毕业设计c语言
                        
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • 信息系统安全相关概念(上)
                        YuanDaima2048
课程笔记基础概念安全信息安全笔记
                        
    文章总览：YuanDaiMa2048博客文章总览下篇:信息系统安全相关概念(下)信息系统安全相关概念[上]信息系统概述信息系统信息系统架构信息系统发展趋势：信息系统日趋大型化、复杂化信息系统面临的安全威胁信息系统安全架构设计--以云计算为例信息系统安全需求及安全策略自主访问控制策略DAC强制访问控制策略MAC信息系统概述信息系统用于收集、存储和处理数据以及传递信息、知识和数字产品的一组集成组件。几
    
                    
    • 
                    
  • HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换
                        让开，我要吃人了
OpenHarmonyHarmonyOS鸿蒙开发harmonyos华为鸿蒙移动开发鸿蒙系统前端开发语言
                        
    鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
    
                    
    • 
                    
  • 内存保护学习（一）：tc27x的内存保护MPU设置浅析（个人理解）
                        剑从东方起
链接文件及功能安全开发语言c语言
                        
    目录一、背景二、Tc27x相关寄存器1、注意点2、注意几个强相关寄存器1）、数据保护范围寄存器2）、代码保护范围寄存器3）、保护集启用寄存器命名约定4）、PSW（每个核都有一个）5）、SYSCON三、使用方法1、内存方面2、在ECUM里面初始化MPU3、OS回调CBK检查4、机理5、补充点一、背景根据低ASIL等级开发的软件组件可能会错误地访问具有较高ASIL等级的软件组件的内存区域，从而产生干扰
    
                    
    • 
                    
  • 详解“c:/work/src/components/a/b.vue“‘ has no default export报错原因
                        hw_happy
开发语言前端vue.jsjavascript
                        
    前情提要在一个vue文件中需要引入定义的b.vue文件，但是提示b文件没有默认导出，对于vue2文件来说有exportdefault，在中，所有定义的变量、函数和组件都会自动被视为默认导出的组件内容。因此，不需要显式地使用exportdefault来导出组件。但是在我引用这个文件的时候还是提示了这个错误，原来是我的项目使用了ts和vite\webpack，因为TypeScript和Vue的默认导出
    
                    
    • 
                    
  • KVM虚拟机源代码分析【转】
                        xidianjiapei001
#虚拟化技术
                        
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
    
                    
    • 
                    
  • Istio pilot-discovery服务发现源码解析（1.13版本）
                        xidianjiapei001
#Istioistio云原生服务发现
                        
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • Vue3 vant组件库自动导入
                        不叫虎子
Vuevue.js前端javascript前端框架typescript
                        
    实现：完整使用vant组件库文档安装：#Vue3项目，安装最新版Vantnpmivant#通过yarn安装yarnaddvant#通过pnpm安装pnpmaddvant【一】按需引入：https://vant-contrib.gitee.io/vant/#/zh-CN/quickstart#fang-fa-er.-an-xu-yin-ru-zu-jian-yang-shi【二】批量引入在基于vit
    
                    
    • 
                    
  • vant-element-ts一起使用存在的问题
                        flynn_
问题总结vue
                        
    由于vant-ui与element-ui部分组件存在冲突，导致在vue-typescript中出现错误:Subsequentpropertydeclarationsmusthavethesametype.Property'$notify'mustbeoftype'ElNotification',butherehastype'Notify'.方案：一个全局导入，一个按需导入,避免冲突的组件同时使用，
    
                    
    • 
                    
  • 【Python】tkinter及组件如何使用
                        小九不懂SAP
我的Python日记python开发语言tkinter
                        
    一、tkinter的应用场景tkinter是Python的标准GUI（图形用户界面）库，它提供了丰富的控件和工具，使得开发者能够轻松创建跨平台的桌面应用程序。以下是一些tkinter的常见应用场景：桌面应用程序开发：开发者可以使用tkinter来创建各种桌面应用程序，如文本编辑器、计算器、图片查看器、游戏等。这些应用程序可以具有复杂的用户界面，包括窗口、按钮、文本框、下拉菜单、滚动条等。数据可视化
    
                    
    • 
                    
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
                        2401_84544531
程序员android面试学习
                        
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
    
                    
    • 
                    
  • 【前端】vue 报错:The template root requires exactly one element
                        程序员-张师傅
前端前端vue.jsjavascript
                        
    【前端】vue报错:Thetemplaterootrequiresexactlyoneelement在Vue.js中，当你遇到错误“Thetemplaterootrequiresexactlyoneelement”时，这通常意味着你的Vue组件的模板（template）根节点不是单一的元素。Vue要求每个组件的模板必须有一个根元素来包裹所有的子元素。这个错误通常出现在以下几种情况：模板中有多个并行
    
                    
    • 
                    
  • 【鸿蒙应用】总结一下ArkUI
                        读心悦
鸿蒙基础鸿蒙应用
                        
    ArkUI是HarmonyOS应用界面的UI开发框架，提供了简洁的UI语法、UI组件、动画机制和事件交互等等UI开发基础，以此满足应用开发者对UI界面开发的需求。组件是界面搭建的最小单位，开发者通过多种组件的组合构成完整的界面。页面是ArkUI最小的调度分隔单位，开发者可以将应用设计为多个功能页面，每一个页面进行单独的文件管理，并且通过页面路由API完成页面之间的调度管理，以此来实现应用内功能的解
    
                    
    • 
                    
  • 谈谈你对AQS的理解
                        Mutig_s
jucjava开发语言面试后端
                        
    AQS概述AQS，全称为AbstractQueuedSynchronizer，是Java并发包（java.util.concurrent）中一个核心的框架，主要用于构建阻塞式锁和相关的同步器，也是构建锁或者其他同步组件的基础框架。AQS提供了一种基于FIFO（First-In-First-Out）的CLH(三个人名缩写)双向队列的机制，来实现各种同步器，如ReentrantLock、Semapho
    
                    
    • 
                    
  • Kafka 基础与架构理解
                        StaticKing
KAFKAkafka
                        
    目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
    
                    
    • 
                    
  • 构建常态化安全防线：XDR的态势感知与自动化响应机制
                        安胜ANSCEN
网络安全运维威胁分析自动化响应网络安全常态化安全运营
                        
    当前，网络安全威胁日益复杂多变，企业正面临前所未有的严峻挑战。为有效应对这些挑战，态势感知与自动化响应机制在提升网络安全运营效率与防御效果中扮演着至关重要的角色。它们能够实时监测网络状态，智能分析潜在威胁，并在发现异常时立即触发自动化响应流程，从而迅速遏制安全风险，保障企业数字资产的安全。态势感知网络安全的“预警雷达”态势感知，作为网络安全运营的核心组件，犹如一张无形的“预警雷达”，全面监测网络环
    
                    
    • 
                    
  • 机电综合管理系统架构
                        小熊coder
机载系统系统架构
                        
    文章目录一、机电综合管理系统架构1.系统概述2.架构层次3.核心组件二、余度管理1.余度概述2.硬件冗余3.软件冗余4.通信冗余三、总线架构1.MIL-STD-1553B总线2.ARINC429总线3.ARINC629总线4.AFDX/ARINC664总线四、未来发展趋势1.分布式架构2.高速网络3.智能化与自动化结语机电综合管理系统（ElectromechanicalManagementSyst
    
                    
    • 
                    
  • 什么是接口测试？做接口测试的意义是什么？
                        白码会说
软件测试接口测试软件测试
                        
    Timewilltell.1、什么是接口测试？为什么要做接口测试？接口测试是测试系统组件间接口的一种测试。接口测试主要用于检测外部系统与系统之间以及内部各个子系统之间的交互点。测试的重点是要检查数据的交换，传递和控制管理过程，以及系统间的相互逻辑依赖关系等。由于如今的系统复杂度不断上升，传统的测试方法成本急剧增加且测试效率大幅下降，所以就要做接口测试。同时，接口测试相对容易实现自动化持续集成，且相
    
                    
    • 
                    
  • 说说在 Vue.js 中如何实现组件间通信
                        deniro

                        
    1用法假设父组件的模板包含子组件，我们可以通过props来正向地把数据从父组件传递给子组件。props可以是字符串数组，也可以是对象。html：js：Vue.component('deniro-component',{props:['message'],template:'{{message}}'});varapp=newVue({el:'#app',data:{}});渲染结果：＂嫦娥四号＂成功
    
                    
    • 
                    
  • 华为USG6000E-S12防火墙Key exchange failed.无法SSH解决方案
                        redmond88
网络技术ssh华为运维
                        
    由于目前防火墙算法太新，导致crt和xshell的版本无法登陆，按以下方法解决一、下载华为本地加载除弱安全算法组件包之外的组件包https://download.csdn.net/download/redmond88/89620664?spm=1001.2014.3001.5503二、先改后缀名为.cfg,上传文件到防火墙三、在用户视图下改后缀名为.mod四、move文件到$_install_mo
    
                    
    • 
                    
  • vue keep-alive
                        w_wx_x

                        
    作用：  vue内置组件，能在组件切换过程中将状态保留在内存中，防止重复渲染DOM  keep-alive是用在一个直属子组件被开关的情形，同时只有一个子组件在渲染，若有v-for则不会工作  注：keep-alive是一个抽象组件，自身不会渲染一个DOM元素，也不会出现在父组件链中//页面文件//路由exportdefaultnewRouter({routes:[{path:'/',name:'
    
                    
    • 
                    
  • 使用STM32实现简单的智能温控系统
                        棂梓知识
stm32单片机嵌入式硬件
                        
    智能温控系统是一种能够根据环境温度实时调整设备的工作状态的系统。在本篇文章中，我们将使用STM32微控制器来实现一个简单的智能温控系统。该系统将会有以下功能：实时监测环境温度，并显示在LCD屏幕上。当环境温度超过设定的阈值时，自动开启风扇。当环境温度恢复正常时，自动关闭风扇。通过按键模拟调节设定的阈值。系统设计首先，我们需要准备一些硬件设备。具体而言，我们需要以下组件：STM32F103C8T6开
    
                    
    • 
                                
  • scala的option和some
                                    矮蛋蛋
编程scala
                                    
    原文地址： 
http://blog.sina.com.cn/s/blog_68af3f090100qkt8.html 
对于学习 Scala 的 Java™ 开发人员来说，对象是一个比较自然、简单的入口点。在 本系列 前几期文章中，我介绍了 Scala 中一些面向对象的编程方法，这些方法实际上与 Java 编程的区别不是很大。我还向您展示了 Scala 如何重新应用传统的面向对象概念，找到其缺点
    
                                
    • 
                                
  • NullPointerException
                                    Cb123456
androidBaseAdapter
                                    
      
  java.lang.NullPointerException: Attempt to invoke virtual method 'int android.view.View.getImportantForAccessibility()' on a null object reference 
  
  出现以上异常.然后就在baidu上
    
                                
    • 
                                
  • PHP使用文件和目录
                                    天子之骄
php文件和目录读取和写入php验证文件php锁定文件
                                    
    PHP使用文件和目录 
1.使用include()包含文件 
(1)：使用include()从一个被包含文档返回一个值 
(2)：在控制结构中使用include() 
  
include_once()函数需要一个包含文件的路径，此外，第一次调用它的情况和include()一样，如果在脚本执行中再次对同一个文件调用，那么这个文件不会再次包含。 
  
在php.ini文件中设置
    
                                
    • 
                                
  • SQL SELECT DISTINCT 语句
                                    何必如此
sql
                                    
    SELECT DISTINCT 语句用于返回唯一不同的值。 
 
SQL SELECT DISTINCT 语句 
在表中，一个列可能会包含多个重复值，有时您也许希望仅仅列出不同（distinct）的值。 
 
DISTINCT 关键词用于返回唯一不同的值。 
 
SQL SELECT DISTINCT 语法 
 
SELECT DISTINCT column_name,column_name 
F
    
                                
    • 
                                
  • java冒泡排序
                                    3213213333332132
java冒泡排序
                                    
    package com.algorithm;

/**
 * @Description 冒泡
 * @author FuJianyong
 * 2015-1-22上午09:58:39
 */
public class MaoPao {
	public static void main(String[] args) {
		int[] mao = {17,50,26,18,9,10
    
                                
    • 
                                
  • struts2.18 +json,struts2-json-plugin-2.1.8.1.jar配置及问题！
                                    7454103
DAOspringAjaxjsonqq
                                    
    struts2.18  出来有段时间了！ （貌似是 稳定版） 
  
闲时研究下下！  貌似 sruts2 搭配 json 做 ajax 很吃香！ 
  
实践了下下！ 不当之处请绕过！ 呵呵 
  
网上一大堆 struts2+json  不过大多的json 插件 都是 jsonplugin.34.jar  
  
strut
    
                                
    • 
                                
  • struts2 数据标签说明
                                    darkranger
jspbeanstrutsservletScheme
                                    
    数据标签主要用于提供各种数据访问相关的功能，包括显示一个Action里的属性，以及生成国际化输出等功能 
数据标签主要包括： 
action ：该标签用于在JSP页面中直接调用一个Action，通过指定executeResult参数，还可将该Action的处理结果包含到本页面来。 
bean ：该标签用于创建一个javabean实例。如果指定了id属性，则可以将创建的javabean实例放入Sta
    
                                
    • 
                                
  • 链表.简单的链表节点构建
                                    aijuans
编程技巧
                                    
    /*编程环境WIN-TC*/ #include "stdio.h" #include "conio.h" 
#define NODE(name, key_word, help) \  Node name[1]={{NULL, NULL, NULL, key_word, help}} 
typedef struct node {  &nbs
    
                                
    • 
                                
  • tomcat下jndi的三种配置方式
                                    avords
tomcat
                                    
    jndi(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。命名服务将名称和对象联系起来，使得我们可以用名称 
访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。 
         tomcat配置
    
                                
    • 
                                
  • 关于敏捷的一些想法
                                    houxinyou
敏捷
                                    
    从网上看到这样一句话：“敏捷开发的最重要目标就是：满足用户多变的需求，说白了就是最大程度的让客户满意。” 
感觉表达的不太清楚。 
感觉容易被人误解的地方主要在“用户多变的需求”上。 
第一种多变，实际上就是没有从根本上了解了用户的需求。用户的需求实际是稳定的，只是比较多，也比较混乱，用户一般只能了解自己的那一小部分，所以没有用户能清楚的表达出整体需求。而由于各种条件的，用户表达自己那一部分时也有
    
                                
    • 
                                
  • 富养还是穷养，决定孩子的一生
                                    bijian1013
教育人生
                                    
        是什么决定孩子未来物质能否丰盛？为什么说寒门很难出贵子，三代才能出贵族？真的是父母必须有钱，才能大概率保证孩子未来富有吗？-----作者：@李雪爱与自由
    事实并非由物质决定，而是由心灵决定。一朋友富有而且修养气质很好，兄弟姐妹也都如此。她的童年时代，物质上大家都很贫乏，但妈妈总是保持生活中的美感，时不时给孩子们带回一些美好小玩意，从来不对孩子传递生活艰辛、金钱来之不易、要懂得珍惜
    
                                
    • 
                                
  • oracle 日期时间格式转化
                                    征客丶
oracle
                                    
    oracle 系统时间有 SYSDATE 与 SYSTIMESTAMP； 
SYSDATE：不支持毫秒，取的是系统时间； 
SYSTIMESTAMP：支持毫秒，日期，时间是给时区转换的，秒和毫秒是取的系统的。 
 
日期转字符窜： 
一、不取毫秒： 
TO_CHAR(SYSDATE, 'YYYY-MM-DD HH24:MI:SS') 
简要说明， 
YYYY 年 
MM   月
    
                                
    • 
                                
  • 【Scala六】分析Spark源代码总结的Scala语法四
                                    bit1129
scala
                                    
    1. apply语法 
  
FileShuffleBlockManager中定义的类ShuffleFileGroup，定义： 
  
private class ShuffleFileGroup(val shuffleId: Int, val fileId: Int, val files: Array[File]) {
  ...
  def apply(bucketId
    
                                
    • 
                                
  • Erlang中有意思的bug
                                    bookjovi
erlang
                                    
      
代码中常有一些很搞笑的bug，如下面的一行代码被调用两次（Erlang beam） 
  
commit f667e4a47b07b07ed035073b94d699ff5fe0ba9b
Author: Jovi Zhang <[email protected]>
Date:   Fri Dec 2 16:19:22 2011 +0100

    erts:
    
                                
    • 
                                
  • 移位打印10进制数转16进制-2008-08-18
                                    ljy325
java基础
                                    
    
/**

 * Description 移位打印10进制的16进制形式

 * Creation Date 15-08-2008 9:00

 * @author 卢俊宇

 * @version 1.0

 *

 */

public class PrintHex {

 

    // 备选字符

    static final char di
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-组合模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 


import java.util.ArrayList;
import java.util.List;

abstract class Component {
	
	public abstract void printStruct(Str
    
                                
    • 
                                
  • 利用cmd命令将.class文件打包成jar
                                    chenyu19891124
cmdjar
                                    
    cmd命令打jar是如下实现： 
在运行里输入cmd，利用cmd命令进入到本地的工作盘符。(如我的是D盘下的文件有此路径 D:\workspace\prpall\WEB-INF\classes) 
现在是想把D:\workspace\prpall\WEB-INF\classes路径下所有的文件打包成prpall.jar。然后继续如下操作： 
cd D: 回车 
cd workspace/prpal
    
                                
    • 
                                
  • [原创]JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明
                                    comsci
eclipse设计模式算法工作swing
                                    
         
 
                  JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明 
 
    &nb
    
                                
    • 
                                
  • SecureCRT右键粘贴的设置
                                    daizj
secureCRT右键粘贴
                                    
    一般都习惯鼠标右键自动粘贴的功能，对于SecureCRT6.7.5 ，这个功能也已经是默认配置了。 
老版本的SecureCRT其实也有这个功能，只是不是默认设置，很多人不知道罢了。 
 
菜单： 
Options->Global Options ...->Terminal 
 
右边有个Mouse的选项块。 
Copy on Select 
Paste on Right/Middle
    
                                
    • 
                                
  • Linux 软链接和硬链接
                                    dongwei_6688
linux
                                    
    1.Linux链接概念Linux链接分两种，一种被称为硬链接（Hard Link），另一种被称为符号链接（Symbolic Link）。默认情况下，ln命令产生硬链接。 
【硬连接】硬连接指通过索引节点来进行连接。在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Index)。在Linux中，多个文件名指向同一索引节点是存在的。一般这种连
    
                                
    • 
                                
  • DIV底部自适应
                                    dcj3sjt126com
JavaScript
                                    
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml&q
    
                                
    • 
                                
  • Centos6.5使用yum安装mysql——快速上手必备
                                    dcj3sjt126com
mysql
                                    
    第1步、yum安装mysql
[root@stonex ~]#  yum -y install mysql-server
安装结果：
Installed:
    mysql-server.x86_64 0:5.1.73-3.el6_5                   &nb
    
                                
    • 
                                
  • 如何调试JDK源码
                                    frank1234
jdk
                                    
    相信各位小伙伴们跟我一样，想通过JDK源码来学习Java，比如collections包，java.util.concurrent包。 
 
可惜的是sun提供的jdk并不能查看运行中的局部变量，需要重新编译一下rt.jar。 
 
下面是编译jdk的具体步骤： 
        1.把C:\java\jdk1.6.0_26\sr
    
                                
    • 
                                
  • Maximal Rectangle
                                    hcx2013
max
                                    
    Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area. 
  
public class Solution {
    public int maximalRectangle(char[][] matrix)
    
                                
    • 
                                
  • Spring MVC测试框架详解——服务端测试
                                    jinnianshilongnian
spring mvc test
                                    
    随着RESTful Web Service的流行，测试对外的Service是否满足期望也变的必要的。从Spring 3.2开始Spring了Spring Web测试框架，如果版本低于3.2，请使用spring-test-mvc项目（合并到spring3.2中了）。 
  
Spring MVC测试框架提供了对服务器端和客户端（基于RestTemplate的客户端）提供了支持。 
&nbs
    
                                
    • 
                                
  • Linux64位操作系统（CentOS6.6）上如何编译hadoop2.4.0
                                    liyong0802
hadoop
                                    
    一、准备编译软件 
  1.在官网下载jdk1.7、maven3.2.1、ant1.9.4，解压设置好环境变量就可以用。 
    环境变量设置如下： 
  
（1）执行vim /etc/profile
（2）在文件尾部加入:
   export JAVA_HOME=/home/spark/jdk1.7
   export MAVEN_HOME=/ho
    
                                
    • 
                                
  • StatusBar 字体白色
                                    pangyulei
status
                                    
    
[[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent];
/*you'll also need to set UIViewControllerBasedStatusBarAppearance to NO in the plist file if you use this method
    
                                
    • 
                                
  • 如何分析Java虚拟机死锁
                                    sesame
javathreadoracle虚拟机jdbc
                                    
    英文资料：  
Thread Dump and Concurrency Locks  
  
Thread dumps are very useful for diagnosing synchronization related problems such as deadlocks on object monitors. Ctrl-\ on Solaris/Linux or Ctrl-B
    
                                
    • 
                                
  • 位运算简介及实用技巧（一）：基础篇
                                    tw_wangzhengquan
位运算
                                    
    http://www.matrix67.com/blog/archives/263 
   去年年底写的关于位运算的日志是这个Blog里少数大受欢迎的文章之一，很多人都希望我能不断完善那篇文章。后来我看到了不少其它的资料，学习到了更多关于位运算的知识，有了重新整理位运算技巧的想法。从今天起我就开始写这一系列位运算讲解文章，与其说是原来那篇文章的follow-up，不如说是一个r
    
                                
    • 
                                
  • jsearch的索引文件结构
                                    yangshangchuan
搜索引擎jsearch全文检索信息检索word分词
                                    
    jsearch是一个高性能的全文检索工具包，基于倒排索引，基于java8，类似于lucene，但更轻量级。 
  
jsearch的索引文件结构定义如下： 
    1、一个词的索引由=分割的三部分组成：        第一部分是词        第二部分是这个词在多少
    
                                
    •