长情知热爱
长情知热爱

Netty-Netty组件了解

EventLoop 和 EventLoopGroup

        回想一下我们在 NIO 中是如何处理我们关心的事件的？在一个 while 循环中 select 出事
件，然后依次处理每种事件。我们可以把它称为事件循环，这就是 EventLoop 。 interface
io.netty.channel. EventLoop 定义了 Netty 的核心抽象，用于处理网络连接的生命周期中所发
生的事件。
        io.netty.util.concurrent 包构建在 JDK 的 java.util.concurrent 包上。 而 io.netty.channel 包
中的类，为了与 Channel 的事件进行交互，扩展了这些接口/类。 一个 EventLoop 将由一个
永远都不会改变的 Thread 驱动，同时任务（ Runnable 或者 Callable ）可以直接提交给
EventLoop 实现，以立即执行或者调度执行。
Netty-Netty组件了解_第1张图片

线程的分配

         服务于 Channel 的 I/O 和事件的 EventLoop 包含在 EventLoopGroup 中。
        异步传输实现只使用了少量的 EventLoop （以及和它们相关联的 Thread ），而且在当前
的线程模型中，它们可能会被多个 Channel 所共享。这使得可以通过尽可能少量的 Thread 来
支撑大量的 Channel ，而不是每个 Channel 分配一个 Thread 。 EventLoopGroup 负责为每个
新创建的 Channel 分配一个 EventLoop 。 在当前实现中，使用顺序循环（round-robin）的方
式进行分配以获取一个均衡的分布，并且相同的 EventLoop 可能会被分配给多个 Channel 。
        一旦一个 Channel 被分配给一个 EventLoop ，它将在它的整个生命周期中都使用这个
EventLoop （以及相关联的 Thread ）。
Netty-Netty组件了解_第2张图片

        需要注意，EventLoop 的分配方式对 ThreadLocal 的使用的影响。因为一个 EventLoop 通
常会被用于支撑多个 Channel ，所以对于所有相关联的 Channel 来说， ThreadLocal 都将是
一样的。这使得它对于实现状态追踪等功能来说是个糟糕的选择。然而，在一些无状态的上
下文中，它仍然可以被用于在多个 Channel 之间共享一些重度的或者代价昂贵的对象，甚
至是事件。

线程管理

         在内部，当提交任务到如果（当前）调用线程正是支撑 EventLoop 的线程，那么所提交
的代码块将会被（直接）执行。 否则， EventLoop 将调度该任务以便稍后执行，并将它放入
到内部队列中。当 EventLoop 下次处理它的事件时，它会执行队列中的那些任务 / 事件。
Netty-Netty组件了解_第3张图片

Channel、EventLoop(Group)和 ChannelFuture

         Netty 网络抽象的代表：
        Channel—Socket；
        EventLoop—控制流、多线程处理、并发；
        ChannelFuture—异步通知。
        Channel 和 EventLoop 关系如图
Netty-Netty组件了解_第4张图片
        从图上我们可以看出 Channel 需要被注册到某个 EventLoop 上，在 Channel 整个生命周
期内都由这个EventLoop处理IO事件，也就是说一个Channel和一个EventLoop进行了绑定，
但是一个EventLoop可以同时被多个Channel绑定。 这一点在“ EventLoop 和 EventLoopGroup ”
节里也提及过。

Channel 接口

        基本的 I/O 操作（ bind() 、 connect() 、 read() 和 write() ）依赖于底层网络传输所提供的原
语。在基于 Java 的网络编程中，其基本的构造是类 Socket 。 Netty 的 Channel 接口所提供
的 API ，被用于所有的 I/O 操作。大大地降低了直接使用 Socket 类的复杂性。此外， Channel
也是拥有许多预定义的、专门化实现的广泛类层次结构的根。
        由于 Channel 是独一无二的，所以为了保证顺序将 Channel 声明为 java.lang.Comparable
的一个子接口。因此，如果两个不同的 Channel 实例都返回了相同的散列码，那么
AbstractChannel 中的 compareTo() 方法的实现将会抛出一个 Error 。
Channel 的生命周期状态
         ChannelUnregistered ： Channel 已经被创建，但还未注册到 EventLoop
        ChannelRegistered ： Channel 已经被注册到了 EventLoop
         ChannelActive ： Channel 处于活动状态（已经连接到它的远程节点）。它现在可以接
收和发送数据了
         ChannelInactive ： Channel 没有连接到远程节点
         当这些状态发生改变时，将会生成对应的事件。这些事件将会被转发给 ChannelPipeline
中的 ChannelHandler，其可以随后对它们做出响应。在我们的编程中，关注 ChannelActive 和
ChannelInactive 会更多一些。
重要 Channel 的方法
         eventLoop： 返回分配给 Channel 的 EventLoop
         pipeline： 返回 Channel 的 ChannelPipeline ，也就是说每个 Channel 都有自己的
ChannelPipeline 。
         isActive： 如果 Channel 是活动的，则返回 true 。活动的意义可能依赖于底层的传输。
例如，一个 Socket 传输一旦连接到了远程节点便是活动的，而一个 Datagram 传输一旦被
打开便是活动的。
         localAddress： 返回本地的 SokcetAddress
         remoteAddress： 返回远程的 SocketAddress
         write： 将数据写到远程节点，注意，这个写只是写往 Netty 内部的缓存，还没有真正
写往 socket 。
         flush： 将之前已写的数据冲刷到底层 socket 进行传输。
         writeAndFlush： 一个简便的方法，等同于调用 write() 并接着调用 flush()

ChannelPipeline 和 ChannelHandlerContext

ChannelPipeline 接口

        当 Channel 被创建时，它将会被自动地分配一个新的 ChannelPipeline ，每个 Channel 都
有自己的 ChannelPipeline 。这项关联是永久性的。在 Netty 组件的生命周期中，这是一项固
定的操作，不需要开发人员的任何干预。
        ChannelPipeline 提供了 ChannelHandler 链的容器，并定义了用于在该链上传播 入站（也
就是从网络到业务处理） 和 出站（也就是从业务处理到网络） ，各种事件流的 API ，我们
代码中的 ChannelHandler 都是放在 ChannelPipeline 中的。
        使得事件流经 ChannelPipeline 是 ChannelHandler 的工作，它们是在应用程序的初始化
或者引导阶段被安装的。这些 ChannelHandler 对象接收事件、执行它们所实现的处理逻辑，
并将数据传递给链中的下一个 ChannelHandler ，而且 ChannelHandler 对象也完全可以拦截
事件不让事件继续传递。它们的执行顺序是由它们被添加的顺序所决定的。
Netty-Netty组件了解_第5张图片

ChannelHandler 的生命周期

        在 ChannelHandler 被添加到 ChannelPipeline 中或者被从 ChannelPipeline 中移除时会调
用下面这些方法。这些方法中的每一个都接受一个 ChannelHandlerContext 参数。
handlerAdded 当把 ChannelHandler 添加到 ChannelPipeline 中时被调用
handlerRemoved 当从 ChannelPipeline 中移除 ChannelHandler 时被调用
exceptionCaught 当处理过程中在 ChannelPipeline 中有错误产生时被调用

ChannelPipeline 中的 ChannelHandler

         入站和出站 ChannelHandler 被安装到同一个 ChannelPipeline 中，ChannelPipeline 以双
向链表的形式进行维护管理。比如下图，我们在网络上传递的数据，要求加密，但是加密后
密文比较大，需要压缩后再传输，而且按照业务要求，需要检查报文中携带的用户信息是否
合法，于是我们实现了 5 个 Handler： 解压（入）Handler、压缩（出）handler、解密（入）
Handler、加密（出） Handler、授权（入） Handler 。

Netty-Netty组件了解_第6张图片

        如果一个消息或者任何其他的入站事件被读取， 那么它会从 ChannelPipeline 的头部开
始流动，但是只被处理入站事件的 Handler 处理，也就是解压（入）Handler、解密（入）Handler、 授权（入） Handler，最终，数据将会到达 ChannelPipeline 的尾端，届时，所有处理就都结束了。
Netty-Netty组件了解_第7张图片
        数据的出站运动（即正在被写的数据）在概念上也是一样的。在这种情况下， 数据将从
链的尾端开始流动，但是只被处理出站事件的 Handler 处理，也就是加密（出） Handler、
压缩（出）handler，直到它到达链的头部为止。 在这之后，出站数据将会到达网络传输层，
也就是我们的 Socket 。
Netty-Netty组件了解_第8张图片
        Netty 能区分入站事件的 Handler 和出站事件的 Handler ，并确保数据只会在具有相同定
向类型的两个 ChannelHandler 之间传递。

Netty-Netty组件了解_第9张图片

Netty-Netty组件了解_第10张图片

        所以在我们编写 Netty 应用程序时要注意，分属出站和入站不同的 Handler ， 在业务没
特殊要求的情况下 是无所谓顺序的，正如我们下面的图所示 ， 比如‘压缩（出）handler‘可
以放在‘解压（入）handler‘和‘解密（入） Handler‘中间，也可以放在‘解密（入） Handler
‘和‘授权（入） Handler‘之间。
        而同属一个方向的 Handler 则是有顺序的，因为上一个 Handler 处理的结果往往是下一
个 Handler 的要求的输入。比如入站处理，对于收到的数据，只有先解压才能得到密文，才
能解密，只有解密后才能拿到明文中的用户信息进行授权检查，所以解压 -> 解密 -> 授权这个
三个入站 Handler 的顺序就不能乱。
Netty-Netty组件了解_第11张图片

ChannelPipeline 上的方法

        既然 ChannelPipeline 以双向链表的形式进行维护管理 Handler ，自然也提供了对应的方
法在 ChannelPipeline 中增加或者删除、替换 Handler 。
        addFirst、 addBefore 、 addAfter 、 addLast
        将一个 ChannelHandler 添加到 ChannelPipeline 中
        remove 将一个 ChannelHandler 从 ChannelPipeline 中移除
        replace 将 ChannelPipeline 中的一个 ChannelHandler 替换为另一个 ChannelHandler
        get 通过类型或者名称返回 ChannelHandler
        context 返回和 ChannelHandler 绑定的 ChannelHandlerContext
        names 返回 ChannelPipeline 中所有 ChannelHandler 的名称
        ChannelPipeline 的 API 公开了用于调用入站和出站操作的附加方法。

ChannelHandlerContext

        ChannelHandlerContext 代表了 ChannelHandler 和 ChannelPipeline 之间的关联，每当有
ChannelHandler 添加到 ChannelPipeline 中时，都会创建 ChannelHandlerContext ，为什么需
要这个 ChannelHandlerContext ？前面我们已经说过， ChannelPipeline 以双向链表的形式进
行维护管理 Handler ，毫无疑问， Handler 在放入 ChannelPipeline 的时候必须要有两个指针
pre 和 next 来说明它的前一个元素和后一个元素，但是 Handler 本身来维护这两个指针合适
吗？想想我们在使用 JDK 的 LinkedList 的时候，我们放入 LinkedList 的数据是不会带这两个指
针的， LinkedList 内部会用类 Node 对我们的数据进行包装，而类 Node 则带有两个指针 pre
和 next 。
        所以，ChannelHandlerContext 的主要作用就和 LinkedList 内部的类 Node 类似。
