AbstractTrafficShapingHandler (Netty API Reference (4.1.22.Final))

java.lang.Object
- io.netty.channel.ChannelHandlerAdapter
- - io.netty.channel.ChannelInboundHandlerAdapter
  - - io.netty.channel.ChannelDuplexHandler
    - - io.netty.handler.traffic.AbstractTrafficShapingHandler

All Implemented Interfaces:

ChannelHandler ， ChannelInboundHandler ， ChannelOutboundHandler

已知直接子类：

ChannelTrafficShapingHandler ， GlobalChannelTrafficShapingHandler ， GlobalTrafficShapingHandler
```
public abstract class AbstractTrafficShapingHandler
extends ChannelDuplexHandler
```
AbstractTrafficShapingHandler允许将全局带宽（请参阅GlobalTrafficShapingHandler ）或每个会话带宽（请参阅ChannelTrafficShapingHandler ）限制为流量整形。它允许您使用来自TrafficCounter的监视器实现对带宽的几乎实时监视，这些监视器将回调每个checkInterval方法执行此处理程序的计数。

如果您因任何特定原因需要停止监视（记帐）或更改读/写限制或检查间隔，可以使用以下几种方法：
- configure允许您更改读取或写入限制或checkInterval
- getTrafficCounter允许您访问TrafficCounter ，从而停止或启动监视，直接更改checkInterval或访问其值。

Nested Class Summary
- Nested classes/interfaces inherited from interface io.netty.channel.ChannelHandler
  ChannelHandler.Sharable

Field Summary

Fields
Modifier and Type	Field and Description
`protected long`	`checkInterval` 两个性能快照之间的延迟
`static long`	`DEFAULT_CHECK_INTERVAL` 两次检查之间的默认延迟：1秒
`static long`	`DEFAULT_MAX_TIME` 流量整形时的默认最大延迟（在此期间不会发生通信）。
`protected long`	`maxTime` 最大延迟等待
`protected TrafficCounter`	`trafficCounter` 流量计数器

构造方法摘要

构造方法
Modifier	Constructor and Description
`protected`	`AbstractTrafficShapingHandler()` 构造函数使用NO LIMIT，缺省值为 1000L ms，默认最大时间为 15000L ms。
`protected`	`AbstractTrafficShapingHandler(long checkInterval)` 构造函数使用NO LIMIT，默认最大时间为延迟允许值 15000L ms。
`protected`	`AbstractTrafficShapingHandler(long writeLimit, long readLimit)` 构造函数使用 1000L ms的默认“检查间隔”值和默认的最大时间作为延迟允许值 15000L ms。
`protected`	`AbstractTrafficShapingHandler(long writeLimit, long readLimit, long checkInterval)` 使用默认最大时间作为延迟允许值 15000L毫秒的构造函数。
`protected`	`AbstractTrafficShapingHandler(long writeLimit, long readLimit, long checkInterval, long maxTime)`

方法摘要

所有方法静态方法接口方法具体的方法弃用的方法
Modifier and Type	Method and Description
`protected long`	`calculateSize(java.lang.Object msg)` 计算给定的 `Object`的大小。
`void`	`channelRead(ChannelHandlerContext ctx, java.lang.Object msg)` 致电`ChannelHandlerContext.fireChannelRead(Object)`转发到`ChannelPipeline`中的下一个`ChannelInboundHandler` 。
`void`	`channelRegistered(ChannelHandlerContext ctx)` 致电`ChannelHandlerContext.fireChannelRegistered()`转发到`ChannelPipeline`中的下一个`ChannelInboundHandler` 。
`void`	`configure(long newCheckInterval)` 更改检查间隔。
`void`	`configure(long newWriteLimit, long newReadLimit)` 更改底层的限制。
`void`	`configure(long newWriteLimit, long newReadLimit, long newCheckInterval)` 更改底层限制和检查时间间隔。
`protected void`	`doAccounting(TrafficCounter counter)` 每次从TrafficCounters计算会计时调用。
`long`	`getCheckInterval()`
`long`	`getMaxTimeWait()`
`long`	`getMaxWriteDelay()`
`long`	`getMaxWriteSize()`
`long`	`getReadLimit()`
`long`	`getWriteLimit()`
`protected static boolean`	`isHandlerActive(ChannelHandlerContext ctx)`
`void`	`read(ChannelHandlerContext ctx)` 致电`ChannelHandlerContext.read()`转发到`ChannelPipeline`中的下一个`ChannelOutboundHandler` 。
`void`	`setCheckInterval(long checkInterval)`
`void`	`setMaxTimeWait(long maxTime)` 请注意，更改将被视为尽力而为，这意味着所有已计划的流量都不会改变，但仅适用于新的流量。
`void`	`setMaxWriteDelay(long maxWriteDelay)` 请注意，更改将被视为尽力而为，这意味着所有已计划的流量都不会改变，但仅适用于新的流量。
`void`	`setMaxWriteSize(long maxWriteSize)` 请注意，此限制是防止内存不足异常的最佳内存限制。
`void`	`setReadLimit(long readLimit)` 请注意，更改将被视为尽力而为，这意味着所有已计划的流量都不会改变，但仅适用于新的流量。
`void`	`setWriteLimit(long writeLimit)` 请注意，更改将被视为尽力而为，这意味着所有已计划的流量都不会改变，但仅适用于新的流量。
`protected void`	`submitWrite(ChannelHandlerContext ctx, java.lang.Object msg, long delay, ChannelPromise promise)` 已过时。
`java.lang.String`	`toString()`
`TrafficCounter`	`trafficCounter()`
`protected int`	`userDefinedWritabilityIndex()`
`void`	`write(ChannelHandlerContext ctx, java.lang.Object msg, ChannelPromise promise)` 致电`ChannelOutboundInvoker.write(Object, ChannelPromise)`转发到`ChannelPipeline`中的下一个`ChannelOutboundHandler` 。

