RalapHao
RalapHao

Netty架构模型设计与源码浅析

Netty架构模型设计与源码浅析_第1张图片
cover.jpg

本文主要从IO模型、Netty逻辑架构、Netty各组件的设计与应用为主导，由简-难-细展开来介绍，其中包括IO模型以及BIO、NIO、AIO；
逻辑架构主要是如何分层、各层如何协作以及如何达到高性能、高可靠性等；组件主要介绍Buffer、Channel、ChannelPipeling、ChannelHandler、EvnetLoop等，最后从源码的角度分析客户端、服务端如何实现以及二者通讯中编解码、读写半包等

  • 参考资料
    [1]李林锋《Netty权威指南》 第2版
    [2] Netty官网

一、IO模型

  1. 阻塞IO模型


    Netty架构模型设计与源码浅析_第2张图片
    阻塞IO模型.png

应用进程空间触发内核调用，数据包准备直到复制到用户空间或异常发生，此期间应用进程处于等待阻塞状态，被称为阻塞模型

  1. 非阻塞IO模型


    Netty架构模型设计与源码浅析_第3张图片
    非阻塞.png

从应用层到内核，若该缓存区没有数据，立即返回EWouldBlock异常，通常进行轮询，反复Recv，直到数据准备完成，与阻塞的区别：无数据的情况下，是否立即返回

  1. IO多路复用模型


    Netty架构模型设计与源码浅析_第4张图片
    IO复用模型.png

应用进程通过Select将一个或多个FD（File Description）阻塞，select/poll是顺序扫描FD数据是否就绪，Select能持有的FD有限；epoll中FD受限于操作系统的最大文件句柄数，其通过事件驱动替代顺序扫描，只关心活跃的FD，当FD就绪，回调rallBack，性能更好，同时epoll通过内核与用户空间mmap使用同一块内存来实现的，此期间Select与数据复制都会阻塞应用线程

  1. 信号驱动IO模型


    Netty架构模型设计与源码浅析_第5张图片
    信号驱动IO模型.png

该模型与复用模型类似，通过信号驱动与通知完成数据准备就绪的判别，同时此过程非阻塞，这是和复用模型的区别

  1. 异步IO模型


    Netty架构模型设计与源码浅析_第6张图片
    异步IO模型.png

该模型与信号驱动类似，触发内核某个操作，数据准备就绪，复制完成后，通知应用程序，与信号驱动的区别在于是否已经完成数据复制后通知

  1. BIO

    • 同步


      Netty架构模型设计与源码浅析_第7张图片
      BIO同步通信模型.png

    由独立的Acceptor线程负责监听客户端连接，然后为每个连接创建新的线程，处理完成后返回给客户端，最大的问题就是缺乏弹性伸缩能力，当客户并突增后，服务器线程膨胀，性能会下降，线程堆栈溢出、新建线程失败等问题，最后导致系统宕机。

    • 伪异步


      Netty架构模型设计与源码浅析_第8张图片
      BIO通信模型(伪异步).png

    通过将客户端Socket封装成Task，投递到线程池，通过线程对Socket做统一控制，解决了线程突增问题，但是由于底层通信还是同步阻塞模型，没有从根本解决问题，当所有可用线程被阻塞，后续Socket进入队列，队列满后，新请求甚至被直接拒绝掉，大量响应超时，导致客户端认为服务器瘫痪

  2. NIO

    Netty架构模型设计与源码浅析_第9张图片
    NIO通讯模型.png

    NIO有三大核心类，Buffer、Channel、Selector，Buffer与Channel一一对应，Channel与Selector是多对一。Channel注册到Selector，Selector轮询就绪的Key，根据事件在Channel间切换，异步读取消息到Buffer，通过解码处理，最后可以发送消息Buffer到SocketChannel，通过Selector事件，通知事件注册Key处理消息，Socket连接以及读写都是异步的，同时Selector通过epool实现，所以非常适合做高性能、高负载的网络服务器

  3. AIO
    使用Proactor模式，通过Future、CompletionHandler实现异步操作结果以及通知的实现，不需要通过多路复用即可实现异步读写，从而简化编程模型，由于不是本文主要内容，所以不仔细分析

  4. 零拷贝
    从操作系统层面讲，数据不经过CPU拷贝从一个内从区域到另一个内存区域，内核缓冲区没有产生重复数据

    • 传统IO


      Netty架构模型设计与源码浅析_第10张图片
      传统IO拷贝.png

      经过四次内存拷贝，四次上下文形态的切换

      1. JVM发起read，OS切换到内核态（第一次状态切换），数据从Hardware通过DMA拷贝到Kernel（第一次拷贝）
      2. OS切换到用户态（第二次状态切换），将数据从kernel通过CPU拷贝到User（第二次拷贝）
      3. JVM发write，OS切换形态到内核态（第三次状态切换），将数据拷贝到Kernel（第三次拷贝），然后切换到用户态（第四次状态切换）数据拷贝到Hardware（第四次拷贝）

    • Mmap优化


      Netty架构模型设计与源码浅析_第11张图片
      MMAP-IO拷贝.png

      三次内存拷贝，四次上下文形态的切换
      整个数据流与传统IO相似，区别在于节省了第二次拷贝，内核缓冲数据可以与用户共享。

    • SendFile


      Netty架构模型设计与源码浅析_第12张图片
      SendFile-IO拷贝 -.png

      带有DMA收集拷贝功能的SendFile是俩次拷贝，俩次内核的切换

      1. OS切换内核态，Hardware拷贝数据到Kernel
      2. Kernel拷贝Length、Offset到 Kernel（不计做数据拷贝）
      3. 传统I/O用户空间缓存了数据，所以应用程序可以对数据进行修改
      4. 通过Length、Offset直接将Kernel数据拷贝到协议引擎
      5. Java NIO中transferTo实现了该功能

二、Netty概述

Netty是在NIO问题众多的情况下应声而来，基于NIO提供了异步非阻塞、事件驱动的网络应用程序框架与工具

  • NIO存在的问题
    1. 类库、API复杂，依赖额技能：多线程
    2. 可靠性能力的补齐，工作量和难度都很大：断连重连、网络闪断、读写半包、失败缓存、网络拥堵、异常码流的处理
  • Netty应声而来
    1. API简单、开发门槛低
    2. 功能强大，预置多种编解码，支持多种主流协议
    3. 定制能力强，通过ChannelHandler，对通信框架灵活扩展
    3. 性能高、成熟、稳定，社区活跃

三、Netty架构设计

  1. 架构模型


    Netty架构模型设计与源码浅析_第13张图片
    Netty逻辑机构图.png

    整体采用三层网络架构进行设计开发，实现了NIO架构各层之间的解耦，便于上层协议栈的开发与逻辑的定制；Reactor层作为通信调度，PipeLine层拦截监听事件，Service ChannelHandler 用于扩展与业务逻辑的编排，下面详细介绍各层职责

    • Reactor通信调度
      主要负责网络的连接以及读写操作，将网络层的数据读取到内存缓存区中，然后触发各种网络事件，例如：连接创建、连接激活、读写事件等，同时将事件回调到Pipeline中，由PipeLine做后续处理
    • PipeLine职责链
      复制事件在职责链中的有序传播，同时负责动动态的编排，选择监听和处理自己感兴趣的事件，可以拦截处理与向前\后传播事件，通常不同Handler节点功能不同，例如编解码Handler，负责消息协议转化，这样上层只需要关心业务逻辑，不需要感知底层的协议、线程模型的差异，实现了架构的分层隔离
    • Service Handler 业务处理
      可以分为俩类，一类是纯粹的业务逻辑处理，另一类就是其他应用层的协议插件，用于特定协议相关的会话和链路管理

  2. 服务端 & 客户端 创建过程时序

    • 服务端


      Netty架构模型设计与源码浅析_第14张图片
      服务端顺序图.png

    • 客户端


      Netty架构模型设计与源码浅析_第15张图片
      客户端顺序图图.png

  3. 线程控制
    由于Netty采用异步通信模型，一个IO线程并发处理多个客户端连接读写，IO多路复用 + 池化技术其实就是Reactor的基本设计思想，Reactor单独运行在一个线程，负责监听与分发事件，分发给适当的程序来处理IO事件，通过Handler实际处理相关事件，那么线程模型到底是什么样，下面详细讲解

    • 单Reactor单线程模型


      Netty架构模型设计与源码浅析_第16张图片
      Reactor单线程.png
      1. 典型的IO多路复用通过一个线程阻塞多路连接请求，Reactor通过select监听客户端事件，收到后通过Dispatch进行分发事件；
      2. 如果是连接事件，交由Acceptor进行连接处理，创建Handler完成后续处理；
      3. 如果非连接请求，分发到相应的handler处理，完成read -> 业务处理 - > send 过程处理

      优点：模型简单，无多线程，不存在进程通讯、资源竞争问题
      缺点：性能问题：单线程无法发挥多核优势，同时处理Handler业务会阻塞线程，导致客户端连接超时，往往超时会重试，加重服务端压力，恶性循环；可靠性问题：线程意外停止或进入死循环会导致整个系统不可用
      使用于客户端数据量有限，业务响应迅速的应用

    • 单Reactor多线程模型


      Netty架构模型设计与源码浅析_第17张图片
      Reactor多线程 .png
      1. Reactor启动单线程监听客户端事件，通过Dispatch分发事件
      2. 连接事件交由Acceptor进行连接处理，创建Handler完成后续处理
      3. 非连接事件，由Reactor分发到相应的Handler处理
      4. handler只负责响应事件，read读取数据后，分发到worker线程池中做业务处理

      优点：发挥多核的处理能力
      缺点：单Reactor线程处理所有监听事件，在高并发情况下会成为瓶颈，同时多线程共享和访问数据比较复杂

    • Reactor主从多线程模型


      Netty架构模型设计与源码浅析_第18张图片
      Reactor主从多线程.png
      1. Reactor主线程通过select监听连接事件，收到连接通知Acceptor处理连接事件
      2. 连接建立后主线程分配给Reactor子线程，创建Handler进行各种事件处理
      3. 有事件发生，SubReactor调用相应的Handler，handler通过read后将数据分发给worker线程去处理
      4. 一个MainReactor可以对应多个SubReactor

    优点：主从线程数据交互简单，职责明确，主线程负责接收连接，从线程负责后续业务处理，同时无需返回
    缺点：编程难度较大

    • Netty线程模型


      Netty架构模型设计与源码浅析_第19张图片
      Netty线程模型.png

      该模式可以通过参数配置，支持以上三种Reactor线程模型

    1. 抽象出俩个线程池，Boss Group 负责客户端连接请求，Worker Group负责网络的读写，二者皆为NioEventLoopGroup，表示事件循环组，每一循环为NioEventLoop
    2. NioEventLoop表示一个不断循环处理任务的线程，内置Selector监听绑定在其上面的Socket通讯事件
    3. 每个Boss NioEventLoop包含三个步骤
      • 轮询监听accept事件
      • 处理accept事件，与client建立连接，生成NioSocketChannel，并将其注册到Worker NioEventLoop中的Selector
      • 处理任务队列任务
    4. 每个Worker NioEventLoop循环执行步骤
      • 轮询监听read、write事件
      • 在对应的NioSocketChannel处理read、write事件
      • 处理任务队列任务
    5. 每个Worker NioEventLoop处理业务会通过PipeLine,其中内置了很多处理器，支持业务处理

  1. Handler调用机制


    Netty架构模型设计与源码浅析_第20张图片
    Pipeline事件拦截和处理流程.png