不过 ChannelHandlerContext 不仅仅只是个包装类，它还提供了很多的方法，比如让事
件从当前 ChannelHandler 传递给链中的下一个 ChannelHandler ，还可以被用于获取底层的
Channel ，还可以用于写出站数据。

Channel、ChannelPipeline 和 ChannelHandlerContext 上的事件传播

        ChannelHandlerContext 有很多的方法，其中一些方法也存在于 Channel 和
Channel-Pipeline 本身上， 但是有一点重要的不同。 如果调用 Channel 或者 ChannelPipeline 上
的这些方法，它们将沿着整个 ChannelPipeline 进行传播。而调用位于 ChannelHandlerContext
上的相同方法，则将从当前所关联的 ChannelHandler 开始，并且只会传播给位于该
ChannelPipeline 中的下一个（入站下一个，出站上一个）能够处理该事件的 ChannelHandler 。

Netty-Netty组件了解_第12张图片

        我们用一个实际例子来说明，比如服务器收到对端发过来的报文，解压后需要进行解密，
结果解密失败，要给对端一个应答。
        如果发现解密失败原因是服务器和对端的加密算法不一致，应答报文只能以明文的压缩
格式发送，就可以在解密 handler 中直接使用 ctx.write 给对端应答，这样应答报文就只经过
压缩 Handler 就发往了对端；
        其他情况下，应答报文要以加密和压缩格式发送，就可以在解密 handler 中使用
channel.write() 或者 channelpipeline.write() 给对端应答，这样应答报文就会流经整个出站处理
过程。
Netty-Netty组件了解_第13张图片

ChannelHandlerContext 的 API

alloc 返回和这个实例相关联的 Channel 所配置的 ByteBufAllocator
bind 绑定到给定的 SocketAddress ，并返回 ChannelFuture
channel 返回绑定到这个实例的 Channel
close 关闭 Channel ，并返回 ChannelFuture
connect 连接给定的 SocketAddress ，并返回 ChannelFuture
deregister 从之前分配的 EventExecutor 注销，并返回 ChannelFuture
disconnect 从远程节点断开，并返回 ChannelFuture
executor 返回调度事件的 EventExecutor
fireChannelActive 触发对下一个 ChannelInboundHandler 上的 channelActive() 方法（已
连接）的调用
fireChannelInactive 触发对下一个 ChannelInboundHandler 上的 channelInactive() 方法
（已关闭）的调用
fireChannelRead 触发对下一个 ChannelInboundHandler 上的 channelRead() 方法（已接
收的消息）的调用
fireChannelReadComplete 触发对下一个 ChannelInboundHandler 上的
channelReadComplete() 方法的调用
fireChannelRegistered 触发对下一个 ChannelInboundHandler 上的
fireChannelRegistered() 方法的调用
fireChannelUnregistered 触发对下一个 ChannelInboundHandler 上的
fireChannelUnregistered() 方法的调用
fireChannelWritabilityChanged 触发对下一个 ChannelInboundHandler 上的
fireChannelWritabilityChanged() 方法的调用
fireExceptionCaught 触发对下一个 ChannelInboundHandler 上的
fireExceptionCaught(Throwable) 方法的调用
fireUserEventTriggered 触发对下一个 ChannelInboundHandler 上的
fireUserEventTriggered(Object evt) 方法的调用
handler 返回绑定到这个实例的 ChannelHandler
isRemoved 如果所关联的 ChannelHandler 已经被从 ChannelPipeline 中移除则返回 true
name 返回这个实例的唯一名称
pipeline 返回这个实例所关联的 ChannelPipeline
read 将数据从 Channel 读取到第一个入站缓冲区；如果读取成功则触发一个
channelRead 事件，并（在最后一个消息被读取完成后）通知 ChannelInboundHandler 的
channelReadComplete(ctx) 方法
write 通过这个实例写入消息并经过 ChannelPipeline
writeAndFlush 通过这个实例写入并冲刷消息并经过 ChannelPipeline
当使用 ChannelHandlerContext 的 API 的时候，有以下两点：
⚫ ChannelHandlerContext 和 ChannelHandler 之间的关联（绑定）是永远不会改变的，
所以缓存对它的引用是安全的；
⚫ 相对于其他类的同名方法，ChannelHandlerContext 的方法将产生更短的事件流，应该尽可能地利用这个特性来获得最大的性能。

 ChannelHandler

ChannelHandler 接口

        从应用程序开发人员的角度来看，Netty 的主要组件是 ChannelHandler ，它充当了所有
处理入站和出站数据的应用程序逻辑的容器。 ChannelHandler 的方法是由网络事件触发的。
事实上， ChannelHandler 可专门用于几乎任何类型的动作，例如将数据从一种格式转换为另
外一种格式，例如各种编解码，或者处理转换过程中所抛出的异常。
        举例来说，ChannelInboundHandler 是一个你将会经常实现的子接口。这种类型的
ChannelHandler 接收入站事件和数据，这些数据随后将会被你的应用程序的业务逻辑所处理。
当你要给连接的客户端发送响应时，也可以从 ChannelInboundHandler 直接冲刷数据然后输
出到对端。应用程序的业务逻辑通常实现在一个或者多个 ChannelInboundHandler 中。
        这种类型的 ChannelHandler 接收入站事件和数据，这些数据随后将会被应用程序的业
务逻辑所处理。
        Netty 定义了下面两个重要的 ChannelHandler 子接口：
                ChannelInboundHandler——处理入站数据以及各种状态变化；
                ChannelOutboundHandler——处理出站数据并且允许拦截所有的操作。

ChannelInboundHandler 接口

        下面列出了接口 ChannelInboundHandler 的生命周期方法。这些方法将会在数据被接收
时或者与其对应的 Channel 状态发生改变时被调用。正如我们前面所提到的，这些方法和
Channel 的生命周期密切相关。
        channelRegistered 当 Channel 已经注册到它的 EventLoop 并且能够处理 I/O 时被调用
        channelUnregistered 当 Channel 从它的 EventLoop 注销并且无法处理任何 I/O 时被调
用
        channelActive 当 Channel 处于活动状态时被调用； Channel 已经连接 / 绑定并且已经就
绪
        channelInactive 当 Channel 离开活动状态并且不再连接它的远程节点时被调用
        channelReadComplete 当 Channel 上的一个读操作完成时被调用
        channelRead 当从 Channel 读取数据时被调用
        ChannelWritabilityChanged
        当 Channel 的可写状态发生改变时被调用。可以通过调用 Channel 的 isWritable() 方法
来检测 Channel 的可写性。与可写性相关的阈值可以通过
Channel.config().setWriteHighWaterMark() 和 Channel.config().setWriteLowWaterMark() 方法来
设置
        userEventTriggered 当 ChannelnboundHandler.fireUserEventTriggered() 方法被调用时被
调用。
注意： channelReadComplete 和 channelRead 这两个方法非常让人搞不清两者的区别是
什么，我们先放下这个疑问，后面会有解释。

ChannelOutboundHandler 接口

        出站操作和数据将由 ChannelOutboundHandler 处理。它的方法将被 Channel 、 Channel
        Pipeline 以及 ChannelHandlerContext 调用。
        所有由 ChannelOutboundHandler 本身所定义的方法：
        bind(ChannelHandlerContext,SocketAddress,ChannelPromise)
        当请求将 Channel 绑定到本地地址时被调用
        connect(ChannelHandlerContext,SocketAddress,SocketAddress,ChannelPromise)
        当请求将 Channel 连接到远程节点时被调用
        disconnect(ChannelHandlerContext,ChannelPromise)
        当请求将 Channel 从远程节点断开时被调用
        close(ChannelHandlerContext,ChannelPromise) 当请求关闭 Channel 时被调用
        deregister(ChannelHandlerContext,ChannelPromise)
        当请求将 Channel 从它的 EventLoop 注销时被调用
        read(ChannelHandlerContext) 当请求从 Channel 读取更多的数据时被调用
        flush(ChannelHandlerContext) 当请求通过 Channel 将入队数据冲刷到远程节点时被调
用
        write(ChannelHandlerContext,Object,ChannelPromise) 当请求通过 Channel 将数据写到
远程节点时被调用

ChannelHandler 的适配器

        有一些适配器类可以将编写自定义的 ChannelHandler 所需要的工作降到最低限度，因
为它们提供了定义在对应接口中的所有方法的默认实现。因为你有时会忽略那些不感兴趣的
事件，所以 Netty 提供了抽象基类 ChannelInboundHandlerAdapter （处理入站） 和
ChannelOutboundHandlerAdapter （处理出站）。
        我们可以使用 ChannelInboundHandlerAdapter 和 ChannelOutboundHandlerAdapter 类作
为自己的 ChannelHandler 的起始点。这两个适配器分别提供了 ChannelInboundHandler 和
ChannelOutboundHandler 的基本实现。通过扩展抽象类 ChannelHandlerAdapter ，它们获得
了它们共同的超接口 ChannelHandler 的方法。
Netty-Netty组件了解_第14张图片
        不过 ChannelOutboundHandler 有个非常让人迷惑的 read 方法， ChannelOutboundHandler
不是处理出站事件的吗？怎么会有 read 方法呢？其实这个 read 方法不是表示读数据，而是
表示业务发出了读（ read ）数据的要求，这个要求也会封装为一个事件进行传播，这个事件
因为是业务发出到网络的，自然就是个出站事件，而且这个事件触发的就是
ChannelOutboundHandler 中 read 方法。
        如果我们的 Handler 既要处理入站又要处理出站怎么办呢？这个时候就可以使用类
ChannelDuplexHandler ，当然也可以同时实现 ChannelOutboundHandler,
ChannelInboundHandler 这两个接口，自然就要麻烦很多了。

Handler 的共享和并发安全性

        ChannelHandlerAdapter 还提供了实用方法 isSharable() 。如果其对应的实现被标注为
Sharable ，那么这个方法将返回 true ，表示它可以被添加到多个 ChannelPipeline 。
        这就牵涉到了我们实现的 Handler 的共享性和线程安全性。回顾我们的 Netty 代码，在
往 pipeline 安装 Handler 的时候，我们基本上是 new 出 Handler 的实例
Netty-Netty组件了解_第15张图片
        因为每个 socketChannel 有自己的 pipeline 而且每个 socketChannel 又是和线程绑定的，
所以这些 Handler 的实例之间完全独立的，只要 Handler 的实例之间不是共享了全局变量，
Handler 的实例是线程安全的。
        但是如果业务需要我们在多个 socketChannel 之间共享一个 Handler 的实例怎么办呢？
比如统计服务器接受到和发出的业务报文总数，我们就需要用一个 Handler 的实例来横跨所
有的 socketChannel 来统计所有 socketChannel 业务报文数。
        为了实现这一点，我们可以实现一个 MessageCountHandler ，并且在
MessageCountHandler 上使用 Netty 的 @Sharable 注解，然后在安装 MessageCountHandler 实
例到 pipeline 时，共用一个即可。当然，因为 MessageCountHandler 实例是共享的，所以在
实现 MessageCountHandler 的统计功能时，请务必注意线程安全，我们在具体实现时就使用
了 Java 并发编程里的 Atomic 类来保证这一点。
        具体代码请参考包 cn.tuling.nettybasic.sharehndler 。