Methods inherited from class io.netty.channel.ChannelDuplexHandler
bind, close, connect, deregister, disconnect, flush

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter
channelActive, channelInactive, channelReadComplete, channelUnregistered, channelWritabilityChanged, exceptionCaught, userEventTriggered

Methods inherited from class io.netty.channel.ChannelHandlerAdapter
ensureNotSharable, handlerAdded, handlerRemoved, isSharable

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.netty.channel.ChannelHandler
exceptionCaught, handlerAdded, handlerRemoved

- 字段详细信息
  - DEFAULT_CHECK_INTERVAL
```
public static final long DEFAULT_CHECK_INTERVAL
```
    两次检查之间的默认延迟：1秒
    
    另请参见：
    
    Constant Field Values
  - DEFAULT_MAX_TIME
```
public static final long DEFAULT_MAX_TIME
```
    流量整形时的默认最大延迟（在此期间不会发生通信）。应该比TIMEOUT少。这里是“标准”30的一半
    
    另请参见：
    
    Constant Field Values
  - trafficCounter
```
protected TrafficCounter trafficCounter
```
    流量计数器
  - maxTime
```
protected volatile long maxTime
```
    最大延迟等待
  - checkInterval
```
protected volatile long checkInterval
```
    两个性能快照之间的延迟
- 构造方法详细信息
  - AbstractTrafficShapingHandler
```
protected AbstractTrafficShapingHandler(long writeLimit,
                                        long readLimit,
                                        long checkInterval,
                                        long maxTime)
```
    参数
    
    writeLimit - 0或以字节/秒为单位的限制
    
    readLimit - 0或以字节/秒为单位的限制
    
    checkInterval - 通道两次性能计算之间的延迟，如果不计算统计信息，则延迟0。
    
    maxTime - maxTime等待的最大延迟时间。必须是积极的。
  - AbstractTrafficShapingHandler
```
protected AbstractTrafficShapingHandler(long writeLimit,
                                        long readLimit,
                                        long checkInterval)
```
    使用默认最大时间作为延迟允许值 15000L毫秒的构造函数。
    
    参数
    
    writeLimit - 0或以字节/秒为单位的限制
    
    readLimit - 0或以字节/秒为单位的限制
    
    checkInterval - 通道两次性能计算之间的延迟，如果不计算统计数据，则延迟0。
  - AbstractTrafficShapingHandler
```
protected AbstractTrafficShapingHandler(long writeLimit,
                                        long readLimit)
```
    使用默认检查间隔时间值 1000L毫秒和默认最大时间作为延迟允许值 15000L毫秒的构造函数。
    
    参数
    
    writeLimit - 0或以字节/秒为单位的限制
    
    readLimit - 0或以字节/秒为单位的限制
  - AbstractTrafficShapingHandler
```
protected AbstractTrafficShapingHandler()
```
    构造函数使用NO LIMIT，默认值为 1000L ms，默认最大时间为 15000L ms。
  - AbstractTrafficShapingHandler
```
protected AbstractTrafficShapingHandler(long checkInterval)
```
    构造函数使用NO LIMIT，默认最大时间为延迟允许值 15000L ms。
    
    参数
    
    checkInterval - 通道两次性能计算之间的延迟，如果不计算统计数据，则延迟0。
- 方法详细信息
  - userDefinedWritabilityIndex