在Netty架构设计中，Handler充当了处理入栈和出栈的数据处理逻辑的容器，实现相应接口（ChannelInBoundHandler）重写相应方法就可以接收入栈事件和数据，将数据进行逻辑处理；向客户端发送响应时，可用从InBound中冲刷数据，ChannelOutBoundHandler原理相同，处理出栈数据；其中入栈是相对PipeLine来说的，PipeLine中以LinkedList线程存储Handler，从Socket中read数据到Pipeline进行处理称为入栈，Handler执行顺序为HeadHandler -> TailHandler,反之write到Socket称为出栈，执行顺序TailHandler - > HeadHandler

  1. 编解码与协议开发
    当Netty接收和发送消息时，就会发生一次数据转换，根据入栈和出栈分别进行解码和编码，Netty自身提供了一系列编解码器，都会实现ChannelInBoundHandler、ChannelOutBoundHandler接口并在channelRead中接收数据，进行数据的编解码，数据处理后会转发到写一个Handler；由于TCP是 “流” 协议，也就是传输的数据是没有界限的，所以导致在业务层面讲不能确定每次发送是一条完整数据，这就是TPC粘包、拆包问题
    • TCP粘包、拆包问题
      底层TCP无法理解上层业务数据，所以导致底层无法保证数据包不被拆分和重组，所以这个问题只能通过上层协议栈设计去解决，根据业界与主流协议的解决方案，可以总结为以下几种
      1. 消息定长
      2. 在包尾添加特殊字符进行分割，比如：回车
      3. 将消息分为消息头、消息体，消息头保存消息长度
      4. 更复杂的应用层协议
    • 消息序列化
      当进行远程跨进程调用时，需要将被传输的Java对象编码为字节数组或ByteBuffer对象，目标系统需要将接收到的数据进行相应解码为Java对象，其中最常见的就是Java的序列化，实现Serializable接口

      1. Java序列化
        序列化目的：网络传输（本文重点）、对象持久化；
        序列化是Java编码中的一种，由于其种种缺陷，衍生出多种编
        解码技术与框架
        缺陷：无法跨语言、序列化后的体积较大、性能低

      2. Protobuf
        是一种与语言无关、平台无关、性能高、扩展性好的数据序列化方法，可以用于数据传输协议以及数据存储，可类比于XML但是比XML更小、更快、更简单，通过数据描述文件和代码生成机制实现以上特点

      3. Thrift

        Thrift是一种接口描述语言和二进制通讯协议，它被用来定义和创建跨语言的服务。它被当作一个远程过程调用（RPC）框架来使用，是由Facebook为“大规模跨语言服务开发”而开发的。——来源：百度百科

      4. Mershalling
        是一个Java对象序列话的API包，修正了JDK自带序列化的诸多问题，在兼容Serializable的同时，新增可调参数与附加特性

        • 可插拔的类解析器，提供更加便捷的定制策略，
        • 可插拔的对象替换技术
        • 无需实现指定接口
        • 通过缓冲提高性能
  2. 如何达到架构质量指标

    • 高性能

      性能是设计出来的，而不是测试出来的

      影响网络通信性能多，主要从传输、协议、进程三个方面看，选取怎么样内存模型、采用怎么样的通信协议、线程模型如何选择，下面详细介绍Netty在这些方面是如何做的

      1. 采用异步非阻塞的IO类库，基于Reactor模式实现，平滑的处理客户端线性增长；通过NioEventLoop聚合异步多路复用Selector，并发处理成百上千个SocketChannel的读写，极大提升性能、弹性伸缩能力；
      2. 网络传输缓冲区使用 直接内存，避免内存复制，提高IO读写性能；
        通过三种方面体现零拷贝：
        • Netty的读写采用DirectBuffer堆外内存直接内存，相比于堆内存要讲堆内存缓存区数据拷贝到直接内存， 不需要进行字节缓冲区的二次拷贝
        • 通过实现CompositeByteBuf，将多个ByteBuf分装成一个ByteBuf，对外提供统一ByteBuf接口，实际就是一个装饰器，将多个ByteBuf组合成一个集合，这样避免了内存拷贝；
        • 文件传输中通过transferTo方法直接文件发送到目标Channel中， 不需要进行循环拷贝（底层SendFile）
      3. 支持通过内存池的方式循环利用ByteBuffer,避免频繁创建、销毁Buffer对象造成的性能开销；虽然JVM虚拟机与JIT及时编辑编译的发展，对象的分配和回收是个非常轻量级的工作，但是对于缓冲区的情况稍有不同，缓冲区操作频繁，同时还是堆外内存，这样分配和回收对象就会稍有耗时。为了尽量重用缓冲区，Netty提供了基于内存池的缓冲区重用机制，通过启动辅助类中配置相关参数，事项差异化定制；PooledByteBufAllocator.DEFAULT.directBuffer(1024)
      4. 可配置的IO线程数、TCP参数等，为不同的应用场景提供定制化的调优参数；通过辅助类的参数配置，可以使Nettry支持任意一种Reactor线程模型，支持不同的业务场景，同时合理地设置TCP参数满足不同的用户场景
      5. 采用环形数组缓冲区实现无锁化并发编程，替代传统的线程安全容器以及锁；在数据读写时，采用循环数数组缓冲区如ChannelOutBoundBuffer，每次写入通道，然后弹出，直到无内容
      6. 合理地使用线程安全容器、原子类等，提高系统的并发处理能力；volatile的大量、正确使用；CAS和原子类的广泛使用；线程安全容器的使用；读写锁提高并发性能
      7. 关键资源使用单线程串行化，避免多线程并发访问带来的锁竞争和额外的CPU资源消耗问题；表面上串行化设计似乎CPU利用率不高，并发程度不够，但是通过Worker NioEventLoop的线程池的参数，可以同时启动多个串行化的线程并行运行，这种局部无锁化的穿串行线程设计相比一个队列，多个工作线程性能更优
      8. 通过引用计数器及时的释放不在应用的对象，细粒度的内存管理降低GC的频率，AbstractReferenceCountedByteBuf

    • 可靠性
      作为高性能的异步通讯框架，架构的可靠性是重要硬性指标

      1. 链路有效性检测
        基于长连接带来诸多便利，但链路的有效性没有保证，Netty可以通过心跳周期性的检测，在系统空闲无业务时可以识别网络闪断、网络单通等网络异常进行自动关闭、重连，使系统空闲与高峰能顺利过度；同时业务消息可以充当链路检测，心跳只需要系统空闲时发送；
        心跳机制：Ping - Pong 、Ping - Ping
        Netty提供相关类库：io.netty.handler.timout.*，进行空闲检测，主要监听读空闲、写空闲、读写空闲事件，自定义逻辑代码实现协议层的心跳检测
      2. 内存保护机制
        通过对象引用计数器对Bytebuf等内置对象进行细粒度的内存申请与释放，对非法的对象引用做检测与保护，通过内存池对ByteBuf重用、分配机制（预分配、协议定长）、设置内充容量上限（链路总数、单个缓冲区大小、消息长度）
      3. 优雅停机
        基于JVM发送退出信号量，Netty对所有涉及资源释放、回收的地方，都采用了优雅退出的方式，也就是退出前释放相关模块资源占用、将缓冲区的消息处理完成、待刷新数据持久化到硬盘或数据库，所有处理执行完毕后退出

    • 可定制
      主要体现在Pipelin的职责链设计，便于业务逻辑的定制化；基于接口开发；提供大量工厂类、配置化辅助类，可以按照业务需求进行配置、创建对象；

    • 可扩展
      很方便的进行应用层协议定制扩展