资源管理和 SimpleChannelInboundHandler

        回想一下我们在 NIO 中是如何接收和发送网络数据的？都是首先创建了一个 Buffer ，应
用程序中的业务部分和 Channel 之间通过 Buffer 进行数据的交换：
Netty-Netty组件了解_第16张图片
        Netty 在处理网络数据时，同样也需要 Buffer ，在 Read 网络数据时由 Netty 创建 Buffer ，
Write 网络数据时 Buffer 往往是由业务方创建的。不管是读和写， Buffer 用完后都必须进行
释放，否则可能会造成内存泄露。
        在 Write 网络数据时，可以确保数据被写往网络了， Netty 会自动进行 Buffer 的释放，
但是如果 Write 网络数据时，我们有 outBoundHandler 处理了 write() 操作并丢弃了数据，没
有继续往下写，要由我们负责释放这个 Buffer ，就必须调用 ReferenceCountUtil.release 方法，
否则就可能会造成内存泄露。
        在 Read 网络数据时，如果我们可以确保每个 InboundHandler 都把数据往后传递了，也
就是调用了相关的 fireChannelRead 方法， Netty 也会帮我们释放，同样的，如果我们有
InboundHandler 处理了数据，又不继续往后传递，又不调用负责释放的 ReferenceCountUtil.release 方法，就可能会造成内存泄露。
        但是由于消费入站数据是一项常规任务，所以 Netty 提供了一个特殊的被 称为 SimpleChannelInboundHandler 的 ChannelInboundHandler 实现。这个实现会在数
据被 channelRead0() 方法消费之后自动释放数据。
Netty-Netty组件了解_第17张图片
        同时系统为我们提供的各种预定义 Handler 实现，都实现了数据的正确处理，所以我们
自行在编写业务 Handler 时，也需要注意这一点： 要么继续传递，要么自行释放 。

内置通信传输模式

        NIO io.netty.channel.socket.nio 使用 java.nio.channels 包作为基础 —— 基于选择器的方
式
        Epoll io.netty.channel.epoll 由 JNI 驱动的 epoll() 和非阻塞 IO 。这个传输支持只有在
Linux 上可用的多种特性，如 SO_REUSEPORT ，比 NIO 传输更快，而且是完全非阻塞的。将
NioEventLoopGroup 替换为 EpollEventLoopGroup ， 并且将 NioServerSocketChannel.class 替
换为 EpollServerSocketChannel.class 即可。
        
        OIO io.netty.channel.socket.oio 使用 java.net 包作为基础 —— 使用阻塞流
        Local io.netty.channel.local 可以在 VM 内部通过管道进行通信的本地传输
        Embedded io.netty.channel.embedded Embedded 传输，允许使用 ChannelHandler 而又
不需要一个真正的基于网络的传输。在测试 ChannelHandler 实现时非常有用
        

引导 Bootstrap

        网络编程里，“服务器”和“客户端”实际上表示了不同的网络行为；换句话说，是监
听传入的连接还是建立到一个或者多个进程的连接。
        因此，有两种类型的引导： 一种用于客户端（简单地称为 Bootstrap），而另一种
（ServerBootstrap）用于服务器。 无论你的应用程序使用哪种协议或者处理哪种类型的数据，
唯一决定它使用哪种引导类的是它是作为一个客户端还是作为一个服务器。
        比较 Bootstrap 类
Netty-Netty组件了解_第18张图片
         ServerBootstrap 将绑定到一个端口，因为服务器必须要监听连接，而 Bootstrap 则是由
想要连接到远程节点的客户端应用程序所使用的。
        第二个区别可能更加明显 。引导一个客户端只需要一个 EventLoopGroup，但是一个
ServerBootstrap 则需要两个（也可以是同一个实例）。
         因为服务器需要两组不同的 Channel。第一组将只包含一个 ServerChannel，代表服务器
自身的已绑定到某个本地端口的正在监听的套接字。而第二组将包含所有已创建的用来处理
传入客户端连接（对于每个服务器已经接受的连接都有一个）的 Channel。
Netty-Netty组件了解_第19张图片
        与 ServerChannel 相关联的 EventLoopGroup 将分配一个负责为传入连接请求创建
Channel 的 EventLoop 。一旦连接被接受，第二个 EventLoopGroup 就会给它的 Channel 分配
一个 EventLoop 。

ChannelInitializer

        Netty 提供了一个特殊的 ChannelInboundHandlerAdapter 子类： public abstract class ChannelInitializer extends ChannelInboundHandlerAdapter
        它定义了下面的方法：
         protect ed abstract void initChannel(C ch) throws Exception;
        这个方法提供了一种将多个 ChannelHandler 添加到一个 ChannelPipeline 中的简便方法。
你只需要简单地向 Bootstrap 或 ServerBootstrap 的实例提供你的 ChannelInitializer 实现即
可，并且一旦 Channel 被注册到了它的 EventLoop 之后，就会调用你的 initChannel()版本。
在该方法返回之后，ChannelInitializer 的实例将会从 ChannelPipeline 中移除它自己。
        所以，在我们自己的应用程序中，如果存在着某个 handler 只使用一次的情况，也可以
仿造 ChannelInitializer ，用完以后将自己从 ChannelPipeline 中移除自己，比如授权 handler ，
某客户端第一次连接登录以后，进行授权检查，检查通过后就可以把这个授权 handler 移除
了。如果客户端关闭连接下线，下次再连接的时候，就是一个新的连接，授权 handler 依然
会被安装到 ChannelPipeline ，依然会进行授权检查。

ChannelOption

ChannelOption 的各种属性在套接字选项中都有对应。

ChannelOption.SO_BACKLOG

        ChannelOption.SO_BACKLOG 对应的是 tcp/ip 协议 listen 函数中的 backlog 参数，服务端
处理客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接，多个客户端来
的时候，服务端将不能处理的客户端连接请求放在队列中等待处理。所以操作系统里一般有
两个队列，一个是 ACCEPT 队列，保存着已经完成了 TCP 的三次握手的连接，一个 SYN 队列，
服务器正在等待 TCP 的三次握手完成的队列。
        BSD派生系统里 backlog 指的就是 SYN 队列的大小，在 Linux 的实现里 backlog 相对来说，
就含糊不清了，有些内核版本指的是 ACCEPT 队列 +SYN 队列合起来的大小，有的是指 SYN
队列的大小。
        但是从 Linux 2.2 开始， backlog 的参数行为在 Linux 2.2 中发生了变化，现在它指定等
待接受的完全建立的套接字的队列长度，而不是不完整的连接请求的数量。 不完整套接字
队列的最大长度可以使用 /proc/sys/net/ipv4/tcp_max_syn_backlog 设置，默认值为 128 。
        如果 backlog 参数大于 /proc/sys/net/core/somaxconn 中的值，那么它会被静默截断为
值 128 。在 2.4.25 之前的内核中，此限制是硬编码值，后续内核版本也可以通过 vim
/etc/sysctl.conf 来修改，包括我们前面所说的 tcp_max_syn_backlog 也可以在此处修改，然后
通过命令 sysctl -p 生效。
Netty-Netty组件了解_第20张图片

ChannelOption.SO_REUSEADDR

        ChanneOption.SO_REUSEADDR 对应于套接字选项中的 SO_REUSEADDR ，这个参数表示允许重复使用本地地址和端口，
        比如，多网卡（IP ）绑定相同端口，比如某个进程非正常退出，该程序占用的端口可能
要被占用一段时间才能允许其他进程使用，而且程序死掉以后，内核一需要一定的时间才能
够释放此端口，不设置 SO_REUSEADDR 就无法正常使用该端口。
但是注意，这个参数无法做到让应用绑定完全相同 IP + Port 来重复启动。

ChannelOption.SO_KEEPALIVE

        Channeloption.SO_KEEPALIVE 参数对应于套接字选项中的 SO_KEEPALIVE ，该参数用于设 置 TCP 连接，当设置该选项以后，连接会测试链接的状态，这个选项用于可能长时间没有数
据交流的连接。当设置该选项以后，如果在两小时内没有数据的通信时， TCP 会自动发送一
个活动探测数据报文。

ChannelOption.SO_SNDBUF 和 ChannelOption.SO_RCVBUF

        ChannelOption.SO_SNDBUF 参数对应于套接字选项中的 SO_SNDBUF ，
ChannelOption.SO_RCVBUF 参数对应于套接字选项中的 SO_RCVBUF 这两个参数用于操作接
收缓冲区和发送缓冲区的大小，接收缓冲区用于保存网络协议站内收到的数据，直到应用程
序读取成功，发送缓冲区用于保存发送数据，直到发送成功。

ChannelOption.SO_LINGER

        ChannelOption.SO_LINGER 参数对应于套接字选项中的 SO_LINGER,Linux 内核默认的处理
方式是当用户调用 close （）方法的时候，函数返回，在可能的情况下，尽量发送数据，不
一定保证会发生剩余的数据，造成了数据的不确定性，使用 SO_LINGER 可以阻塞 close() 的调
用时间，直到数据完全发送

ChannelOption.TCP_NODELAY

        ChannelOption.TCP_NODELAY 参数对应于套接字选项中的 TCP_NODELAY, 该参数的使用
与 Nagle 算法有关， Nagle 算法是将小的数据包组装为更大的帧然后进行发送，而不是输入
一次发送一次 , 因此在数据包不足的时候会等待其他数据的到了，组装成大的数据包进行发
送，虽然该方式有效提高网络的有效负载，但是却造成了延时，而该参数的作用就是禁止使
用 Nagle 算法，使用于小数据即时传输，于 TCP_NODELAY 相对应的是 TCP_CORK ，该选项是
需要等到发送的数据量最大的时候，一次性发送数据，适用于文件传输。

ByteBuf

ByteBuf API 的优点：
         它可以被用户自定义的缓冲区类型扩展；
        通过内置的复合缓冲区类型实现了透明的零拷贝；
        容量可以按需增长（类似于 JDK 的 StringBuilder）；
        在读和写这两种模式之间切换不需要调用 ByteBuffer 的 flip()方法；
        读和写使用了不同的索引；
        支持方法的链式调用；
        支持引用计数；
        支持池化。
        ByteBuf 维护了两个不同的索引，名称以 read 或者 write 开头的 ByteBuf 方法，将会
推进其对应的索引，而名称以 set 或者 get 开头的操作则不会。
        如果打算读取字节直到 readerIndex 达到和 writerIndex 同样的值时会发生什么。在那
时，你将会到达“可以读取的”数据的末尾。就如同试图读取超出数组末尾的数据一样，试
图读取超出该点的数据将会触发一个 IndexOutOf-BoundsException 。
        可以指定 ByteBuf 的最大容量。试图移动写索引（即 writerIndex ）超过这个值将会触发
一个异常。（默认的限制是 Integer.MAX_VALUE 。）

使用模式

堆缓冲区
         最常用的 ByteBuf 模式是将数据存储在 JVM 的堆空间中。这种模式被称为支撑数组