```
protected int userDefinedWritabilityIndex()
```
    结果
    
    TrafficShapingHandler用来管理用户定义的可写性的索引。对于通道TSH，它被定义为：对于全局TSH，它被定义为：对于GlobalChannel TSH它被定义为。
  - configure
```
public void configure(long newWriteLimit,
                      long newReadLimit,
                      long newCheckInterval)
```
    更改底层限制和检查时间间隔。
    请注意，更改将被视为尽力而为，这意味着所有已计划的流量都不会改变，但仅适用于新的流量。
    
    所以这种方法的预期用法不是太频繁地使用，因此对于流量整形配置。
    
    参数
    
    newWriteLimit - 新的写入限制（以字节为单位）
    
    newReadLimit - 新的读取限制（以字节为单位）
    
    newCheckInterval - 新的检查间隔（以毫秒为单位）
  - configure
```
public void configure(long newWriteLimit,
                      long newReadLimit)
```
    更改底层的限制。
    请注意，更改将被视为尽力而为，这意味着所有已计划的流量都不会改变，但仅适用于新的流量。
    
    所以这种方法的预期用法不是太频繁地使用，因此对于流量整形配置。
    
    参数
    
    newWriteLimit - 新的写入限制（以字节为单位）
    
    newReadLimit - 新的读取限制（以字节为单位）
  - configure
```
public void configure(long newCheckInterval)
```
    更改检查间隔。
    
    参数
    
    newCheckInterval - 新的检查间隔（以毫秒为单位）
  - getWriteLimit
```
public long getWriteLimit()
```
    结果
    
    writeLimit
  - setWriteLimit
```
public void setWriteLimit(long writeLimit)
```
    请注意，更改将被视为尽力而为，这意味着所有已计划的流量都不会改变，但仅适用于新的流量。
    
    所以这种方法的预期用法不是太频繁地使用，因此对于流量整形配置。
    
    参数
    
    writeLimit - 要设置的writeLimit
  - getReadLimit
```
public long getReadLimit()
```
    结果
    
    readLimit
  - setReadLimit
```
public void setReadLimit(long readLimit)
```
    请注意，更改将被视为尽力而为，这意味着所有已计划的流量都不会改变，但仅适用于新的流量。
    
    所以这种方法的预期用法不是太频繁地使用，因此对于流量整形配置。
    
    参数
    
    readLimit - 要设置的readLimit
  - getCheckInterval
```
public long getCheckInterval()
```
    结果
    
    checkInterval
  - setCheckInterval
```
public void setCheckInterval(long checkInterval)
```
    参数
    
    checkInterval - 每个步骤之间的间隔以毫秒为单位选中要设置的值，默认值为1000毫秒。
  - setMaxTimeWait
```
public void setMaxTimeWait(long maxTime)
```
    请注意，更改将被视为尽力而为，这意味着所有已计划的流量都不会改变，但仅适用于新的流量。
    
    所以这种方法的预期用法不是太频繁地使用，因此对于流量整形配置。
    
    参数
    
    maxTime - 等待中的最大延迟应小于相关协议中的TIME OUT。必须是积极的。
  - getMaxTimeWait
```
public long getMaxTimeWait()
```
    结果
    
    等待防止TIME OUT的最大延迟
  - getMaxWriteDelay
```
public long getMaxWriteDelay()
```
    结果
    
    maxWriteDelay
  - setMaxWriteDelay
```
public void setMaxWriteDelay(long maxWriteDelay)
```
    请注意，更改将被视为尽力而为，这意味着所有已计划的流量都不会改变，但仅适用于新的流量。
    
    所以这种方法的预期用法不是太频繁地使用，因此对于流量整形配置。
    
    参数
    
    maxWriteDelay - 设置写入暂停之前允许的缓冲区中的最大写入延迟（以毫秒为单位）。必须是积极的。
  - getMaxWriteSize
```
public long getMaxWriteSize()
```
    结果
    
    maxWriteSize默认是字节。
  - setMaxWriteSize
```
public void setMaxWriteSize(long maxWriteSize)
```
    请注意，此限制是防止内存不足异常的最佳内存限制。为了确保它的正常工作，生成写入的处理程序应该使用Netty提供的一种方式来处理容量：
    
    - Channel.isWritable()财产和相应的channelWritabilityChanged()
    
    - ChannelFuture.addListener(new GenericFutureListener())
    
    参数
    
    maxWriteSize - 设置写入挂起前每个通道缓冲区中允许的最大写入大小，默认值为字节。
  - doAccounting
```
protected void doAccounting(TrafficCounter counter)
```
    每次从TrafficCounters计算会计时调用。这个方法可以用来实现几乎实时的会计。
    
    参数
    
    counter - 计算其性能的 counter
  - channelRead