四、核心组件工作原理及源码解析

以下所有源码分析基于Netty 4.1版本

  1. Buffer（以ByteBuffer为主）

    • 工作原理
      1. NIO原生ByteBuffer
        • 核心属性 
          // Invariants: mark <= position <= limit <= capacity
private int mark = -1;     -- 标记
private int position = 0;  -- 位置，操作指针
private int limit;         -- 操作极限点
private int capacity;      -- 容量
        • 核心方法 
          public final int capacity( ) --返回此缓冲区的容量
public final int position( ) --返回此缓冲区的位置
public final Buffer mark( ) --在此缓冲区的位置设置标记
public final Buffer reset( ) --将此缓冲区的位置重置为以前标记的位置
public final Buffer clear( ) --清除此缓冲区, 即将各个标记恢复到初始值
public final Buffer flip( ) --反转此缓冲区
public final Buffer rewind( ) --重绕此缓冲区
public final int remaining( ) --返回当前位置与限制之间的元素数
public final boolean hasRemaining( ) --当前位置和限制之间是否有元素
public abstract boolean isReadOnly( ) --是否为只读缓冲区
public abstract boolean hasArray(); --是否具有可访问的底层实现数组
public abstract Object array(); --底层实现数组
public abstract int arrayOffset(); --底层实现数组中第一个元素的偏移量
public abstract boolean isDirect(); --是否为直接缓冲区
public static ByteBuffer allocateDirect(int capacity) --创建直接缓冲区
public static ByteBuffer allocate(int capacity) --创建堆内存缓存区
public abstract byte get( ); --position位置开始向后遍历
public abstract ByteBuffer put (byte b); --position位置追加
      2. JDK原生java.nio.ByteBuffer中长度固定，由于只有一个位置标识指针，每次读写需要flip()等操作进行指正切换，API有限，高级功能需要自己去实现；基于以上问题，Netty提供了自己的Buffer实现，主要采用俩中策略 ①参考JDK实现，处理缺陷、扩展功能；②采用Facade模式，聚合并包装JDK原生Buffer

      3. ByteBuf通过readerIndex & writerIndex俩个指针完成缓冲区的读写避免flip，通过扩容解决定容问题


        Netty架构模型设计与源码浅析_第21张图片
        ByteBuf.png
      4. Netty中ByteBuf核心属性 & 方法
        • 属性 
           static final ResourceLeakDetector leakDetector =ResourceLeakDetectorFactory.instance().newResourceLeakDetector(ByteBuf.class); --记录处理内存泄露Buf
/**0 <= readerIndex <= writerIndex <= maxCapacity**/
int readerIndex; --读索引
int writerIndex; --写索引
private int markedReaderIndex; --du索引标记
private int markedWriterIndex; --写索引标记
private int maxCapacity; --最大容量
        • 方法 
          public byte readByte()--读
public ByteBuf writeByte()  --写
public ByteBuf discardReadBytes()  --释放discard区域数据(重用)
public ByteBuf clear() --读写索引复位
public ByteBuf markXXX() -- 标记
public ByteBuf resetXXX() -- 复位标记
public ByteBuf slice() --可读缓存区
      5. 内存池原理
        为了集中管理内存，预先分配一大块连续内存的分配与释放，同时由于频繁调用系统来申请内存从而提高性能大大提升，Netty中PoolArena是由多个Chunk组成的大块内存区域，每个Chunk是由多个Page组成，PoolChunk主要用来组织管理多个Page的内存分配和释放，其中的Page被构建成二叉树，内存选择是对树的深度优先遍历，但是同层随机选择，如果分配内存小于page，PoolSubpage会分成相等的块，分多大是由第一次申请决定的，后面所有的申请都按这个来，无论是Chunk还是Page都是通过状态位来标识是否可用
      6. 相关类
        • ByteBufHolder：对ByteBuf的一层封装，便于协议携带数据在消息体中
        • ByteBufAllocator：Buf分配器，上面源码涉及到，主要分池与非池的Buf的分配；
        • ByteBufUtil ： ByteBuf工具类
    • 源码解析

      1. 继承关系


        Netty架构模型设计与源码浅析_第22张图片
        Diagram-ByteBuf.png

        以上是ByteBuf主要功能类图，从内存分配来看，分为堆内存、直接内存，二者的区别前面已经提过，无非就是分配&回收、复制方面各有利弊，所以读写缓冲使用直接内存，编解码使用堆内存，使系能到达最优；从内存的回收来看，可以分为池化与普通Buf，池化可以重用内存，提升效率，降低GC消耗，但是在维护管理更加复杂；Netty提供以上策略，共开发者选择。

      2. 读取Buf(AbstractByteBuf.java)

        public byte readByte() {
  checkReadableBytes0(1); //校验是否可读（一个字节）
  int i = readerIndex; //从当前可读位置开始
  byte b = _getByte(i);// 由于子类不同的技术实现，所以由子类实现
  readerIndex = i + 1; //位置后移
  return b;
}

private void checkReadableBytes0(int minimumReadableBytes) {
  ensureAccessible(); //访问确认
  if (checkBounds && readerIndex > writerIndex - minimumReadableBytes) {//是否存在可读数据（）
      throw new IndexOutOfBoundsException(String.format(
       "readerIndex(%d) + length(%d) exceeds writerIndex(%d): %s",
       readerIndex, minimumReadableBytes, writerIndex, this));
  }
}

/**
  * release前都要校验
  * 是否可访问
  * isAccessible() --return refCnt() != 0 //是否存在引用
  * 这里对refCnt做一个说明：初始化对象时会置为1，release会置为0，
  * 当对象不可达后，由于JVM在不知道Netty后续操作，所以可能会释放掉对象，
  * 这样release就没法执行，没有归还资源到内存池中，导致后续内存泄漏，
   * 这里会使用leakDetector 解决该问题
  */
protected final void ensureAccessible() {
    if (checkAccessible && !isAccessible()) { //checkAccessible 配置项，（） ： 
        throw new IllegalReferenceCountException(0);
    }
}

      3. 写Buf（AbstractByteBuf.java）

        public ByteBuf writeByte(int value) {
   ensureWritable0(1);
   _setByte(writerIndex++, value);
  return this;
}

final void ensureWritable0(int minWritableBytes) {
  final int writerIndex = writerIndex();
  final int targetCapacity = writerIndex + minWritableBytes; //写入所需容量
  if (targetCapacity <= capacity()) {//小于当前容量 
      ensureAccessible();
      return; //允许写入
  }
  if (checkBounds && targetCapacity > maxCapacity) { //目标所需容量大于最大容量 抛出OutOfBoundException
      ensureAccessible();
      throw new IndexOutOfBoundsException(String.format(
            "writerIndex(%d) + minWritableBytes(%d) exceeds maxCapacity(%d): %s",
            writerIndex, minWritableBytes, maxCapacity, this));
  } 

  // Normalize the target capacity to the power of 2.
  final int fastWritable = maxFastWritableBytes();//允许写入字节数（多此一举）
  //计算扩容后容量
  int newCapacity = fastWritable >= minWritableBytes ?   writerIndex + fastWritable
      : alloc().calculateNewCapacity(targetCapacity, maxCapacity);

  // Adjust to the new capacity.
  //扩容后需要新建缓冲区，复制不同子类实现不同，
  capacity(newCapacity);
}
/**
  *  AbstractByteBufAllocator.java
  *  计算扩容后容量
  * minNewCapacity 容量下限
  * maxCapacity 容量上限
  */
public int calculateNewCapacity(int minNewCapacity, int maxCapacity) {
  // 参数合法性校验
  checkPositiveOrZero(minNewCapacity, "minNewCapacity");
  if (minNewCapacity > maxCapacity) {
    throw new IllegalArgumentException(String.format(
          "minNewCapacity: %d (expected: not greater than maxCapacity(%d)",
          minNewCapacity, maxCapacity));
  }
  // 设置阈值 4MB
  final int threshold = CALCULATE_THRESHOLD; // 4 MiB page
  //如果是 扩容为阈值直接返回阈值
  if (minNewCapacity == threshold) {
      return threshold;
  }

  // If over threshold, do not double but just increase by threshold.
  // 扩容超过阈值，不翻倍，而是步进阈值（增加阈值的倍数）
  if (minNewCapacity > threshold) {
      int newCapacity = minNewCapacity / threshold * threshold;
      if (newCapacity > maxCapacity - threshold) {
        newCapacity = maxCapacity;
      } else {
          newCapacity += threshold;
      }
      return newCapacity;
  }

  // Not over threshold. Double up to 4 MiB, starting from 64.
 // 小于阈值，倍增（初始值64 ->64 *2 -> 64*2*2）
  int newCapacity = 64;
  while (newCapacity < minNewCapacity) {
      newCapacity <<= 1;
  }
    // 不超过预设的最大容量
    return Math.min(newCapacity, maxCapacity);
}

      4. 重用缓冲区（discardReadBytes）

        public ByteBuf discardReadBytes() {
  //无可重用
  if (readerIndex == 0) {
      ensureAccessible();
      return this;
  }
  //读写位置不同（暗含读位置>0）
  if (readerIndex != writerIndex) {
      // 复制数组，未读取的数据复制到其实位置
      setBytes(0, this, readerIndex, writerIndex - readerIndex);
      //重置读写位置
      writerIndex -= readerIndex;
      adjustMarkers(readerIndex);
      readerIndex = 0;
  } else {
       //读写位置相等，无可读数据，不需要复制，直接位置置0即可重用  
      ensureAccessible();
      adjustMarkers(readerIndex);
      writerIndex = readerIndex = 0;
  }
  return this;
}

      5. 对引用计数进行分析（AbstractReferenceCountedByteBuf.java）

        // 颞部通过原子（AtomicIntegerFieldUpdater）的方式对成员变量进行操作