（backing array），它能在没有使用池化的情况下提供快速的分配和释放。可以由 hasArray()
来判断检查 ByteBuf 是否由数组支撑。如果不是，则这是一个直接缓冲区。
直接缓冲区
         直接缓冲区是另外一种 ByteBuf 模式。
        直接缓冲区的主要缺点是，相对于基于堆的缓冲区，它们的分配和释放都较为昂贵。
复合缓冲区
         复合缓冲区 CompositeByteBuf，它为多个 ByteBuf 提供一个聚合视图。比如 HTTP 协议，
分为消息头和消息体，这两部分可能由应用程序的不同模块产生，各有各的 ByteBuf，将会
在消息被发送的时候组装为一个 ByteBuf，此时可以将这两个 ByteBuf 聚合为一个
CompositeByteBuf，然后使用统一和通用的 ByteBuf API 来操作。

分配

        如何在我们的程序中获得 ByteBuf 的实例，并使用它呢？ Netty 提供了两种方式
ByteBufAllocator 接口
        Netty 通过 interface ByteBufAllocator 分配我们所描述过的任意类型的 ByteBuf 实例。
Netty-Netty组件了解_第21张图片

 

        可以通过 Channel （每个都可以有一个不同的 ByteBufAllocator 实例）或者绑定到
ChannelHandler 的 ChannelHandlerContext 获取一个到 ByteBufAllocator 的引用。
        Netty 提供了两种 ByteBufAllocator 的实现： PooledByteBufAllocator 和
Unpooled-ByteBufAllocator 。前者池化了 ByteBuf 的实例以提高性能并最大限度地减少内存碎
片。后者的实现不池化 ByteBuf 实例，并且在每次它被调用时都会返回一个新的实例。
        Netty4.1 默认使用了 PooledByteBufAllocator 。
Unpooled 缓冲区
        Netty 提供了一个简单的称为 Unpooled 的工具类，它提供了静态的辅助方法来创建未池化的 ByteBuf 实例。
        buffer() 返回一个未池化的基于堆内存存储的 ByteBuf
        directBuffer()返回一个未池化的基于直接内存存储的 ByteBuf
        wrappedBuffer() 返回一个包装了给定数据的 ByteBuf
        copiedBuffer() 返回一个复制了给定数据的 ByteBuf
        Unpooled 类还可用于 ByteBuf 同样可用于那些并不需要 Netty 的其他组件的非网络项
目。
随机访问索引 / 顺序访问索引 / 读写操作
        如同在普通的 Java 字节数组中一样， ByteBuf 的索引是从零开始的：第一个字节的索
引是 0 ，最后一个字节的索引总是 capacity() - 1 。使用那些需要一个索引值参数 ( 随机访问 ,
也即是数组下标 ) 的方法（的其中）之一来访问数据既不会改变 readerIndex 也不会改变
writerIndex 。如果有需要，也可以通过调用 readerIndex(index) 或者 writerIndex(index) 来手动
移动这两者。 顺序访问 通过索引访问
         有两种类别的读/写操作：
                 get()和 set()操作，从给定的索引开始，并且保持索引不变；get+数据字长
（bool.byte,int,short,long,bytes）
                read()和 write()操作，从给定的索引开始，并且会根据已经访问过的字节数对索引
进行调整。 ​​​​​​​
更多的操作
        isReadable() 如果至少有一个字节可供读取，则返回 true
        isWritable() 如果至少有一个字节可被写入，则返回 true
        readableBytes() 返回可被读取的字节数
        writableBytes() 返回可被写入的字节数
        capacity() 返回 ByteBuf 可容纳的字节数。在此之后，它会尝试再次扩展直到达到
        maxCapacity()
        maxCapacity() 返回 ByteBuf 可以容纳的最大字节数
        hasArray() 如果 ByteBuf 由一个字节数组支撑，则返回 true
        array() 如果 ByteBuf 由一个字节数组支撑则返回该数组；否则，它将抛出一个
UnsupportedOperationException 异常
可丢弃字节
         可丢弃字节的分段包含了已经被读过的字节。通过调用 discardReadBytes()方法，可以丢
弃它们并回收空间。这个分段的初始大小为 0，存储在 readerIndex 中，会随着 read 操作的
执行而增加（get*操作不会移动 readerIndex）。
        缓冲区上调用 discardReadBytes()方法后，可丢弃字节分段中的空间已经变为可写的了。
频繁地调用 discardReadBytes()方法以确保可写分段的最大化，但是请注意，这将极有可能会
导致内存复制，因为可读字节必须被移动到缓冲区的开始位置。建议只在有真正需要的时候
才这样做，例如，当内存非常宝贵的时候。
Netty-Netty组件了解_第22张图片
可读字节
        ByteBuf 的可读字节分段存储了实际数据。新分配的、包装的或者复制的缓冲区的默认
的 readerIndex 值为 0 。
可写字节
        可写字节分段是指一个拥有未定义内容的、写入就绪的内存区域。新分配的缓冲区的
writerIndex 的默认值为 0 。任何名称以 write 开头的操作都将从当前的 writerIndex 处开始
写数据，并将它增加已经写入的字节数。
Netty-Netty组件了解_第23张图片

索引管理

        调用 markReaderIndex() 、 markWriterIndex() 、 resetWriterIndex() 和 resetReaderIndex() 来
标记和重置 ByteBuf 的 readerIndex 和 writerIndex 。
        也可以通过调用 readerIndex(int) 或者 writerIndex(int) 来将索引移动到指定位置。试图将
任何一个索引设置到一个无效的位置都将导致一个 IndexOutOfBoundsException 。
        可以通过调用 clear() 方法来将 readerIndex 和 writerIndex 都设置为 0 。注意，这并不会
清除内存中的内容
​​​​​​​

查找操作

        在 ByteBuf 中有多种可以用来确定指定值的索引的方法。最简单的是使用 indexOf() 方法。
        较复杂的查找可以通过调用 forEachByte() 。
下面的代码展示了一个查找回车符（\r）的例子。
ByteBuf buffer = .. .;
int index = buffer.forEachByte(ByteBufProcessor.FIND_CR);

派生缓冲区

        派生缓冲区为 ByteBuf 提供了以专门的方式来呈现其内容的视图。这类视图是通过以下
方法被创建的：
        duplicate()； slice() ； slice(int, int) ； Unpooled.unmodifiableBuffer(…) ；
order(ByteOrder) ； readSlice(int) 。
        每个这些方法都将返回一个新的 ByteBuf 实例，它具有自己的读索引、写索引和标记索
引。其内部存储和 JDK 的 ByteBuffer 一样也是共享的。
        ByteBuf 复制 如果需要一个现有缓冲区的真实副本，请使用 copy() 或者 copy(int, int) 方
法。不同于派生缓冲区，由这个调用所返回的 ByteBuf 拥有独立的数据副本。
引用计数
        引用计数是一种通过在某个对象所持有的资源不再被其他对象引用时释放该对象所持
有的资源来优化内存使用和性能的技术。 Netty 在第 4 版中为 ByteBuf 引入了引用计数技术，
interface ReferenceCounted 。

工具类

        ByteBufUtil 提供了用于操作 ByteBuf 的静态的辅助方法。因为这个 API 是通用的，并
且和池化无关，所以这些方法已然在分配类的外部实现。
        这些静态方法中最有价值的可能就是 hexdump() 方法，它以十六进制的表示形式打印
ByteBuf 的内容。这在各种情况下都很有用，例如，出于调试的目的记录 ByteBuf 的内容。
十六进制的表示通常会提供一个比字节值的直接表示形式更加有用的日志条目，此外，十六
进制的版本还可以很容易地转换回实际的字节表示。
        另一个有用的方法是 boolean equals(ByteBuf, ByteBuf) ，它被用来判断两个 ByteBuf 实例
的相等性。

资源释放

        当某个 ChannelInboundHandler 的实现重写 channelRead() 方法时，它要负责显式地释放
与池化的 ByteBuf 实例相关的内存。 Netty 为此提供了一个实用方法
ReferenceCountUtil.release()
        Netty 将使用 WARN 级别的日志消息记录未释放的资源，使得可以非常简单地在代码
中发现违规的实例。但是以这种方式管理资源可能很繁琐。一个更加简单的方式是使用
SimpleChannelInboundHandler ， SimpleChannelInboundHandler 会自动释放资源。
        1、对于入站请求， Netty 的 EventLoo 在处理 Channel 的读操作时进行分配 ByteBuf ，对
于这类 ByteBuf ，需要我们自行进行释放，有三种方式：
         或者使用 SimpleChannelInboundHandler；
        或者在重写 channelRead()方法使用 ReferenceCountUtil.release()
        或者在重写 channelRead()方法使用使用 ctx.fireChannelRead 继续向后传递；
        2、对于出站请求，不管 ByteBuf 是否由我们的业务创建的，当调用了 write 或者
writeAndFlush 方法后， Netty 会自动替我们释放，不需要我们业务代码自行释放。

解决粘包/半包

回顾我们的的 Hello,Netty
参见 cn.tuling.nettybasic.splicing.demo 下的代码

什么是 TCP 粘包半包？

Netty-Netty组件了解_第24张图片

 

假设客户端分别发送了两个数据包 D1 和 D2 给服务端，由于服务端一次读取到的字节
数是不确定的，故可能存在以下 4 种情况。
（1）服务端分两次读取到了两个独立的数据包，分别是 D1 和 D2，没有粘包和拆包；
（2）服务端一次接收到了两个数据包，D1 和 D2 粘合在一起，被称为 TCP 粘包；
（3）服务端分两次读取到了两个数据包，第一次读取到了完整的 D1 包和 D2 包的部分
内容，第二次读取到了 D2 包的剩余内容，这被称为 TCP 拆包；
（4）服务端分两次读取到了两个数据包，第一次读取到了 D1 包的部分内容 D1_1，第
二次读取到了 D1 包的剩余内容 D1_2 和 D2 包的整包。
如果此时服务端 TCP 接收滑窗非常小，而数据包 D1 和 D2 比较大，很有可能会发生第
五种可能，即服务端分多次才能将 D1 和 D2 包接收完全，期间发生多次拆包 。

TCP 粘包/半包发生的原因

        由于 TCP 协议本身的机制（面向连接的可靠地协议 - 三次握手机制）客户端与服务器会
维持一个连接（ Channel ），数据在连接不断开的情况下，可以持续不断地将多个数据包发 往服务器，但是如果发送的网络数据包太小，那么他本身会启用 Nagle 算法（可配置是否启
用）对较小的数据包进行合并（基于此， TCP 的网络延迟要 UDP 的高些）然后再发送（超
时或者包大小足够）。那么这样的话，服务器在接收到消息（数据流）的时候就无法区分哪
些数据包是客户端自己分开发送的，这样产生了粘包；服务器在接收到数据库后，放到缓冲
区中，如果消息没有被及时从缓存区取走，下次在取数据的时候可能就会出现一次取出多个
数据包的情况，造成粘包现象
        UDP：本身作为无连接的不可靠的传输协议（适合频繁发送较小的数据包），他不会对