```
public void channelRead(ChannelHandlerContext ctx,
                        java.lang.Object msg)
                 throws java.lang.Exception
```
    从类复制的描述： ChannelInboundHandlerAdapter
    
    致电ChannelHandlerContext.fireChannelRead(Object)转发到ChannelPipeline中的下一个ChannelInboundHandler 。子类可以重写此方法来更改行为。
    
    Specified by:
    
    channelRead在界面 ChannelInboundHandler
    
    重写：
    
    channelRead在课堂上 ChannelInboundHandlerAdapter
    
    异常
    
    java.lang.Exception
  - isHandlerActive
```
protected static boolean isHandlerActive(ChannelHandlerContext ctx)
```
  - read
```
public void read(ChannelHandlerContext ctx)
```
    从类复制的描述： ChannelDuplexHandler
    
    致电ChannelHandlerContext.read()转发到ChannelPipeline中的下一个ChannelOutboundHandler 。子类可以重写此方法来更改行为。
    
    Specified by:
    
    read在界面 ChannelOutboundHandler
    
    重写：
    
    read在课堂上 ChannelDuplexHandler
  - write
```
public void write(ChannelHandlerContext ctx,
                  java.lang.Object msg,
                  ChannelPromise promise)
           throws java.lang.Exception
```
    从类复制的描述： ChannelDuplexHandler
    
    致电ChannelOutboundInvoker.write(Object, ChannelPromise)转发到ChannelPipeline中的下一个ChannelOutboundHandler 。子类可以重写此方法来更改行为。
    
    Specified by:
    
    write ，界面 ChannelOutboundHandler
    
    重写：
    
    write在课堂上 ChannelDuplexHandler
    
    参数
    
    ctx - 写入操作的ChannelHandlerContext
    
    msg - 写信息
    
    promise - 在操作完成后通知ChannelPromise
    
    异常
    
    java.lang.Exception - 发生错误时抛出
  - submitWrite
```
@Deprecated
protected void submitWrite(ChannelHandlerContext ctx,
                                       java.lang.Object msg,
                                       long delay,
                                       ChannelPromise promise)
```
    已过时。
  - channelRegistered
```
public void channelRegistered(ChannelHandlerContext ctx)
                       throws java.lang.Exception
```
    从类复制的描述： ChannelInboundHandlerAdapter
    
    致电ChannelHandlerContext.fireChannelRegistered()转发到ChannelPipeline中的下一个ChannelInboundHandler 。子类可以重写此方法来更改行为。
    
    Specified by:
    
    channelRegistered在界面 ChannelInboundHandler
    
    重写：
    
    channelRegistered在课堂上 ChannelInboundHandlerAdapter
    
    异常
    
    java.lang.Exception
  - trafficCounter
```
public TrafficCounter trafficCounter()
```
    结果
    
    当前TrafficCounter（如果通道仍然连接）
  - toString
```
public java.lang.String toString()
```
    重写：
    
    toString在课堂上 java.lang.Object
  - calculateSize
```
protected long calculateSize(java.lang.Object msg)
```
    计算给定的Object的大小。该实现支持ByteBuf和ByteBufHolder 。子类可以覆盖这个。
    
    参数
    
    msg - 应该计算大小的信息。
    
    结果
    
    尺寸大小的味精或 -1如果未知。

Class AbstractTrafficShapingHandler

Nested Class Summary

Nested classes/interfaces inherited from interface io.netty.channel.ChannelHandler

Field Summary

构造方法摘要

方法摘要

Methods inherited from class io.netty.channel.ChannelDuplexHandler

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter

Methods inherited from class io.netty.channel.ChannelHandlerAdapter

Methods inherited from class java.lang.Object

Methods inherited from interface io.netty.channel.ChannelHandler

字段详细信息

DEFAULT_CHECK_INTERVAL

DEFAULT_MAX_TIME

trafficCounter

maxTime

checkInterval

构造方法详细信息

AbstractTrafficShapingHandler

AbstractTrafficShapingHandler

AbstractTrafficShapingHandler

AbstractTrafficShapingHandler

AbstractTrafficShapingHandler

方法详细信息

userDefinedWritabilityIndex

configure

configure

configure

getWriteLimit

setWriteLimit

getReadLimit

setReadLimit

getCheckInterval

setCheckInterval

setMaxTimeWait

getMaxTimeWait

getMaxWriteDelay

setMaxWriteDelay

getMaxWriteSize

setMaxWriteSize

doAccounting

channelRead

isHandlerActive

read

write

submitWrite

channelRegistered

trafficCounter

toString

calculateSize