private static final ReferenceCountUpdater updater = new ReferenceCountUpdater() {
// 追踪对象引用次数
private volatile int refCnt = updater.initialValue();
//引用计数器 +1
public ByteBuf retain() {
  return updater.retain(this);// 最终CAS处理updater().getAndAdd(instance, -rawIncrement);
}
// 引用计数器 -1
public boolean release(int decrement) {
  return handleRelease(updater.release(this, decrement));//最终调用 updater().compareAndSet(instance, expectRawCnt, 1)
}

      6. 非池化堆内存Buf（UnpooledHeapByteBuf）
        频繁内存分配&回收会对性能造成一定影响，但是申请和释放的成本会低一些

        private final ByteBufAllocator alloc; --内存分配器
byte[] array; -- 缓冲数据（这里可以使用Nio中Buffer替代，这里是为了提升性能和更加便捷的进行位操作，）
private ByteBuffer tmpNioBuf; --实现与JDK原生Buffer的转换
// 这里对AbstractByteBuf中要求子类实现的方法进行讲解
// get & set 就是简单的赋值
protected byte _getByte(int index) {
  return HeapByteBufUtil.getByte(array, index);
}
protected void _setByte(int index, int value) {
  HeapByteBufUtil.setByte(array, index, value);
}

//扩容
public ByteBuf capacity(int newCapacity) {
  //参数校验
  checkNewCapacity(newCapacity);
  byte[] oldArray = array;
  int oldCapacity = oldArray.length;
  if (newCapacity == oldCapacity) {//无修改
      return this;
  }
  //拷贝的末尾下标
  int bytesToCopy;
  if (newCapacity > oldCapacity) {
      bytesToCopy = oldCapacity;
  } else {
      //如果是缩容,需要截取到新容量位置，调整readerIndex & writerIndex
      trimIndicesToCapacity(newCapacity);
      bytesToCopy = newCapacity;
  }
  // 创建新数组
  byte[] newArray = allocateArray(newCapacity);
  //拷贝数据到新数组
  System.arraycopy(oldArray, 0, newArray, 0, bytesToCopy);
  //替换关联数组
  setArray(newArray);
  //释放旧数组（NOOP）
  freeArray(oldArray);
  return this;
}
//ByteBuf转原生ByteBuffer
public ByteBuffer nioBuffer(int index, int length) {
    ensureAccessible();
    return ByteBuffer.wrap(array, index, length).slice();
 }
//数组转为ByteBuffer
public static ByteBuffer wrap(byte[] array,
                          int offset, int length)
{
    try {
        //将数组转为ByteBuffer
         return new HeapByteBuffer(array, offset, length);
    } catch (IllegalArgumentException x) {
        throw new IndexOutOfBoundsException();
    }
}

        UnpooledDirectByteBuf与此类类似，将array换位ByteBuffer，分配实现为：ByteBuffer.allocateDirect(initialCapacity)

      7. 池化Buf如何复用

         PooledByteBufAllocator
  //创建堆外Buffer
 protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) {
    //获取线程线程绑定的池缓冲
    PoolThreadCache cache = (PoolThreadCache)this.threadCache.get();
    // 通过缓冲获取到池域
    PoolArena directArena = cache.directArena;
    Object buf;
    if (directArena != null) {
       // 分配内存
       buf = directArena.allocate(cache, initialCapacity, maxCapacity);
    } else {
        buf = PlatformDependent.hasUnsafe() ?       UnsafeByteBufUtil.newUnsafeDirectByteBuf(this, initialCapacity, maxCapacity) : new UnpooledDirectByteBuf(this, initialCapacity, maxCapacity);
    }
    return toLeakAwareBuffer((ByteBuf)buf);
}

PooledByteBuf allocate(PoolThreadCache cache, int reqCapacity, int maxCapacity) {
    //创建缓存
    PooledByteBuf buf = newByteBuf(maxCapacity);
    //分配内存
    allocate(cache, buf, reqCapacity);
    return buf;
}
//创建ByteBuf
protected PooledByteBuf newByteBuf(int maxCapacity) {
        //是否支持un_safe
        if (HAS_UNSAFE) {
            return PooledUnsafeDirectByteBuf.newInstance(maxCapacity);
        } else {
            return PooledDirectByteBuf.newInstance(maxCapacity);
   }
}
// 创建Buf实例
static PooledUnsafeDirectByteBuf newInstance(int maxCapacity) {
    //采用对象线程池（先复用不行再创建）
    PooledUnsafeDirectByteBuf buf = RECYCLER.get();
    buf.reuse(maxCapacity);
    return buf;
}
public final T get() {
    if (maxCapacityPerThread == 0) {
        return newObject((Handle) NOOP_HANDLE);
    }
    //获取线程绑定栈
    Stack stack = threadLocal.get();
    //获取对象句柄
    DefaultHandle handle = stack.pop();
    if (handle == null) { //无法获取，创建对象
        handle = stack.newHandle();
        handle.value = newObject(handle);
    }
    return (T) handle.value;
}

//复用重置相关参数
final void reuse(int maxCapacity) {
    maxCapacity(maxCapacity);
    resetRefCnt();
    setIndex0(0, 0);
    discardMarks();
  }
/**
  *分配内存
  * 主要实现以下逻辑 
  * 每个Chunk是由多个Page组成，PoolChunk主要用来组织管理多个Page的内存分配和释放，
  * 其中的Page被构建成二叉树，内存选择是对树的深度优先遍历，但是同层随机选择，
  * 如果分配内存小于page，PoolSubpage会分成相等的块，分多大是由第一次申请决定的，
  * 后面所有的申请都按这个来，无论是Chunk还是Page都是通过状态位来标识是否可用，
  */
private void allocate(PoolThreadCache cache, PooledByteBuf buf, final int reqCapacity) {
    final int normCapacity = normalizeCapacity(reqCapacity);
    if (isTinyOrSmall(normCapacity)) { // capacity < pageSize
        int tableIdx;
        PoolSubpage[] table;
        boolean tiny = isTiny(normCapacity);
        if (tiny) { // < 512
            if (cache.allocateTiny(this, buf, reqCapacity, normCapacity)) {
                // was able to allocate out of the cache so move on
                return;
            }
            tableIdx = tinyIdx(normCapacity);
            table = tinySubpagePools;
        } else {
            if (cache.allocateSmall(this, buf, reqCapacity, normCapacity)) {
                // was able to allocate out of the cache so move on
                return;
            }
            tableIdx = smallIdx(normCapacity);
            table = smallSubpagePools;
        }

        final PoolSubpage head = table[tableIdx];

      /**
         * Synchronize on the head. This is needed as {@link PoolChunk#allocateSubpage(int)} and
         * {@link PoolChunk#free(long)} may modify the doubly linked list as well.
         */
        synchronized (head) {
            final PoolSubpage s = head.next;
            if (s != head) {
                  assert s.doNotDestroy && s.elemSize == normCapacity;
                long handle = s.allocate();
                assert handle >= 0;
                s.chunk.initBufWithSubpage(buf, null, handle, reqCapacity);
                incTinySmallAllocation(tiny);
                return;
            }
        }
        synchronized (this) {
            allocateNormal(buf, reqCapacity, normCapacity);
        }

        incTinySmallAllocation(tiny);
        return;
    }
    if (normCapacity <= chunkSize) {
        if (cache.allocateNormal(this, buf, reqCapacity, normCapacity)) {
            // was able to allocate out of the cache so move on
            return;
        }
        synchronized (this) {
            allocateNormal(buf, reqCapacity, normCapacity);
            ++allocationsNormal;
        }
    } else {
        // Huge allocations are never served via the cache so just call allocateHuge
        allocateHuge(buf, reqCapacity);
    }
}

  2. Channel

    • 工作原理
      1. 主要负责客户端的连接、网络的读写，链路的关闭、一些框架功能等，在原生Channel诸多不便的情况下，Netty重新设计
      2. 采用Facade封装、功能齐全、聚合原生Channel统一分配调度，
      3. 核心方法 
        io.netty.channel.Channel#alloc --获取Buf分配器
io.netty.channel.Channel#config --配置信息
io.netty.channel.Channel#eventLoop --获取eventLoop
io.netty.channel.Channel#flush --将Buf中的写入Channel 
io.netty.channel.Channel#isActive --是否激活
io.netty.channel.Channel#isOpen --是否打开
io.netty.channel.Channel#isRegistered --是否注册到EventLoop
io.netty.channel.Channel#isWritable --是否可写
io.netty.channel.Channel#localAddress --本地地址
io.netty.channel.Channel#metadata --元数据
io.netty.channel.Channel#pipeline --获取pipeLine
io.netty.channel.Channel#read --读取到Buf
io.netty.channel.Channel#remoteAddress --远端地址