数据包进行合并发送（也就没有 Nagle 算法之说了），他直接是一端发送什么数据，直接就
发出去了，既然他不会对数据合并，每一个数据包都是完整的（数据 +UDP 头 +IP 头等等发一
次数据封装一次）也就没有粘包一说了。
        分包产生的原因就简单的多：就是一个数据包被分成了多次接收。
        更具体的原因至少包括：
                1. 应用程序写入数据的字节大小大于套接字发送缓冲区的大小
                2. 进行 MSS 大小的 TCP 分段。 MSS 是最大报文段长度的缩写。 MSS 是 TCP 报文段中的数据字段的最大长度。数据字段加上 TCP 首部才等于整个的 TCP 报文段。所以 MSS 并不是
TCP 报文段的最大长度，而是： MSS=TCP 报文段长度 -TCP 首部长度。

解决粘包半包

由于底层的 TCP 无法理解上层的业务数据，所以在底层是无法保证数据包不被拆分和重
组的，这个问题只能通过上层的应用协议栈设计来解决，根据业界的主流协议的解决方案，
可以归纳如下。
（1） 在包尾增加分割符，比如回车换行符进行分割，例如 FTP 协议；
参见 cn.tuling.nettybasic.splicing.linebase（回车换行符进行分割）和
cn.tuling.nettybasic.splicing.delimiter（自定义分割符）下的代码
（2）消息定长，例如每个报文的大小为固定长度 200 字节，如果不够，空位补空格；
参见 cn.tuling.nettybasic.splicing.fixed 下的代码
（3）将消息分为消息头和消息体，消息头中包含表示消息总长度（或者消息体长度）
的字段，通常设计思路为消息头的第一个字段使用 int32 来表示消息的总长度，使用
LengthFieldBasedFrameDecoder，后面会有详细说明和使用。
​​​​​​​
辨析 channelRead 和 channelReadComplete
两者的区别：
         Netty 是在读到完整的业务请求报文后才调用一次业务 ChannelHandler 的 channelRead
方法，无论这条报文底层经过了几次 SocketChannel 的 read 调用。
        但是 channelReadComplete 方法并不是在业务语义上的读取消息完成后被触发的，而是
在每次从 SocketChannel 成功读到消息后，由系统触发，也就是说如果一个业务消息被 TCP
协议栈发送了 N 次，则服务端的 channelReadComplete 方法就会被调用 N 次。
        我们用代码来看看 cn.tuling.nettybasic.checkread ：
        ​​​​​​​我们在客户端发送 5 次较小报文
Netty-Netty组件了解_第25张图片

 服务端输出：

Netty-Netty组件了解_第26张图片

        很明显，channelRead 是一个报文执行一次，执行的执行次数和客户端发送报文数一样，
channelReadComplete 虽然也执行了多次，但是和客户端发送报文数没什么关系，而且也没
什么规律可寻。

编解码器框架

什么是编解码器

        每个网络应用程序都必须定义如何解析在两个节点之间来回传输的原始字节，以及如何
将其和目标应用程序的数据格式做相互转换。这种转换逻辑由编解码器处理，编解码器由编
码器和解码器组成，它们每种都可以将字节流从一种格式转换为另一种格式。那么它们的区
别是什么呢？
        如果将消息看作是对于特定的应用程序具有具体含义的结构化的字节序列—它的数据。
那么编码器是将消息转换为适合于传输的格式（最有可能的就是字节流）；而对应的解码器
则是将网络字节流转换回应用程序的消息格式。因此，编码器操作出站数据，而解码器处理
入站数据。我们前面所学的解决粘包半包的其实也是编解码器框架的一部分。

解码器

        将字节解码为消息——ByteToMessageDecoder
        将一种消息类型解码为另一种——MessageToMessageDecoder 。
因为解码器是负责将入站数据从一种格式转换到另一种格式的，所以 Netty 的解码器实现了 ChannelInboundHandler 。
         什么时候会用到解码器呢？很简单：每当需要为 ChannelPipeline 中的下一个ChannelInboundHandler 转换入站数据时会用到。此外，得益于 ChannelPipeline 的设计，可 以将多个解码器链接在一起，以实现任意复杂的转换逻辑。
        比如一个实际的业务场景，两端通信，通过 JSON 交换信息，而且 JSON 文本需要加密，
接收端就可以：
         网络加密报文 -> 经过 ByteToMessageDecoder -> String 类型的 JSON 明文；
        String 类型的 JSON 文本-> 经过 MessageToMessageDecoder -> Java 里的对象
        所以我们可以把 ByteToMessageDecoder 看成一次解码器，MessageToMessageDecoder
看成二次或者多次解码器
​​​​​​​

将字节解码为消息

抽象类 ByteToMessageDecoder
        将字节解码为消息（或者另一个字节序列）是一项如此常见的任务，Netty 为它提供了
一个抽象的基类： ByteToMessageDecoder 。由于你不可能知道远程节点是否会一次性地发送
一个完整的消息，所以这个类会对入站数据进行缓冲，直到它准备好处理。
​​​​​​​
        它最重要方法
        decode(ChannelHandlerContext ctx,ByteBuf in,List out)
        是必须实现的唯一抽象方法。decode() 方法被调用时将会传入一个包含了传入数据的
ByteBuf ，以及一个用来添加解码消息的 List 。对这个方法的调用将会重复进行，直到确定没
有新的元素被添加到该 List ，或者该 ByteBuf 中没有更多可读取的字节时为止。然后，如果
该 List 不为空，那么它的内容将会被传递给 ChannelPipeline 中的下一个 ChannelInboundHandler。

将一种消息类型解码为另一种

        在两个消息格式之间进行转换（例如，从 String->Integer ）
        decode(ChannelHandlerContext ctx,I msg,List out)
        对于每个需要被解码为另一种格式的入站消息来说，该方法都将会被调用。解码消息随
后会被传递给 ChannelPipeline 中的下一个 ChannelInboundHandler
        MessageToMessageDecoder， T 代表源数据的类型

TooLongFrameException

        由于 Netty 是一个异步框架，所以需要在字节可以解码之前在内存中缓冲它们。因此，
不能让解码器缓冲大量的数据以至于耗尽可用的内存。为了解除这个常见的顾虑， Netty 提
供了 TooLongFrameException 类，其将由解码器在帧超出指定的大小限制时抛出。
        为了避免这种情况，你可以设置一个最大字节数的阈值，如果超出该阈值，则会导致抛
出一个 TooLongFrameException （随后会被 ChannelHandler.exceptionCaught() 方法捕获）。然
后，如何处理该异常则完全取决于该解码器的用户。某些协议（如 HTTP ）可能允许你返回
一个特殊的响应。而在其他的情况下，唯一的选择可能就是关闭对应的连接。
Netty-Netty组件了解_第27张图片

 

编码器

        解码器的功能正好相反。Netty 提供了一组类，用于帮助你编写具有以下功能的编码器：
                 将消息编码为字节；MessageToByteEncoder
                将消息编码为消息：MessageToMessageEncoder，T 代表源数据的类型
        还是用我们上面的业务场景，两端通信，通过 JSON 交换信息，而且 JSON 文本需要加
密，发送端就可以：
        Java 里的对象 -> 经过 MessageToMessageEncoder -> String 类型的 JSON 文本
        String 类型的 JSON 明文 -> 经过 MessageToByteEncoder-> 网络加密报文；
        所以我们可以把 MessageToByteEncoder 看成网络报文编码器，
MessageToMessageEncoder 看成业务编码器。

将消息编码为字节

        encode(ChannelHandlerContext ctx,I msg,ByteBuf out)
        encode()方法是你需要实现的唯一抽象方法。它被调用时将会传入要被该类编码为
ByteBuf 的出站消息（类型为 I 的）。该 ByteBuf 随后将会被转发给 ChannelPipeline 中的下
一个 ChannelOutboundHandler

将消息编码为消息

        encode(ChannelHandlerContext ctx,I msg,List out)
        这是需要实现的唯一方法。每个通过 write() 方法写入的消息都将会被传递给 encode()
方法，以编码为一个或者多个出站消息。随后，这些出站消息将会被转发给 ChannelPipeline
中的下一个 ChannelOutboundHandler

编解码器类

        我们一直将解码器和编码器作为单独的实体讨论，但是有时在同一个类中管理入站和出
站数据和消息的转换是很有用的。 Netty 的抽象编解码器类正好用于这个目的，因为它们每
个都将捆绑一个解码器 / 编码器对。这些类同时实现了 ChannelInboundHandler 和
ChannelOutboundHandler 接口。
​​​​​​​        为什么我们并没有一直优先于单独的解码器和编码器使用这些复合类呢？因为通过尽
可能地将这两种功能分开，最大化了代码的可重用性和可扩展性，这是 Netty 设计的一个基
本原则。
相关的类：
         抽象类 ByteToMessageCodec
        抽象类 MessageToMessageCodec

实战 – 实现 SSL/TLS 和 Web 服务

        Netty 为许多通用协议提供了编解码器和处理器，几乎可以开箱即用，这减少了我们花
费的时间与精力。

通过 SSL/TLS 保护 Netty 应用程序

        SSL 和 TLS 这样的安全协议，它们层叠在其他协议之上，用以实现数据安全。我们在访
问安全网站时遇到过这些协议，但是它们也可用于其他不是基于 HTTP 的应用程序，如安全
SMTP （ SMTPS ）邮件服务器甚至是关系型数据库系统。
        为了支持 SSL/TLS ， Java 提供了 javax.net.ssl 包，它的 SSLContext 和 SSLEngine 类使得
实现解密和加密相当简单直接。 Netty 通过一个名为 SslHandler 的 ChannelHandler 实现利用
了这个 API ，其中 SslHandler 在内部使用 SSLEngine 来完成实际的工作。
        在大多数情况下，SslHandler 将是 ChannelPipeline 中的第一个 ChannelHandler 。

HTTP 系列

        HTTP 是基于请求 / 响应模式的：客户端向服务器发送一个 HTTP 请求，然后服务器将会
返回一个 HTTP 响应。 Netty 提供了多种编码器和解码器以简化对这个协议的使用。
        一个HTTP 请求 / 响应可能由多个数据部分组成， FullHttpRequest 和 FullHttpResponse 消
息是特殊的子类型，分别代表了完整的请求和响应。所有类型的 HTTP 消息（ FullHttpRequest 、
LastHttpContent 等等）都实现了 HttpObject 接口。
         HttpRequestEncoder 将 HttpRequest、HttpContent 和 LastHttpContent 消息编码为字节
        HttpResponseEncoder 将 HttpResponse、HttpContent 和 LastHttpContent 消息编码为字
节
        HttpRequestDecoder 将字节解码为 HttpRequest、HttpContent 和 LastHttpContent 消息
        HttpResponseDecoder 将字节解码为 HttpResponse、HttpContent 和 LastHttpContent 消
息
        HttpClientCodec 和 HttpServerCodec 则将请求和响应做了一个组合。 ​​​​​​​
聚合 HTTP 消息
        由于 HTTP 的请求和响应可能由许多部分组成，因此你需要聚合它们以形成完整的消息。