io.netty.channel.ChannelOutboundInvoker#bind(java.net.SocketAddress) --绑定本地Socket地址
io.netty.channel.ChannelOutboundInvoker#connect(java.net.SocketAddress) --连接服务器地址
io.netty.channel.ChannelOutboundInvoker#deregister() --注销
io.netty.channel.ChannelOutboundInvoker#disconnect() --断开连接
io.netty.channel.ChannelOutboundInvoker#writeAndFlush(java.lang.Object) --写入channel
    • 源码解析

      1. 继承关系


        Netty架构模型设计与源码浅析_第23张图片
        Diagram-Channel.png

      2. 抽象统一处理的核心

        • 属性 
           //AbstractChannel
private final Channel parent; --父Channel
private final Unsafe unsafe; 
private final DefaultChannelPipeline pipeline; --所属Pipeline
private final CloseFuture closeFuture = new CloseFuture(this);
private volatile SocketAddress localAddress;
private volatile SocketAddress remoteAddress;
private volatile EventLoop eventLoop; --所注册的EventLoop

// AbstractNioChannel.java
private final SelectableChannel ch; --server 、client的统一父类 
protected final int readInterestOp; --OP_READ事件
volatile SelectionKey selectionKey; --注册到Selector中的Key（volatile 多线程可见）
//AbstractNioByteChannel
//继续写半包消息
private final Runnable flushTask = new Runnable() {
    public void run() {
       // Calling flush0 directly to ensure we not try to flush messages that were added via write(...) in the
       // meantime.
       ((AbstractNioUnsafe) unsafe()).flush0();
   }
};
        • 方法 
          //AbstractChannel
//基本操作都是委托到Pipeline处理
public ChannelFuture bind(SocketAddress localAddress) {
    return pipeline.bind(localAddress);
}

public ChannelFuture connect(SocketAddress remoteAddress) {
    return pipeline.connect(remoteAddress);
}

public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress) {
    return pipeline.connect(remoteAddress, localAddress);
}

public ChannelFuture disconnect() {
    return pipeline.disconnect();
}

public ChannelFuture close() {
    return pipeline.close();
}

// AbstractNioChannel.java
//当前Channel注册到EventLoop
protected void doRegister() throws Exception {
boolean selected = false; //注册标识
  for (;;) {
        try {
          selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this); //将当前channel注册到eventLoop中的Selector ，其中0标识对任何事件不感兴趣
          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();//将失效的SelectorKey移除，继续下次注册
              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;
          }
      }
  }
}
// 读操作
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);//设置家监听读操作
    }
}
//AbstractNioByteChannel
protected void doWrite(ChannelOutboundBuffer in) throws Exception {
    int writeSpinCount = config().getWriteSpinCount();//写操作最大循环次数，默认16，
    do {
        Object msg = in.current();//消息循环数组弹出消息
        if (msg == null) {//无消息 所有消息发送完成
            // Wrote all messages.
            clearOpWrite(); // 清楚半包标识
            // Directly return here so incompleteWrite(...) is not called.
            return;
        }
        writeSpinCount -= doWriteInternal(in, msg);//这里执行写，写的过程可能发生TCP缓冲区已满，导致空循环占用CPU资源，导致IO线程无法处理其他线程
    } while (writeSpinCount > 0);

    incompleteWrite(writeSpinCount < 0);//根据循环是否到达极限，设置写半包标识为true
}
private int doWriteInternal(ChannelOutboundBuffer in, Object msg) throws Exception {
    if (msg instanceof ByteBuf) {  //是否Byte类型
        ByteBuf buf = (ByteBuf) msg;
        if (!buf.isReadable()) { //是否可读
            in.remove(); //不可读移除消息
            return 0;
        }

        final int localFlushedAmount = doWriteBytes(buf); //进行消息发送
        if (localFlushedAmount > 0) {
            in.progress(localFlushedAmount);
            if (!buf.isReadable()) {
                in.remove();
            }
            return 1;// 本次没有发送为0字节（TCP缓冲区已满，可发送循环次数 -1）
        }
    } 
}
//设置是否写完全（写半包处理）
protected final void incompleteWrite(boolean setOpWrite) {
    / / Did not write completely.
    if (setOpWrite) {//是否写完全
        setOpWrite();//未写完全，后续Selector会继续轮询处理为发送完的消息
    } else {
        // It is possible that we have set the write OP, woken up by NIO because the socket is writable, and then
        // use our write quantum. In this case we no longer want to set the write OP because the socket is still
        // writable (as far as we know). We will find out next time we attempt to write if the socket is writable
        // and set the write OP if necessary.
        clearOpWrite();//清除写半包标识

        // Schedule flush again later so other tasks can be picked up in the meantime
        //启动任务，后续写操作
        eventLoop().execute(flushTask);
    }
}
//写不完全，设置标识
protected final void setOpWrite() {
    final SelectionKey key = selectionKey();
    // Check first if the key is still valid as it may be canceled as part of the deregistration
    // from the EventLoop
    // See https://github.com/netty/netty/issues/2104
    if (!key.isValid()) {//是否有效
        return;
    }
    final int interestOps = key.interestOps();
    if ((interestOps & SelectionKey.OP_WRITE) == 0) {
        key.interestOps(interestOps | SelectionKey.OP_WRITE);
    }
}

      3. NioServerSocketChannel.java

         //创建ServerSocketChannel
private static ServerSocketChannel newSocket(SelectorProvider provider) {
  try {
        return provider.openServerSocketChannel();
  } catch (IOException e) {
      throw new ChannelException(
        "Failed to open a server socket.", e);
  }
}
 //基本所有的基础操作都依赖于原生ServerSocketChannel
protected void doBind(SocketAddress localAddress) throws Exception {
  if (PlatformDependent.javaVersion() >= 7) {
      javaChannel().bind(localAddress, config.getBacklog());//
  } else {
      javaChannel().socket().bind(localAddress, config.getBacklog());
  }
}

protected int doReadMessages(List buf) throws Exception {
    //等待客户端连接
    SocketChannel ch = SocketUtils.accept(javaChannel());
    try {
        if (ch != null) {
            //创建客户端SocketChannel
            buf.add(new NioSocketChannel(this, ch));
            return 1;
        }
    } catch (Throwable t) {
             ········
    }
    return 0;
 }
  
      
      4.  
        NioSocketChannel.java
         
        //连接服务
protected boolean doConnect(SocketAddress remoteAddress, SocketAddress localAddress) throws Exception {
   if (localAddress != null) {
      doBind0(localAddress);//绑定地址
  }
  boolean success = false;
  try {
      boolean connected = SocketUtils.connect(javaChannel(), remoteAddress);//连接服务
      if (!connected) {
     selectionKey().interestOps(SelectionKey.OP_CONNECT);//没有立即连接成功，注册连接事件
      }
      success = true;
      return connected;
  } finally {
      if (!success) {
          doClose();//连接失败，关闭连接
      }
  }
}

         
        5.  
      
      5.  
        UnSafe（Channel的辅助接口）
         
         
       
         
        
         
         
         
          Netty架构模型设计与源码浅析_第24张图片 
         
         
        
         
        
        
          Diagram-UnSafe.png 
        
         
       
         
        //将Channel注册到EventLoop中的Selector
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
    ObjectUtil.checkNotNull(eventLoop, "eventLoop");
    if (isRegistered()) {//是否已经注册过
         promise.setFailure(new IllegalStateException("registered to an event loop already"));
        return;
    }
    if (!isCompatible(eventLoop)) {//是否是兼容Loop
        promise.setFailure(
                new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
        return;
    }
    AbstractChannel.this.eventLoop = eventLoop;

    if (eventLoop.inEventLoop()) {//当前线程是否为EventLoop线程
        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);
        }
    }
}

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();
    //设置标记位
    neverRegistered = false;
    registered = true;
    pipeline.invokeHandlerAddedIfNeeded();//回调pipeline中的handlerAdded()方法，通知注册成功
    safeSetSuccess(promise);//设置异步状态
    pipeline.fireChannelRegistered(); //回调pipeLine.fireChannelRegistered()
    if (isActive()) {//是否激活
        if (firstRegistration) {//第一次激活
            pipeline.fireChannelActive();//回调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);
  }
}
//其他放方法不再赘述

         
        6.  
       
     
  
      6.  
        ChannelPipeline
         
   
           
    
        • 工作原理
           类似与过滤器组，通过职责链模式对用户是的事件拦截处理，在前面我们已经大体介绍了原理。Netty中的事件分为inbound与outbound， 
     
             
      
          • inbound事件方法：fireXXX()
            •  
      
          • outbound事件方法：bind()、 connect()、 write()、 flush()、 read()、disconnect()、 close()
            •  
     
           
          •  
    
        • 源码解析 
          public final ChannelPipeline addBefore(
     EventExecutorGroup group, String baseName, String name, ChannelHandler handler) {
 final AbstractChannelHandlerContext newCtx;
 final AbstractChannelHandlerContext ctx;
 synchronized (this) {//保证线程安全
     checkMultiplicity(handler);//如果handler不共享 & 在pipeLine中已经存在
     name = filterName(name, handler);
     ctx = getContextOrDie(baseName);//更具名称获取HandlerContext
     newCtx = newContext(group, name, handler);//创建新HandlerContext

     addBefore0(ctx, newCtx);//双向列表添加handler
     /**
       * newCtx.prev = ctx.prev;
       *newCtx.next = ctx;
       *ctx.prev.next = newCtx;
       *ctx.prev = newCtx;
       */
     // If the registered is false it means that the channel was not registered on an eventLoop yet.
     // In this case we add the context to the pipeline and add a task that will call
     // ChannelHandler.handlerAdded(...) once the channel is registered.
     if (!registered) {
         newCtx.setAddPending();
         callHandlerCallbackLater(newCtx, true);
         return this;
     }

     EventExecutor executor = newCtx.executor();
     if (!executor.inEventLoop()) {
         callHandlerAddedInEventLoop(newCtx, executor);
         return this;
     }
 }
 callHandlerAdded0(newCtx);
 return this;
}

//事件是如何传递的（以fireChannelActive事件分析）
public ChannelHandlerContext fireChannelRead(final Object msg) {
 invokeChannelRead(findContextInbound(MASK_CHANNEL_READ), msg);
 return this;
}
//查找inBound相关ctx并返回（Handler的顺序执行核心代码)
private AbstractChannelHandlerContext findContextInbound(int mask) {
 AbstractChannelHandlerContext ctx = this;
 do {
     ctx = ctx.next;
 } while ((ctx.executionMask & mask) == 0);//是否Inbound相关实现，旨在寻找俩一个handler
 return ctx;
}
//执行channelRead方法
static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
 final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
 EventExecutor executor = next.executor();
 if (executor.inEventLoop()) {//是否EventLoop线程
     next.invokeChannelRead(m);//直接调用
 } else {
     executor.execute(new Runnable() {//新起Task
         @Override
         public void run() {
             next.invokeChannelRead(m);
         }
     });
 }
}
private void invokeChannelRead(Object msg) {
 if (invokeHandler()) {//是否调用过该Handler
     try {
         ((ChannelInboundHandler) handler()).channelRead(this, msg);//调用过，传递事件
     } catch (Throwable t) {
         notifyHandlerException(t);
     }
 } else {
     fireChannelRead(msg);//直接调用
 }
}

           
          •  
   
         
        7.  
  
      7.  
        ChannelHandler
         
   
           
    
        • 工作原理 
     
             
      
          1.  
            继承关系
             
             
       
             
        
             
         
             
          Netty架构模型设计与源码浅析_第25张图片 
         
             
        
             
        
            
          Diagram-ChannelHandler.png 
        
             
       
             
            2.  
     
           
          •  
    
        • 源码解析
           主要分析ByteToMessageDecoder 
          public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  if (msg instanceof ByteBuf) {//是否ByteBuf
      CodecOutputList out = CodecOutputList.newInstance();
      try {
          first = cumulation == null;//是否存在未解码的消息
          cumulation = cumulator.cumulate(ctx.alloc(),
                  first ? Unpooled.EMPTY_BUFFER : cumulation, (ByteBuf) msg);//根据是否半包消息，分配Buf
          callDecode(ctx, cumulation, out);//解码
      } catch (DecoderException e) {
          throw e;
      } catch (Exception e) {
          throw new DecoderException(e);
      } finally {//释放资源
          if (cumulation != null && !cumulation.isReadable()) {
              numReads = 0;
              cumulation.release();
              cumulation = null;
          } else if (++ numReads >= discardAfterReads) {
              // We did enough reads already try to discard some bytes so we not risk to see a OOME.
              // See https://github.com/netty/netty/issues/4275
              numReads = 0;
              discardSomeReadBytes();
          }

          int size = out.size();
          firedChannelRead |= out.insertSinceRecycled();
          fireChannelRead(ctx, out, size);
          out.recycle();
      }
  } else {
      ctx.fireChannelRead(msg);
  }
}
//解码
protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List out) {
  try {
      while (in.isReadable()) {//是否存在可读
          int outSize = out.size();
          if (outSize > 0) {//如果存在解码但未发送的消息
              fireChannelRead(ctx, out, outSize);//将消息透传出去
              out.clear();//清空以解码消息集合

              // Check if this handler was removed before continuing with decoding.
              // If it was removed, it is not safe to continue to operate on the buffer.
              //
              // See:
              // - https://github.com/netty/netty/issues/4635
              if (ctx.isRemoved()) {//当前ctx是否已经被移除
                  break;
              }
              outSize = 0;
          }

          int oldInputLength = in.readableBytes();//可读字节数
          decodeRemovalReentryProtection(ctx, in, out);//尝试对何合并后的消息进行解码

          // Check if this handler was removed before continuing the loop.
          // If it was removed, it is not safe to continue to operate on the buffer.
          //
          // See https://github.com/netty/netty/issues/1664
          if (ctx.isRemoved()) {//如果decodeRemovalReentryProtection尝试解码成功
              break;
          }

          if (outSize == out.size()) {//如果没有生成解码消息，说明是半包
              if (oldInputLength == in.readableBytes()) {//任然没有新刻度消息，推出循环
                  break;
              } else {
                  continue;//否者继续读
              }
          }

          if (oldInputLength == in.readableBytes()) {//没有读取成功
              throw new DecoderException(
                      StringUtil.simpleClassName(getClass()) +
                              ".decode() did not read anything but decoded a message.");
          }

          if (isSingleDecode()) {//是否是单条信息解码器，如果是推出循环，解码完成
              break;
          }
      }
  } catch (DecoderException e) {
      throw e;
  } catch (Exception cause) {
      throw new DecoderException(cause);
  }
}
  
     
  
        •  
          EventLoop
           
   
             
    
          • 工作原理 
     
               
      
            1.  
              继承关系
               
               
       
               
        
               
         
               
          Netty架构模型设计与源码浅析_第26张图片 
         
               
        
               
        
              
          Diagram-EventLoop.png 
        
               
       
               
              2.  
      
            2. 是Netty线程设计的完美体现，提升并发性能，很大程度避免锁，局部无锁话，前面已经分析了线程模型的原理，如何通过参数就可以在Reactor各个模型间完美切换等，这里不再赘述
              3.  
     
             
            •  
    
          • 源码解析 
            private Selector selector; //selector的包装对象(通过 **io.netty.noKeySetOptimization** 配置是否开启，默认不开启)
private Selector unwrappedSelector; //原生Selector对象
private SelectedSelectionKeySet selectedKeys;
private final SelectorProvider provider; //Selector提供者，通过SPI实现
//开启Selector
private SelectorTuple openSelector() {
  final Selector unwrappedSelector;
  try {
      unwrappedSelector = provider.openSelector();//设置原生Selector
  } catch (IOException e) {
      throw new ChannelException("failed to open a new selector", e);
  }

  if (DISABLE_KEY_SET_OPTIMIZATION) {//是否开启Selector优化（io.netty.noKeySetOptimization）
      return new SelectorTuple(unwrappedSelector);//未开启，直接返回
  }
  //反射获取Selector实现
  Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction() {
      @Override
      public Object run() {
          try {
              return Class.forName(
                      "sun.nio.ch.SelectorImpl",
                      false,
                      PlatformDependent.getSystemClassLoader());
          } catch (Throwable cause) {
              return cause;
          }
      }
  });
  //是否为Class
  if (!(maybeSelectorImplClass instanceof Class) ||
      // ensure the current selector implementation is what we can instrument.
      !((Class) maybeSelectorImplClass).isAssignableFrom(unwrappedSelector.getClass())) {
      if (maybeSelectorImplClass instanceof Throwable) {
          Throwable t = (Throwable) maybeSelectorImplClass;
          logger.trace("failed to instrument a special java.util.Set into: {}", unwrappedSelector, t);
      }
      return new SelectorTuple(unwrappedSelector);
  }

  final Class selectorImplClass = (Class) maybeSelectorImplClass;
  final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();
   //反射获取SelectedKeys、publicSelectedKeys，通过Netty生成相应替代类
  Object maybeException = AccessController.doPrivileged(new PrivilegedAction() {
      @Override
      public Object run() {
          try {
              //反射获取属性
              Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
              Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");

              if (PlatformDependent.javaVersion() >= 9 && PlatformDependent.hasUnsafe()) {
                  // Let us try to use sun.misc.Unsafe to replace the SelectionKeySet.
                  // This allows us to also do this in Java9+ without any extra flags.
                  long selectedKeysFieldOffset = PlatformDependent.objectFieldOffset(selectedKeysField);
                  long publicSelectedKeysFieldOffset =
                          PlatformDependent.objectFieldOffset(publicSelectedKeysField);

                  if (selectedKeysFieldOffset != -1 && publicSelectedKeysFieldOffset != -1) {
                      PlatformDependent.putObject(
                              unwrappedSelector, selectedKeysFieldOffset, selectedKeySet);
                      PlatformDependent.putObject(
                              unwrappedSelector, publicSelectedKeysFieldOffset, selectedKeySet);
                      return null;
                  }
                  // We could not retrieve the offset, lets try reflection as last-resort.
              }

              Throwable cause = ReflectionUtil.trySetAccessible(selectedKeysField, true);
              if (cause != null) {
                  return cause;
              }
              cause = ReflectionUtil.trySetAccessible(publicSelectedKeysField, true);
              if (cause != null) {
                  return cause;
              }

              selectedKeysField.set(unwrappedSelector, selectedKeySet);
              publicSelectedKeysField.set(unwrappedSelector, selectedKeySet);
              return null;
          } catch (NoSuchFieldException e) {
              return e;
          } catch (IllegalAccessException e) {
              return e;
          }
      }
  });

  if (maybeException instanceof Exception) {
      selectedKeys = null;
      Exception e = (Exception) maybeException;
      logger.trace("failed to instrument a special java.util.Set into: {}", unwrappedSelector, e);
      return new SelectorTuple(unwrappedSelector);
  }
  selectedKeys = selectedKeySet;
  logger.trace("instrumented a special java.util.Set into: {}", unwrappedSelector);
  return new SelectorTuple(unwrappedSelector,
                           new SelectedSelectionKeySetSelector(unwrappedSelector, selectedKeySet));
}
//运行EventLoop
protected void run() {
          cancelledKeys = 0;
          needsToSelectAgain = false;
          final int ioRatio = this.ioRatio;
          boolean ranTasks;
          if (ioRatio == 100) {//百分百处理IO任务
              try {
                      processSelectedKeys();//执行IO操作
              } finally {
                  // Ensure we always run tasks.
                  ranTasks = runAllTasks();//执行非IO任务
              }
          } 
}
//处理IO任务
private void processSelectedKeysOptimized() {
  for (int i = 0; i < selectedKeys.size; ++i) {//循环所有Key
      final SelectionKey k = selectedKeys.keys[i];
      // null out entry in the array to allow to have it GC'ed once the Channel close
      // See https://github.com/netty/netty/issues/2363
      selectedKeys.keys[i] = null;

      final Object a = k.attachment();

      if (a instanceof AbstractNioChannel) {
          processSelectedKey(k, (AbstractNioChannel) a);//通过Select中OPS对事件进行分发
      } else {
          @SuppressWarnings("unchecked")
          NioTask task = (NioTask) a;
          processSelectedKey(k, task);
      }

      if (needsToSelectAgain) {
          // null out entries in the array to allow to have it GC'ed once the Channel close
          // See https://github.com/netty/netty/issues/2363
          selectedKeys.reset(i + 1);
          selectAgain();
          i = -1;
      }
  }
}

 // returns true if selectCnt should be reset
 //这里是Netty对epool bug的规避