为了消除这项繁琐的任务， Netty 提供了一个聚合器 HttpObjectAggregator ，它可以将多个消 息部分合并为 FullHttpRequest 或者 FullHttpResponse 消息。通过这样的方式，你将总是看
到完整的消息内容。
HTTP 压缩
        当使用 HTTP 时，建议开启压缩功能以尽可能多地减小传输数据的大小。虽然压缩会带
来一些 CPU 时钟周期上的开销，但是通常来说它都是一个好主意，特别是对于文本数据来
说。 Netty 为压缩和解压缩提供了 ChannelHandler 实现，它们同时支持 gzip 和 deflate 编码。
使用 HTTPS
        启用 HTTPS 只需要将 SslHandler 添加到 ChannelPipeline 的 ChannelHandler 组合中。
SSL 和 HTTP 的代码参见模块 netty-http
视频中实现步骤：
         1、首先实现 Http 服务器并浏览器访问；
        2、增加 SSL 控制；
        3、实现客户端并访问。

序列化问题

Java 序列化的目的主要有两个：
         1.网络传输
        2.对象持久化
        当选行远程跨迸程服务调用时，需要把被传输的 Java 对象编码为字节数组或者
ByteBuffer 对象。而当远程服务读取到 ByteBuffer 对象或者字节数组时，需要将其解码为发
送时的 Java 对象。这被称为 Java 对象编解码技术。
        Java 序列化仅仅是 Java 编解码技术的一种，由于它的种种缺陷，衍生出了多种编解码
技术和框架
Java 序列化的缺点
        Java 序列化从 JDK1.1 版本就已经提供，它不需要添加额外的类库，只需实现
java.io.Serializable 并生成序列 ID 即可，因此，它从诞生之初就得到了广泛的应用。
但是在远程服务调用（ RPC ）时，很少直接使用 Java 序列化进行消息的编解码和传输，
这又是什么原因呢？下面通过分析 .Tava 序列化的缺点来找出答案。
1 无法跨语言
        对于跨进程的服务调用，服务提供者可能会使用 C 十＋或者其他语言开发，当我们需要
和异构语言进程交互时 Java 序列化就难以胜任。由于 Java 序列化技术是 Java 语言内部的私
有协议，其他语言并不支持，对于用户来说它完全是黑盒。对于 Java 序列化后的字节数组，
别的语言无法进行反序列化，这就严重阻碍了它的应用。
2 序列化后的码流太大
        通过一个实例看下 Java 序列化后的字节数组大小。
3 序列化性能太低
        无论是序列化后的码流大小，还是序列化的性能，JDK 默认的序列化机制表现得都很差。
因此，我们边常不会选择 Java 序列化作为远程跨节点调用的编解码框架。
代码参见模块 netty-basic 下的包 cn.tuling.nettybasic.serializable.protogenesis

如何选择序列化框架

选择四要点
         是否需要跨语言的支持
        空间:编码后占用空间
        时间:编解码速度
        是否追求可读性
        如果项目里有跨语言支持的硬性要求，某种序列化框架只支持特定语言，即使它比其他
的框架快 1 万倍，也没法选择。
        空间和时间其实是对序列化框架的性能要求，这两者其实是存在矛盾的，想要编码后占
用空间小，自然就要花费更多的时间去编码，所以这两者往往要追求一种平衡。
        有些项目里还要求序列化后的数据是人类可读的，这个时候的选择就不多了，一般是
JSON 格式或者 XML 格式，有些序列化框架也支持通过自带工具观察序列化后的数据，也可
以考虑选择。

序列化框架比较

我们可以借鉴阿里技术官方的分析结果
（ https://developer.aliyun.com/article/783611?utm_content=g_1000268438 ）
跨语言来说：
Netty-Netty组件了解_第28张图片
还有一种没体现在上面的 msgpack （ https://msgpack.org/ ）也是支持跨语言的。
从性能上来说
Netty-Netty组件了解_第29张图片

 Netty-Netty组件了解_第30张图片

        从空间性能来看，avro 、 kryo 、 Hessian2 、 fst 、 Protocol buffer 表现都不错；
        从时间性能来看，kryo 、 fst 、 Protocol buffer 表现也很好
        Msgpack 也是一种很优秀的序列化框架，性能和 Protocol buffer 不相上下：
        https://www.howtoautomate.in.th/protobuf-101/2017-05-06-10_30_22-serialization-perfo
rmance-comparisonxmlbinaryjsonp/
        https://www.howtoautomate.in.th/wp-content/uploads/2017/05/2017-05-06-10_30_34-Se
rialization-Performance-comparisonXMLBinaryJSONP....png
Netty-Netty组件了解_第31张图片
Netty-Netty组件了解_第32张图片
        所以接下来，在后续的课程中我们将讲述 Protocol Buffer 、 MessagePack 和 Kyro 的 Netty
的集成，其他的序列化框架和 Netty 的集成，大家可以参考后自行实现。

序列化 – 内置和第三方的 MessagePack 实战

内置

        Netty 内置了对 JBoss Marshalling 和 Protocol Buffers 的支持
        Protocol Buffers 序列化机制代码参见模块 netty-basic 下的包
cn.tuling.nettybasic.serializable.protobuf

集成第三方 MessagePack 实战（ + LengthFieldBasedFrame 详解）

LengthFieldBasedFrame 详解
         maxFrameLength：表示的是包的最大长度，
        lengthFieldOffset：指的是长度域的偏移量，表示跳过指定个数字节之后的才是长度域；
        lengthFieldLength：记录该帧数据长度的字段，也就是长度域本身的长度；
        lengthAdjustment：长度的一个修正值，可正可负，Netty 在读取到数据包的长度值 N 后，
认为接下来的 N 个字节都是需要读取的，但是根据实际情况，有可能需要增加 N 的值，也
有可能需要减少 N 的值，具体增加多少，减少多少，写在这个参数里；
         initialBytesToStrip：从数据帧中跳过的字节数，表示得到一个完整的数据包之后，扔掉
这个数据包中多少字节数，才是后续业务实际需要的业务数据。
         failFast：如果为 true，则表示读取到长度域，TA 的值的超过 maxFrameLength，就抛出
一个 TooLongFrameException，而为 false 表示只有当真正读取完长度域的值表示的字节之后，
才会抛出 TooLongFrameException，默认情况下设置为 true，建议不要修改，否则可能会造
成内存溢出。
数据包大小: 14B = 长度域 2B + "HELLO, WORLD"（单词 HELLO+一个逗号+一个空格+单
词 WORLD）
Netty-Netty组件了解_第33张图片
长度域的值为 12B(0x000c) 。希望解码后保持一样，根据上面的公式 , 参数应该为：
        1. lengthFieldOffset = 0
        2. lengthFieldLength = 2
        3. lengthAdjustment 无需调整
        4. initialBytesToStrip = 0 - 解码过程中，没有丢弃任何数据
数据包大小 : 14B = 长度域 2B + "HELLO, WORLD"
Netty-Netty组件了解_第34张图片
长度域的值为 12B(0x000c) 。解码后，希望丢弃长度域 2B 字段，所以，只要
initialBytesToStrip = 2 即可。
        1. lengthFieldOffset = 0
        2. lengthFieldLength = 2
        3. lengthAdjustment 无需调整
        4. initialBytesToStrip = 2 解码过程中，丢弃 2 个字节的数据
数据包大小 : 14B = 长度域 2B + "HELLO, WORLD" 。长度域的值为 14(0x000E)
Netty-Netty组件了解_第35张图片
长度域的值为 14(0x000E) ，包含了长度域本身的长度。希望解码后保持一样，根据上面
的公式，参数应该为：
        1. lengthFieldOffset = 0
        2. lengthFieldLength = 2
        3. lengthAdjustment = -2 因为长度域为 14 ，而报文内容为 12 ，为了防止读取报文超出
报文本体，和将长度字段一起读取进来，需要告诉 netty ，实际读取的报文长度比长度域中
的要少 2 （ 12-14=-2 ）
        4. initialBytesToStrip = 0 - 解码过程中，没有丢弃任何数据
在长度域前添加 2 个字节的 Header 。长度域的值 (0x00000C) = 12 。总数据包长度 :
17=Header(2B) + 长度域 (3B) + "HELLO, WORLD"
长度域的值为 12B(0x000c) 。编码解码后，长度保持一致，所以 initialBytesToStrip = 0 。
参数应该为 :
        1. lengthFieldOffset = 2
        2. lengthFieldLength = 3
        3. lengthAdjustment = 0 无需调整 4. initialBytesToStrip = 0 - 解码过程中，没有丢弃任何数据
Header 与长度域的位置换了。总数据包长度 : 17= 长度域 (3B) + Header(2B) + "HELLO,
WORLD"
长度域的值为 12B(0x000c) 。编码解码后，长度保持一致，所以 initialBytesToStrip = 0 。
参数应该为 :
        1. lengthFieldOffset = 0
        2. lengthFieldLength = 3
        3. lengthAdjustment = 2 因为长度域为 12 ，而报文内容为 12 ，但是我们需要把 Header
的值一起读取进来，需要告诉 netty ，实际读取的报文内容长度比长度域中的要多 2 （ 12+2=14 ）
        4. initialBytesToStrip = 0 - 解码过程中，没有丢弃任何数据
        带有两个 header 。 HDR1 丢弃，长度域丢弃，只剩下第二个 header 和有效包体，这种
协议中，一般 HDR1 可以表示 magicNumber ，表示应用只接受以该 magicNumber 开头的二
进制数据， rpc 里面用的比较多。总数据包长度 : 16=HDR1(1B)+ 长度域 (2B) +HDR2(1B) + "HELLO, WORLD"
Netty-Netty组件了解_第36张图片
长度域的值为 12B(0x000c)
        1. lengthFieldOffset = 1 (HDR1 的长度 )
        2. lengthFieldLength = 2
        3. lengthAdjustment =1 因为长度域为 12 ，而报文内容为 12 ，但是我们需要把 HDR2 的
值一起读取进来，需要告诉 netty ，实际读取的报文内容长度比长度域中的要多 1 （ 12+1=13 ）
        4. initialBytesToStrip = 3 丢弃了 HDR1 和长度字段
带有两个 header ， HDR1 丢弃，长度域丢弃，只剩下第二个 header 和有效包体。总数
据包长度 : 16=HDR1(1B)+ 长度域 (2B) +HDR2(1B) + "HELLO, WORLD"
长度域的值为 16B(0x0010) ，长度为 2 ， HDR1 的长度为 1 ， HDR2 的长度为 1 ，包体的长
度为 12 ， 1+1+2+12=16 。
        1. lengthFieldOffset = 1
        2. lengthFieldLength = 2
        3. lengthAdjustment = -3 因为长度域为 16 ，需要告诉 netty ，实际读取的报文内容长度比
长度域中的要 少 3 （ 13-16= -3 ）
        4. initialBytesToStrip = 3 丢弃了 HDR1 和长度字段
MessagePack 集成
代码参见模块 netty-basic 下的 : cn.tuling.serializable.msgpack 包下

如何进行单元测试

        一种特殊的 Channel 实现—— EmbeddedChannel ，它是 Netty 专门为改进针对
ChannelHandler 的单元测试而提供的。
        将入站数据或者出站数据写入到 EmbeddedChannel 中，然后检查是否有任何东西到达