private boolean unexpectedSelectorWakeup(int selectCnt) {//这里判断是否要重建Selector 
  //通过io.netty.selectorAutoRebuildThreshold进行配置 默认512
  //如果selectCnt（轮询次数）次数大于配置值，就进行重建Selector
  if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
          selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {
      // The selector returned prematurely many times in a row.
      // Rebuild the selector to work around the problem.
      logger.warn("Selector.select() returned prematurely {} times in a row; rebuilding Selector {}.",
              selectCnt, selector);
      rebuildSelector();//重建Selector 避免Selector空轮询
      return true;
  }
  return false;
}

  
     
  
 
            五、总结
             
 
            Netty作为高性能的NIO通信框架，延续了NIO的诸多特性的同时，还对NIO存在的问题，做统一的规避与优化，主要从内存、线程、编解码、传输等方面，通过巧妙地线程模型设计、堆与直接内存的合理使用、环形数组缓冲区、无锁并发、内存池化重用、引用计数器等技术对性能做了很大的提升，通过学习Netty架构在分层、稳定、扩展等方面的巧妙设计，受益良多。
             

                            
                        
                    
                    
                    
            
                    
                    
                    
            
                
                
            
                    
                
            
            
        
    
    
            
        
            你可能感兴趣的:(Netty架构模型设计与源码浅析)
            
        
            
            
            
                
              
                    
            • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
              很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
              
                    
              • 
                    
            • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
              功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
              
                    
              • 
                    
            • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
              一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
              
                    
              • 
                    
            • 随笔 | 仙一般的灵气
                        海思沧海

                        
              仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
              
                    
              • 
                    
            • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
              MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
              
                    
              • 
                    
            • 一百九十四章. 自相矛盾
                        巨木擎天

                        
              唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
              
                    
              • 
                    
            • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
              在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
              
                    
              • 
                    
            • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
              昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
              
                    
              • 
                    
            • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
              《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
              
                    
              • 
                    
            • Long类型前后端数据不一致
                        igotyback
前端
                        
              响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
              
                    
              • 
                    
            • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
              摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
              
                    
              • 
                    
            • 2021-08-26
                        影幽

                        
              在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
              
                    
              • 
                    
            • 高级编程--XML+socket练习题
                        masa010
java开发语言
                        
              1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
              
                    
              • 
                    
            • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
              预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
              
                    
              • 
                    
            • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
              重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
              
                    
              • 
                    
            • 每日一题——第九十题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
              题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
              
                    
              • 
                    
            • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
              在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
              
                    
              • 
                    
            • 《庄子.达生9》
                        钱江潮369

                        
              【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
              
                    
              • 
                    
            • 水泥质量纠纷案代理词
                        徐宝峰律师

                        
              贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
              
                    
              • 
                    
            • 腾讯云技术深度探索：构建高效云原生微服务架构
                        我的运维人生
云原生架构腾讯云运维开发技术共享
                        
              腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
              
                    
              • 
                    
            • Goolge earth studio 进阶4——路径修改与平滑
                        陟彼高冈yu
Googleearthstudio进阶教程旅游
                        
              如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
              
                    
              • 
                    
            • 关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验java数据库开发语言
                        
              目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
              
                    
              • 
                    
            • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
                        成长时间线

                        
              7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
              
                    
              • 
                    
            • 山东大学小树林支教调研团青青仓木队——翟晓楠
                        山东大学青青仓木队

                        
              过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
              
                    
              • 
                    
            • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
              随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
              
                    
              • 
                    
            • 四章-32-点要素的聚合
                        彩云飘过

                        
              本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
              
                    
              • 
                    
            • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
              ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
              
                    
              • 
                    
            • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
              不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
              
                    
              • 
                    
            • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商
                        nseejrukjhad
langchaineasyui前端python
                        
              #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
              
                    
              • 
                    
            • 利用Requests Toolkit轻松完成HTTP请求
                        nseejrukjhad
http网络协议网络python
                        
              RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
              
                    
              • 
                                
            • 如何用ruby来写hadoop的mapreduce并生成jar包
                                    wudixiaotie
mapreduce
                                    
              ruby来写hadoop的mapreduce，我用的方法是rubydoop。怎么配置环境呢： 
1.安装rvm： 
    不说了 网上有 
2.安装ruby： 
    由于我以前是做ruby的，所以习惯性的先安装了ruby，起码调试起来比jruby快多了。 
3.安装jruby： 
    rvm install jruby然后等待安
              
                                
              • 
                                
            • java编程思想 -- 访问控制权限
                                    百合不是茶
java访问控制权限单例模式
                                    
              访问权限是java中一个比较中要的知识点,它规定者什么方法可以访问,什么不可以访问 
  
一:包访问权限; 
  