了 ChannelPipeline 的尾端。以这种方式，你便可以确定消息是否已经被编码或者被解码过
了，以及是否触发了任何的 ChannelHandler 动作。
​​​​​​​
        writeInbound(Object... msgs)
        将入站消息写到 EmbeddedChannel 中。 如果 可以通过 readInbound() 方法从
EmbeddedChannel 中读取数据，则返回 true
        readInbound()
        从 EmbeddedChannel 中读取一个入站消息。任何返回的东西都穿越了整个
ChannelPipeline 。 如果 没有任何可供读取的，则返回 null
        writeOutbound(Object... msgs)
        将出站消息写到 EmbeddedChannel 中。 如果 现在可以通过 readOutbound() 方法从
EmbeddedChannel 中读取到什么东西，则返回 true
        readOutbound()
        从 EmbeddedChannel 中读取一个出站消息。任何返回的东西都穿越了整个
ChannelPipeline 。如果没有任何可供读取的，则返回 null
        finish() 将 EmbeddedChannel 标记为完成，并且如果有可被读取的入站数据或者出站数
据，则返回 true 。这个方法还将会调用 EmbeddedChannel 上的 close() 方法。
        入站数据由 ChannelInboundHandler 处理，代表从远程节点读取的数据。出站数据由
ChannelOutboundHandler 处理，代表将要写到远程节点的数据。
        使用 writeOutbound() 方法将消息写到 Channel 中，并通过 ChannelPipeline 沿着出站的
方向传递。随后，你可以使用 readOutbound() 方法来读取已被处理过的消息，以确定结果是
否和预期一样。 类似地，对于入站数据，你需要使用 writeInbound() 和 readInbound() 方法。
        在每种情况下，消息都将会传递过 ChannelPipeline ，并且被相关的
ChannelInboundHandler 或者 ChannelOutboundHandler 处理。
Netty-Netty组件了解_第37张图片

测试入站消息

        我们有一个简单的 ByteToMessageDecoder 实现。给定足够的数据，这个实现将产生固
定大小的帧。如果没有足够的数据可供读取，它将等待下一个数据块的到来，并将再次检查
是否能够产生一个新的帧。
        这个特定的解码器将产生固定为 3 字节大小的帧。因此，它可能会需要多个事件来提
供足够的字节数以产生一个帧。

测试出站消息

        在测试的处理器—AbsIntegerEncoder ，它是 Netty 的 MessageToMessageEncoder 的一个
特殊化的实现，用于将负值整数转换为绝对值。
        该示例将会按照下列方式工作：
持有 AbsIntegerEncoder 的 EmbeddedChannel 将会以 4 字节的负整数的形式写出站数据；
        编码器将从传入的 ByteBuf 中读取每个负整数，并将会调用 Math.abs() 方法来获取其绝
对值；
        编码器将会把每个负整数的绝对值写到 ChannelPipeline 中。

测试异常处理

        应用程序通常需要执行比转换数据更加复杂的任务。例如，你可能需要处理格式不正确
的输入或者过量的数据。在下一个示例中，如果所读取的字节数超出了某个特定的限制，我
们将会抛出一个 TooLongFrameException 。
        这是一种经常用来防范资源被耗尽的方法。设定最大的帧大小已经被设置为 3 字节。
如果一个帧的大小超出了该限制，那么程序将会丢弃它的字节，并抛出一个 TooLongFrameException 。位于 ChannelPipeline 中的其他 ChannelHandler 可以选择在
exceptionCaught() 方法中处理该异常或者忽略它
​​​​​​​

你可能感兴趣的:(php,开发语言)

  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 如何用matlab灵活控制feko的求解 NingrLi matlab开发语言
    https://bbs.rfeda.cn/read.php?tid=3778Feko中的模型和求解设置等都可以通过editfeko进行设置，其文件存储为.pre文件，该文件可以用文本打开，因此，我们可以通过VB、VC、matlab等工具对.pre文件进行读写操作，以达到更灵活的使用feko。同样，对于.out文件，我们也可以进行读操作。熟练使用对.pre文件和.out文件的操作后，我们可以方便的计
  • 进销存小程序源码 PHP网络版ERP进销存管理系统 全开源可二开 摸鱼小号 php
    可直接源码搭建部署发布后使用：一、功能模块介绍该系统模板主要有进，销，存三个主要模板功能组成，下面将介绍各模块所对应的功能；进：需要将产品采购入库，自动生成采购明细台账同时关联财务生成付款账单；销：是指对客户的销售订单记录，汇总生成产品销售明细及回款计划；存：库存的日常盘点与统计，库存下限预警、出入库台账、库存位置等。1.进购管理采购订单：采购下单审批→由上级审批通过采购入库；采购入库：货品到货>
  • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署） java毕设程序源码王哥 php课程设计vue.js
    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
  • Github 2024-09-12 Go开源项目日报Top10 老孙正经胡说 githubgolang开源Github趋势分析开源项目PythonGolang
    根据GithubTrendings的统计，今日(2024-09-12统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下：开发语言项目数量Go项目10C项目1Terraform：基础设施即代码的开源工具创建周期：3626天开发语言：Go协议类型：OtherStar数量：40393个Fork数量：9397次关注人数：40393人贡献人数：358人OpenIssues数量：1943个Git
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • php服务器状态监测,PHP网站状态在线监控源码 傲雪吟霜白如冰 php服务器状态监测
    在网上找的一个在线监控源码，比较简单，但是功能也略有不足，例如如果网站挂了就按照监控频率一直发邮件提示，网站恢复之后不会发邮件通知；不能直接填写要监控的网址或者某一页面，适合监控大量的网站或者vps、服务器。最新使用感受：没有发送邮件限制，我设置监控频率是一个小时，一天没管就把邮箱塞满了。如果服务器恢复的话不会专门发邮件提醒。如果只是监控几个站的话有很多免费的监控网站可以使用，只是使用数量上有限制
  • php状态监控源码,PHP服务器状态监控实现程序 江子星 php状态监控源码
    */header('Content-type:text/html;charset=utf-8');include'./smtp/class.smtp.php';include'./smtp/class.phpmailer.php';functionsendmail($subject='',$body=''){date_default_timezone_set('Asia/Shanghai');//
  • 服务器状态监控php源码,服务器状态监控_监控Linux服务器网站状态的SHELL脚本 温糯米 服务器状态监控php源码
    摘要腾兴网为您分享:监控Linux服务器网站状态的SHELL脚本，蜗牛集市，同花顺，探客宝，手柄助手等软件知识，以及日期倒计时插件，云南省教育资源公共，rui手机桌面，小屁孩桌面便签，合金装备崛起复仇，朝夕日历，photoshop图像处理软件,一年级学生每日计划表，悟空找房，饿了吗外卖商家版，逃生，中国民宿网，realpolitiks，交通安全知识竞赛，雅思流利说等软件it资讯，欢迎关注腾兴网。1
  • 数据仓库介绍 阿龙的代码在报错 数据分析数据仓库数据库
    数据仓库数据仓库的概念数据仓库的主要特征数据仓库的主流开发语言-sql结构化数据sql语句数据仓库的概念数据仓库（英语：DataWarehouse，简称数仓、DW）,是一个用于存储、分析、报告的数据系统。数据仓库的目的是构建面向分析的集成化数据环境，分析结果为企业提供决策支持（DecisionSupport）。就是数据仓库只分析数据并不产生数据数据仓库的主要特征1、面向主题主题是一个抽象的概念，是
  • php 实现JWT 每天瞎忙的农民工 phpphp
    在PHP中，JSONWebToken(JWT)是一种开放标准(RFC7519)用于在各方之间作为JSON对象安全地传输信息。JWT通常用于身份验证系统，如OAuth2或基于令牌的身份验证。以下是一个基本的PHP实现JWT生成和验证的代码示例。JWT的组成部分JWT包含三个部分：Header（头部）：说明算法和令牌类型。Payload（有效载荷）：包含声明（如用户数据、过期时间等）。Signatur
  • 外卖霸王餐返利外卖会员卡小程序开发 闹小艾 good506070微信小程序小程序
    外卖霸王餐返利外卖会员卡小程序开发"社交电商赋能下的外卖返利小程序"是专为商家与用户双赢而设计的创新平台。以下是其开发方案的详细步骤：一、需求梳理：首先，我们需要明确小程序的核心功能和特色。包括设定活动类型、返利策略，以及用户体验友好的界面设计。二、技术决策：技术选型是关键。我们采用小程序的开发框架，利用JavaScript作为前端开发语言，并结合微信提供的API进行后端接口调用与数据处理。三、账
  • discuz discuz_admincp.php 讲解,Discuz! 1.5-2.5 命令执行漏洞分析(CVE-2018-14729) weixin_39740419 discuz讲解
    0x00漏洞简述漏洞信息8月27号有人在GitHub上公布了有关Discuz1.5-2.5版本中后台数据库备份功能存在的命令执行漏洞的细节。漏洞影响版本Discuz!1.5-2.50x01漏洞复现官方论坛下载相应版本就好。0x02漏洞分析需要注意的是这个漏洞其实是需要登录后台的，并且能有数据库备份权限，所以比较鸡肋。我这边是用Discuz!2.5完成漏洞复现的，并用此进行漏洞分析的。漏洞点在：so
  • FastCGI结合docker下的Nginx执行shell脚本 南波波 nginxdocker
    1使用docker下载Nginx下面展示一些内联代码片。a.#dockerpullnginx#dockerrun--namerunoob-php-nginx-p8088:80-d\-v~/nginx/www:/usr/share/nginx/html:ro\-v~/nginx/conf/conf.d:/etc/nginx/conf.d:ro\nginxb.在~/nginx/conf/conf.d创
  • 【免费】springboot项目申报管理系统|毕业设计|Javaweb项目 计算机学姐来啦 springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee
    收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
  • 《C++语言的设计和演化》读书感悟（一） 依晴无旧 C\C++java开发语言
    写了一百多篇技术文章了，我突然想写一下和技术文搭一点关系的语言发展设计的文章，《C++语言的设计和演化》是我无聊翻自己库存电子书找到了，因为当年看这本书是C++之父写的，所以就保存下来，但是当时主要学习C++，这本书更多是C++之父从本身出发，对C++设计和演化的观点和感想，所以当时就被我扔去吃灰了。现在重拾起来，读起来别有风味。开发语言，虽然很多，但是万变不离其宗，学进去了，无非就是数据类型、控
  • 什么是 PHP? 为什么用 PHP? 谁在用 PHP? m0_37438181 永远学习php开发语言
    一、什么是PHP？PHP（HypertextPreprocessor，超文本预处理器）是一种广泛应用于Web开发的通用开源脚本语言。PHP主要用于服务器端编程，可以嵌入HTML中，与数据库进行交互，生成动态网页内容。它具有以下特点：简单易学：语法相对简单，容易上手，对于初学者来说是一个不错的选择。跨平台性：可以在多种操作系统上运行，如Windows、Linux、Unix等。丰富的函数库：提供了大量
  • 【网络安全】漏洞挖掘：php代码审计 秋说 网络安全phpweb安全漏洞挖掘
    未经许可，不得转载。文章目录正文正文在应用程序中，通过一个JavaScript注释发现了一个备份ZIP文件。解压后，获取了应用程序的代码，其中包含如下代码片段：代码首先检查变量$action是否等于'convert'，如果是，则继续执行。随后对传入的变量$data使用trim()函数去除两端空白字符，并使用eval()函数执行$data的内容。显然，代码对$data没有进行任何过滤或验证，因此可以
  • 内网穿透之EW使用、判断服务器是否出网 板栗妖怪 学习内网渗透
    环境搭建使用的是下面文章的环境记一次学习--内网穿透-CSDN博客ew代理然后同样通过thinkphp漏洞写入文件，然后通过蚁剑连接然后上传ew的Linux版本，然后加权执行一层代理正向代理设置正向代理（在ubuntu上），然后kali在proxychain配置文件中连接ubuntu的192.168.244.154的代理端口反向代理在ubuntu上设置反向代理，将连接反弹到kali上的某个端口。然
  • python基于django/flask的NBA球员大数据分析与可视化python+java+node.js QQ_511008285 pythondjangoflaskjavaspringboot数据分析
    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以本文针对NBA球员的大数据进行
  • Java基于spring boot的国产电影数据分析与可视化python+java+node.js QQ_511008285 javaspringboot数据分析pythondjangovue.jsflask
    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以  该系统使用进行大数据处理和
  • python学习第七节：正则表达式 一只会敲代码的小灰灰 python学习python学习正则表达式
    python学习第七节：正则表达式正则表达式基本上在所有开发语言中都会使用到，在python中尤为重要。当我们使用python开发爬虫程序将目标网页扒下来之后我们要从网页中解析出我们想要的信息，这个时候就需要正则表达式去进行匹配。importrere的常量re模块中有9个常量，常量的值都是int类型！（知道就行）修饰符描述re.l使匹配对大小写不敏感re.L做本地化识别(locale-aware)
  • 定制优化Nextcloud镜像 攻城狮_正
    Nextcloud是一款开源免费的私有云存储网盘项目，可以让你快速便捷地搭建一套属于自己或团队的云同步网盘，从而实现跨平台跨设备文件同步、共享、版本控制、团队协作等功能。它的客户端覆盖了Windows、Mac、Android、iOS、Linux等各种平台，也提供了网页端以及WebDAV接口，所以你几乎可以在各种设备上方便地访问你的云盘。Nextcloud基于PHP语言开发，可以使用Nginx+PH
  • 华纳云：修复WordPress内存耗尽错误的常用方法有哪些？ 华纳云IDC服务商 服务器WordPress
    WordPress内存耗尽错误通常是由于PHP内存限制不足导致的。修复这种错误的方法有多种，以下是几种常用的方法：1.修改wp-config.php文件在WordPress根目录的wp-config.php文件中添加或修改以下代码，增加PHP的内存限制：define('WP_MEMORY_LIMIT','256M');将256M替换为所需的内存值。例如，可以将其设置为128M,256M,512M等
  • Cocos2d、Cocos2dx、Cocos Creator、Cocos Studio的区别 Thomas游戏圈
    一、Cocos2d和Cocos2dx的区别【开发语言】：Cocos2d是Object-C写的，Cocos2dx是C++写的，支持使用C++、Lua或Java进行开发。【运行平台】：Cocos2d只能在IOS下运行，Cocos2dx是跨平台的，适配iOS、Android、HTML5、Windows和Mac系统，功能侧重于原生移动平台。点击链接加入群聊【Unity/Cocos交流群】【国籍】：Coco
  • CentOS下php安装mcrypt扩展 天咋哭了
    （以下步骤均为本人实际操作，可能与你的安装方法有所区别，但我会尽量排除疑惑）大致步骤（1）安装mcrypt，（2）安装php对mcrypt的扩展，（3）重启apache（1）、确认你的linux没有安装mcrypt库，如果已安装，跳过安装步骤[root@test-206~]#yumlistinstalled|grepmcryptlibmcrypt.x86_642.5.8-4.el5.centosi
  • [Unity优化] Unity3D如何减少安装包大小 hcq666
    译官方文档：http://docs.unity3d.com/Manual/ReducingFilesize.htmlPDF文档：http://www.rukawa.cn/Uploads/Attachment/ReducingFilesize/ReducingFilesize.pdf原文地址：http://www.rukawa.cn/index.php?s=/home/article/detail/
  • 4个步骤，解锁“非暴力沟通”12字秘诀（转） 谭琳_freeisok
    原文地址：http://sa.sogou.com/sgsearch/sgs_tc_news.php?req=HvihEyHzKTRpqhoFoRYZrxkyz8qRuXiOGTd2-liL6rMw32GQqbt6pIHt_qlL7scd&user_type=1作为一个遵纪守法的好人，也许我们从来没有把谈话和“暴力”扯上关系。不过，如果稍微留意一下我们生活中的谈话方式，一定会发现，有些话确实伤人。不
  • PHP中的microtime(true)是干什么的？底层原理是什么？ 快点好好学习吧 php开发语言
    microtime(true)是PHP中用于获取当前Unix时间戳（包括微秒部分）的一个函数。它返回一个浮点数，表示自Unix纪元（1970年1月1日00:00:00UTC）以来的当前时间，精确到微秒。用法示例$time=microtime(true);echo$time;参数true：如果传递true作为参数，microtime()会返回一个浮点数。如果不传递参数或传递false，则返回一个字符
  • springboot宠物咖啡馆平台的设计与实现 然然学长 springboot宠物java后端intellij-idea开发语言
    运行环境环境说明:开发语言:java框架:springboot，vueJDK版本:JDK1.8数据库:mysql5.7+(推荐5.7，8.0也可以)数据库工具:Navicat11+开发软件:idea/eclipse(推荐idea)Maven包:Maven3.3.9+系统详细实现管理员模块的实现用户信息管理基于SpringBoot的宠物咖啡馆平台的设计与实现的系统管理员可以管理用户，可以对用户信息添
  • 面向对象面向过程 3213213333332132 java
    面向对象：把要完成的一件事，通过对象间的协作实现。 面向过程：把要完成的一件事，通过循序依次调用各个模块实现。 我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。 1、面向对象 package bigDemo.ObjectOriented; /** * 大象类 * * @Description * @author FuJian
  • Java Hotspot: Remove the Permanent Generation bookjovi HotSpot
      openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122   JEP 122: Remove the Permanent Generation Author Jon Masamitsu Organization Oracle Created 2010/8/15 Updated 2011/
  • 正则表达式向前查找向后查找,环绕或零宽断言 dcj3sjt126com 正则表达式
    向前查找和向后查找 1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。     对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。 2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
  • BaseDao 171815164 seda
    import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.PreparedStatement; import java.sql.ResultSet; public class BaseDao { public Conn
  • Ant标签详解--Java命令 g21121 Java命令
            这一篇主要介绍与java相关标签的使用         终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。           1
  • [简单]代码片段_电梯数字排列 53873039oycg 代码
           今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下:       import java.util.Arrays; public class 电梯数字排列_S3_Test { public static void main(S
  • Hessian原理 云端月影 hessian原理
    Hessian 原理分析 一．      远程通讯协议的基本原理 网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
  • 区分Activity的四种加载模式----以及Intent的setFlags aijuans android
      在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。 这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。 加载模式分类及在哪里配置 Activity有四种加载模式： standard singleTop
  • hibernate几个核心API及其查询分析 antonyup_2006 html.netHibernatexml配置管理
    (一)  org.hibernate.cfg.Configuration类         读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.)         Configuration co
  • PL/SQL的流程控制 百合不是茶 oraclePL/SQL编程循环控制
    PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有   流程控制; 分支语句 if 条件 then 结果 else 结果 end if ; 条件语句 case when 条件 then 结果; 循环语句 loop
  • 强大的Mockito测试框架 bijian1013 mockito单元测试
    一.自动生成Mock类        在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类  &nbs
  • 精通Oracle10编程SQL(11)开发子程序 bijian1013 oracle数据库plsql
    /* *开发子程序 */ --子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用 --PL/SQL有两种类型的子程序：过程和函数 --开发过程 --建立过程：不带任何参数 CREATE OR REPLACE PROCEDURE out_time IS BEGIN DBMS_OUTPUT.put_line(systimestamp); E
  • 【EhCache一】EhCache版Hello World bit1129 Hello world
    本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍   环境准备 1.新建Maven项目   2.添加EhCache的Maven依赖 <dependency> <groupId>ne
  • 学习EJB3基础知识笔记 白糖_ beanHibernatejbosswebserviceejb
    最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。   EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
  • angular.bootstrap boyitech AngularJSAngularJS APIangular中文api
    angular.bootstrap 描述：     手动初始化angular。     这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。   使用方法：     angular .
  • java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数 bylijinnan java
    public class SearchInShiftedArray { /** * 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。 * 请在这个特殊数组中找出给定的整数。 * 解答： * 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
  • 天使还是魔鬼？都是我们制造 ducklsl 生活教育情感
    ----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！     从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！     自己挑了两部先看了看，但是发现看完之后，心里久久不能平
  • [机器智能与生物]研究生物智能的问题 comsci 生物
          我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别....       但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
  • 获取Android Device的信息 dai_lm android
    String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT; phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI; phoneInfo += ", TAGS: " + android.os.Build.TAGS; ph
  • 最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现 datamachine java算法字符串匹配
    原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
  • 小学5年级英语单词背诵第一课 dcj3sjt126com englishword
    long 长的 show 给...看，出示 mouth 口，嘴 write 写   use 用，使用 take 拿，带来 hand 手 clever 聪明的   often 经常 wash 洗 slow 慢的 house 房子   water 水 clean 清洁的 supper 晚餐 out 在外   face 脸，
  • macvim的使用实战 dcj3sjt126com macvim
    macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳   1. 下载macvim https://code.google.com/p/macvim/   2. 了解macvim :h               vim的使用帮助信息 :h macvim  
  • java二分法查找 蕃薯耀 java二分法查找二分法java二分法
    java二分法查找 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 11:40:03 星期二 http:/
  • Spring Cache注解+Memcached hanqunfeng springmemcached
    Spring3.1 Cache注解  依赖jar包： <!-- simple-spring-memcached --> <dependency> <groupId>com.google.code.simple-spring-memcached</groupId> <artifactId>simple-s
  • apache commons io包快速入门 jackyrong apache commons
    原文参考 http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html   Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍：   1）  工具类   2
  • 如何学习编程 lampcy java编程C++c
    首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
  • 架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy nannan408 Spring3
    1.前言。    如题。 2.描述。    @DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。 @DependsOn({"steelAxe","abc"}) @Comp
  • Spring4+quartz2的配置和代码方式调度 Everyday都不同 代码配置spring4quartz2.x定时任务
    前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API……   quartz定时任务必须搞清楚几个概念： JobDetail——处理类 Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
  • Hibernate入门 tntxia Hibernate
      前言   使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。   Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。   如
  • Math类 xiaoxing598 Math
    一、Java中的数字（Math）类是final类，不可继承。 1、常数 PI：double圆周率 E：double自然对数 2、截取（注意方法的返回类型） double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数 int round(float f) 返回四舍五入后的整数 long round