自定义包: 
package com.wj.control;
//包
public class Demo {
  //定义一个无参的方法
	public void DemoPackage(){
		System.out.println("调用
              
                                
              • 
                                
            • [生物与医学]请审慎食用小龙虾
                                    comsci
生物
                                    
               
     现在的餐馆里面出售的小龙虾,有一些是在野外捕捉的,这些小龙虾身体里面可能带有某些病毒和细菌,人食用以后可能会导致一些疾病,严重的甚至会死亡..... 
 
     所以,参加聚餐的时候,最好不要点小龙虾...就吃养殖的猪肉,牛肉,羊肉和鱼,等动物蛋白质 
    
              
                                
              • 
                                
            • org.apache.jasper.JasperException: Unable to compile class for JSP:
                                    商人shang
maven2.2jdk1.8
                                    
              环境： jdk1.8    maven  tomcat7-maven-plugin  2.0 
原因： tomcat7-maven-plugin  2.0 不知吃 jdk 1.8，换成 tomcat7-maven-plugin  2.2就行，即 
  
  
<plugin>
				
              
                                
              • 
                                
            • 你的垃圾你处理掉了吗?GC
                                    oloz
GC
                                    
              前序:本人菜鸟，此文研究学习来自网络，各位牛牛多指教　 
 
 
 
1.垃圾收集算法的核心思想 
　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。 
　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别
              
                                
              • 
                                
            • shiro 和 SESSSION
                                    杨白白
shiro
                                    
              shiro 在web项目里默认使用的是web容器提供的session，也就是说shiro使用的session是web容器产生的，并不是自己产生的，在用于非web环境时可用其他来源代替。在web工程启动的时候它就和容器绑定在了一起，这是通过web.xml里面的shiroFilter实现的。通过session.getSession()方法会在浏览器cokkice产生JESSIONID，当关闭浏览器，此
              
                                
              • 
                                
            • 移动互联网终端 淘宝客如何实现盈利
                                    小桔子
移動客戶端淘客淘寶App
                                    
                     2012年淘宝联盟平台为站长和淘宝客带来的分成收入突破30亿元，同比增长100%。而来自移动端的分成达1亿元，其中美丽说、蘑菇街、果库、口袋购物等App运营商分成近5000万元。 可以看出，虽然目前阶段PC端对于淘客而言仍旧是盈利的大头，但移动端已经呈现出爆发之势。而且这个势头将随着智能终端(手机，平板)的加速普及而更加迅猛
              
                                
              • 
                                
            • wordpress小工具制作
                                    aichenglong
wordpress小工具
                                    
              wordpress 使用侧边栏的小工具，很方便调整页面结构 
小工具的制作过程 
1 在自己的主题文件中新建一个文件夹(如widget)，在文件夹中创建一个php(AWP_posts-category.php) 
小工具是一个类,想侧边栏一样，还得使用代码注册，他才可以再后台使用，基本的代码一层不变 
<?php 
 class AWP_Post_Category extends WP_Wi
              
                                
              • 
                                
            • JS微信分享
                                    AILIKES
js
                                    
              // 所有功能必须包含在 WeixinApi.ready 中进行 
   WeixinApi.ready(function(Api) { 
       // 微信分享的数据 
           var wxData = { 
      &nb
              
                                
              • 
                                
            • 封装探讨
                                    百合不是茶
JAVA面向对象 封装
                                    
              //封装   属性 方法 将某些东西包装在一起，通过创建对象或使用静态的方法来调用，称为封装；封装其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题，增加代码的可读性和可维护性 
  
在 Aname类中申明三个属性，将其封装在一个类中：通过对象来调用 
  
例如   1： 
	//属性 将其设为私有
	姓名 name 可以公开

              
                                
              • 
                                
            • jquery radio/checkbox change事件不能触发的问题
                                    bijian1013
JavaScriptjquery
                                    
              我想让radio来控制当前我选择的是机动车还是特种车，如下所示：  
<html> 
<head> 
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"><
              
                                
              • 
                                
            • AngularJS中安全性措施
                                    bijian1013
JavaScriptAngularJS安全性XSRFJSON漏洞
                                    
                      在使用web应用中，安全性是应该首要考虑的一个问题。AngularJS提供了一些辅助机制，用来防护来自两个常见攻击方向的网络攻击。 
一.JSON漏洞 
        当使用一个GET请求获取JSON数组信息的时候（尤其是当这一信息非常敏感，
              
                                
              • 
                                
            • [Maven学习笔记九]Maven发布web项目
                                    bit1129
maven
                                    
              基于Maven的web项目的标准项目结构 
user-project 
    user-core 
    user-service 
    user-web 
       src 
     
              
                                
              • 
                                
            • 【Hive七】Hive用户自定义聚合函数(UDAF)
                                    bit1129
hive
                                    
              用户自定义聚合函数，用户提供的多个入参通过聚合计算(求和、求最大值、求最小值)得到一个聚合计算结果的函数。 
问题：UDF也可以提供输入多个参数然后输出一个结果的运算，比如加法运算add(3，5)，add这个UDF需要实现UDF的evaluate方法,那么UDF和UDAF的实质分别究竟是什么？ 
  
Double evaluate(Double a, Double b) 
 
              
                                
              • 
                                
            • 通过 nginx-lua 给 Nginx 增加 OAuth 支持
                                    ronin47

                                    
              前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGeek 在过去几年中取得了发展，我们已经积累了不少针对各种任务的不同管理接口。我们通常为新的展示需求创建新模块，比如我们自己的博客、图表等。我们还定期开发内部工具来处理诸如部署、可视化操作及事件处理等事务。在处理这些事务中，我们使用了几个不同的接口来认证： 
&n
              
                                
              • 
                                
            • 利用tomcat-redis-session-manager做session同步时自定义类对象属性保存不上的解决方法
                                    bsr1983
session
                                    
              在利用tomcat-redis-session-manager做session同步时，遇到了在session保存一个自定义对象时，修改该对象中的某个属性，session未进行序列化，属性没有被存储到redis中。   在 tomcat-redis-session-manager的github上有如下说明：   Session Change Tracking 
As noted in the &qu
              
                                
              • 
                                
            • 《代码大全》表驱动法-Table Driven Approach-1
                                    bylijinnan
java算法
                                    
              关于Table Driven Approach的一篇非常好的文章： 
 
http://www.codeproject.com/Articles/42732/Table-driven-Approach 
 
 
package com.ljn.base;

import java.util.Random;

public class TableDriven {

    public 
              
                                
              • 
                                
            • Sybase封锁原理
                                    chicony
Sybase
                                    
                     昨天在操作Sybase IQ12.7时意外操作造成了数据库表锁定，不能删除被锁定表数据也不能往其中写入数据。由于着急往该表抽入数据，因此立马着手解决该表的解锁问题。     无奈此前没有接触过Sybase IQ12.7这套数据库产品，加之当时已属于下班时间无法求助于支持人员支持，因此只有借助搜索引擎强大的
              
                                
              • 
                                
            • java异常处理机制
                                    CrazyMizzz
java
                                    
              java异常关键字有以下几个，分别为 try catch final throw throws 
他们的定义分别为 
try：    Opening exception-handling statement. 
catch：  Captures the exception. 
finally： Runs its code before terminating
              
                                
              • 
                                
            • hive 数据插入DML语法汇总
                                    daizj
hiveDML数据插入
                                    
              Hive的数据插入DML语法汇总1、Loading files into tables语法：1) LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)]解释：1)、上面命令执行环境为hive客户端环境下： hive>l
              
                                
              • 
                                
            • 工厂设计模式
                                    dcj3sjt126com
设计模式
                                    
                使用设计模式是促进最佳实践和良好设计的好办法。设计模式可以提供针对常见的编程问题的灵活的解决方案。  工厂模式 
工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。  
Example #1 调用工厂方法（带参数）   
<?phpclass Example{ 
              
                                
              • 
                                
            • mysql字符串查找函数
                                    dcj3sjt126com
mysql
                                    
                
FIND_IN_SET(str,strlist) 
假如字符串str 在由N 子链组成的字符串列表strlist 中，则返回值的范围在1到 N 之间。一个字符串列表就是一个由一些被‘,’符号分开的自链组成的字符串。如果第一个参数是一个常数字符串，而第二个是type SET列，则   FIND_IN_SET() 函数被优化，使用比特计算。如果str不在strlist 或st
              
                                
              • 
                                
            • jvm内存管理
                                    easterfly
jvm
                                    
              一、JVM堆内存的划分 
 分为年轻代和年老代。年轻代又分为三部分：一个eden,两个survivor。 
 工作过程是这样的：e区空间满了后，执行minor gc，存活下来的对象放入s0, 对s0仍会进行minor gc，存活下来的的对象放入s1中，对s1同样执行minor gc，依旧存活的对象就放入年老代中； 
 年老代满了之后会执行major gc，这个是stop the word模式，执行
              
                                
              • 
                                
            • CentOS-6.3安装配置JDK-8
                                    gengzg
centos
                                    
              JAVA_HOME=/usr/java/jdk1.8.0_45
JRE_HOME=/usr/java/jdk1.8.0_45/jre
PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib
export JAVA_HOME
              
                                
              • 
                                
            • 【转】关于web路径的获取方法
                                    huangyc1210
Web路径
                                    
              假定你的web application 名称为news,你在浏览器中输入请求路径：  http://localhost:8080/news/main/list.jsp  则执行下面向行代码后打印出如下结果：  1、 System.out.println(request.getContextPath()); //可返回站点的根路径。也就是项
              
                                
              • 
                                
            • php里获取第一个中文首字母并排序
                                    远去的渡口
数据结构PHP
                                    
              很久没来更新博客了，还是觉得工作需要多总结的好。今天来更新一个自己认为比较有成就的问题吧。 最近在做储值结算，需求里结算首页需要按门店的首字母A-Z排序。我的数据结构原本是这样的： 
Array
(
    [0] => Array
        (
            [sid] => 2885842
            [recetcstoredpay] =&g
              
                                
              • 
                                
            • java内部类
                                    hm4123660
java内部类匿名内部类成员内部类方法内部类
                                    
                   　在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。内部类可以间接解决多继承问题,可以使用内部类继承一个类，外部类继承一个类，实现多继承。 
     &nb
              
                                
              • 
                                
            • Caused by: java.lang.IncompatibleClassChangeError: class org.hibernate.cfg.Exten
                                    zhb8015

                                    
              maven pom.xml关于hibernate的配置和异常信息如下，查了好多资料，问题还是没有解决。只知道是包冲突，就是不知道是哪个包....遇到这个问题的分享下是怎么解决的。。 
  
maven pom: 
  
		<dependency>
			<groupId>org.hibernate</groupId>
			<ar
              
                                
              • 
                                
            • Spark 性能相关参数配置详解－任务调度篇
                                    Stark_Summer
sparkcachecpu任务调度yarn
                                    
              随着Spark的逐渐成熟完善, 越来越多的可配置参数被添加到Spark中来, 本文试图通过阐述这其中部分参数的工作原理和配置思路, 和大家一起探讨一下如何根据实际场合对Spark进行配置优化。 
  
由于篇幅较长，所以在这里分篇组织，如果要看最新完整的网页版内容，可以戳这里：http://spark-config.readthedocs.org/，主要是便
              
                                
              • 
                                
            • css3滤镜
                                    wangkeheng
htmlcss
                                    
              经常看到一些网站的底部有一些灰色的图标，鼠标移入的时候会变亮，开始以为是js操作src或者bg呢，搜索了一下，发现了一个更好的方法：通过css3的滤镜方法。 
 
html代码： 
 
<a href='' class='icon'><img src='utv.jpg' /></a> 
css代码： 
 
.icon{-webkit-filter: graysc
              
                                
              •