ProxyConnection (Zodiac Server Proxy 1.3.9 API)

java.lang.Object
- io.netty.channel.ChannelHandlerAdapter
- - io.netty.channel.ChannelInboundHandlerAdapter
 - - io.netty.channel.SimpleChannelInboundHandler
 - - org.zodiac.server.proxy.impl.ProxyConnection

类型参数:

I - the type of "initial" message. This will be either HttpResponse or HttpRequest.

所有已实现的接口:

ChannelHandler, ChannelInboundHandler

直接已知子类:

HttpProxyConnection
```
public abstract class ProxyConnection
extends SimpleChannelInboundHandler
```
Base class for objects that represent a connection to/from our proxy.

A ProxyConnection models a bidirectional message flow on top of a Netty Channel.

The readProxyIncoming(Object) method is called whenever a new message arrives on the underlying socket.

The writeToChannel(Object) method can be called by anyone wanting to write data out of the connection.

ProxyConnection has a lifecycle and its current state within that lifecycle is recorded as a ConnectionState. The allowed states and transitions vary a little depending on the concrete implementation of ProxyConnection. However, all ProxyConnections share the following lifecycle events:
- connected() - Once the underlying channel is active, the ProxyConnection is considered connected and moves into ConnectionState.AWAITING_INITIAL. The Channel is recorded at this time for later referencing.
- disconnected() - When the underlying channel goes inactive, the ProxyConnection moves into ConnectionState.DISCONNECTED
- becameWritable() - When the underlying channel becomes writeable, this callback is invoked.
By default, incoming data on the underlying channel is automatically read and passed to the readProxyIncoming(Object) method. Reading can be stopped and resumed using stopReading() and resumeReading().

嵌套类概要

嵌套类
限定符和类型	类和说明
`protected class`	`ProxyConnection.RequestReadMonitor` Utility handler for monitoring requests read on this connection.
`protected class`	`ProxyConnection.ResponseReadMonitor` Utility handler for monitoring responses read on this connection.

从接口继承的嵌套类/接口 io.netty.channel.ChannelHandler
ChannelHandler.Sharable

字段概要

字段
限定符和类型	字段和说明
`private String`	`applicationName`
`protected Channel`	`channel`
`protected ChannelHandlerContext`	`ctx`
`private ConnectionState`	`currentState`
`protected long`	`lastReadTime`
`protected ProxyConnectionLogger`	`log`
`protected org.slf4j.Logger`	`logger`
`protected ProxyManager`	`proxyManager`
`protected SSLEngine`	`sslEngine` If using encryption, this holds our `SSLEngine`.

构造器概要

构造器
限定符	构造器和说明
`protected`	`ProxyConnection(ConnectionState initialState, ProxyManager proxyServer, String applicationName)` Construct a new ProxyConnection.

方法概要

所有方法实例方法抽象方法具体方法
限定符和类型	方法和说明
`protected void`	`becameSaturated()` Callback that's invoked if this connection becomes saturated.
`protected void`	`becameWritable()` Callback that's invoked when this connection becomes writeable again.
`protected void`	`become(ConnectionState state)` Udpates the current state to the given value.
`void`	`channelActive(ChannelHandlerContext ctx)` Only once the Netty Channel is active to we recognize the ProxyConnection as connected.
`void`	`channelInactive(ChannelHandlerContext ctx)` As soon as the Netty Channel is inactive, we recognize the ProxyConnection as disconnected.
`protected void`	`channelRead0(ChannelHandlerContext ctx, Object msg)` Adapting the Netty API
`void`	`channelRegistered(ChannelHandlerContext ctx)`
`protected void`	`channelRegistered0(ChannelHandlerContext ctx)`
`void`	`channelWritabilityChanged(ChannelHandlerContext ctx)`
`private void`	`closeChannel(io.netty.util.concurrent.Promise<Void> promise)`
`protected void`	`connected()` This method is called as soon as the underlying `Channel` is connected.
`(专用程序包) io.netty.util.concurrent.Future<Void>`	`disconnect()` Disconnects.
`protected void`	`disconnected()` This method is called as soon as the underlying `Channel` becomes disconnected.
`protected io.netty.util.concurrent.Future<Channel>`	`encrypt(ChannelPipeline pipeline, SSLEngine sslEngine)` Encrypts traffic on this connection with SSL/TLS.
`protected io.netty.util.concurrent.Future<Channel>`	`encrypt(SSLEngine sslEngine)` Encrypts traffic on this connection with SSL/TLS.
`void`	`exceptionCaught(ChannelHandlerContext ctx, Throwable cause)`
`protected void`	`exceptionCaught(Throwable cause)` Override this to handle exceptions that occurred during asynchronous processing on the `Channel`.
`protected String`	`getApplicationName()`
`Channel`	`getChannel()`
`protected ConnectionState`	`getCurrentState()`
`(专用程序包) ProxyConnectionLogger`	`getLOG()`
`SSLEngine`	`getSslEngine()`
`protected boolean`	`is(ConnectionState state)` Utility for checking current state.
`protected boolean`	`isConnecting()` If this connection is currently in the process of going through a `ConnectionFlow`, this will return true.
`protected boolean`	`isSaturated()` Indicates whether or not this connection is saturated (i.e. not writeable).
`protected void`	`readIncoming(ChannelHandlerContext ctx, Object msg)` Read is invoked automatically by Netty as messages arrive on the socket.
`protected abstract void`	`readProxyIncoming(Object msg)`
`protected void`	`resumeReading()` Call this to resume reading.
`protected void`	`stopReading()` Call this to stop reading.
`protected void`	`timedOut()` This method is called when the underlying `Channel` times out due to an idle timeout.
`void`	`userEventTriggered(ChannelHandlerContext ctx, Object evt)` We're looking for `IdleStateEvent`s to see if we need to disconnect.
`protected void`	`writeRaw(io.netty.buffer.ByteBuf buf)` Writes raw buffers to the connection.
`protected ChannelFuture`	`writeToChannel(Object msg)`

从类继承的方法 io.netty.channel.SimpleChannelInboundHandler
acceptInboundMessage, channelRead

从类继承的方法 io.netty.channel.ChannelInboundHandlerAdapter
channelReadComplete, channelUnregistered

从类继承的方法 io.netty.channel.ChannelHandlerAdapter
ensureNotSharable, handlerAdded, handlerRemoved, isSharable

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 io.netty.channel.ChannelHandler
handlerAdded, handlerRemoved

- 字段详细资料
 - log
```
protected final ProxyConnectionLogger log
```
 - logger
```
protected org.slf4j.Logger logger
```
 - proxyManager
```
protected final ProxyManager proxyManager
```
 - ctx
```
protected volatile ChannelHandlerContext ctx
```
 - channel
```
protected volatile Channel channel
```
 - currentState
```
private volatile ConnectionState currentState
```
 - lastReadTime
```
protected volatile long lastReadTime
```
 - sslEngine
```
protected volatile SSLEngine sslEngine
```
 If using encryption, this holds our SSLEngine.
 - applicationName
```
private final String applicationName
```
- 构造器详细资料
 - ProxyConnection
```
protected ProxyConnection(ConnectionState initialState,
 ProxyManager proxyServer,
 String applicationName)
```
 Construct a new ProxyConnection.
 
 参数:
 
 initialState - the state in which this connection starts out
 
 proxyServer - the ProxyManager in which we're running
 
 applicationName - the application name in which we're running
- 方法详细资料
 - readIncoming
```
protected void readIncoming(ChannelHandlerContext ctx,
 Object msg)
```
 Read is invoked automatically by Netty as messages arrive on the socket.
 
 参数:
 
 ctx - handler context
 
 msg - message
 - readProxyIncoming
```
protected abstract void readProxyIncoming(Object msg)
```
 - writeRaw
```
protected void writeRaw(io.netty.buffer.ByteBuf buf)
```
 Writes raw buffers to the connection.
 
 参数:
 
 buf - byte buffer
 - writeToChannel
```
protected ChannelFuture writeToChannel(Object msg)
```
 - connected
```
protected void connected()
```
 This method is called as soon as the underlying Channel is connected. Note that for proxies with complex ConnectionFlows that include SSL handshaking and other such things, just because the Channel is connected doesn't mean that our connection is fully established.
 - disconnected
```
protected void disconnected()
```
 This method is called as soon as the underlying Channel becomes disconnected.
 - timedOut
```
protected void timedOut()
```
 This method is called when the underlying Channel times out due to an idle timeout.
 - encrypt
```
protected io.netty.util.concurrent.Future<Channel> encrypt(SSLEngine sslEngine)
```
 Encrypts traffic on this connection with SSL/TLS.
 
 参数:
 
 sslEngine - the SSLEngine for doing the encryption
 
 返回:
 
 a Future for when the SSL handshake has completed
 - encrypt
```
protected io.netty.util.concurrent.Future<Channel> encrypt(ChannelPipeline pipeline,
 SSLEngine sslEngine)
```
 Encrypts traffic on this connection with SSL/TLS.
 
 参数:
 
 pipeline - the ChannelPipeline on which to enable encryption
 
 sslEngine - the SSLEngine for doing the encryption
 
 返回:
 
 a Future for when the SSL handshake has completed
 - becameSaturated
```
protected void becameSaturated()
```
 Callback that's invoked if this connection becomes saturated.
 - becameWritable
```
protected void becameWritable()
```
 Callback that's invoked when this connection becomes writeable again.
 - exceptionCaught
```
protected void exceptionCaught(Throwable cause)
```
 Override this to handle exceptions that occurred during asynchronous processing on the Channel.
 
 参数:
 
 cause - error
 - disconnect
```
io.netty.util.concurrent.Future<Void> disconnect()
```
 Disconnects. This will wait for pending writes to be flushed before disconnecting.
 
 返回:
 
 Future for when we're done disconnecting. If we weren't connected, this returns null.
 - closeChannel
```
private void closeChannel(io.netty.util.concurrent.Promise<Void> promise)
```
 - isSaturated
```
protected boolean isSaturated()
```
 Indicates whether or not this connection is saturated (i.e. not writeable).
 
 返回:
 
 saturated ot not
 - is
```
protected boolean is(ConnectionState state)
```
 Utility for checking current state.
 
 参数:
 
 state - connection state
 
 返回:
 
 be specified state or not
 - isConnecting
```
protected boolean isConnecting()
```
 If this connection is currently in the process of going through a ConnectionFlow, this will return true.
 
 返回:
 
 connecting or not
 - become
```
protected void become(ConnectionState state)
```
 Udpates the current state to the given value.
 
 参数:
 
 state - connection state
 - getCurrentState
```
protected ConnectionState getCurrentState()
```
 - getSslEngine
```
public SSLEngine getSslEngine()
```
 - stopReading
```
protected void stopReading()
```
 Call this to stop reading.
 - resumeReading
```
protected void resumeReading()
```
 Call this to resume reading.
 - getLOG
```
ProxyConnectionLogger getLOG()
```
 - channelRead0
```
protected void channelRead0(ChannelHandlerContext ctx,
 Object msg)
 throws Exception
```
 Adapting the Netty API
 
 指定者:
 
 channelRead0 在类中 SimpleChannelInboundHandler
 
 抛出:
 
 Exception
 - channelRegistered
```
public final void channelRegistered(ChannelHandlerContext ctx)
 throws Exception
```
 指定者:
 
 channelRegistered 在接口中 ChannelInboundHandler
 
 覆盖:
 
 channelRegistered 在类中 ChannelInboundHandlerAdapter
 
 抛出:
 
 Exception
 - channelRegistered0
```
protected final void channelRegistered0(ChannelHandlerContext ctx)
 throws Exception
```
 抛出:
 
 Exception
 - channelActive
```
public final void channelActive(ChannelHandlerContext ctx)
 throws Exception
```
 Only once the Netty Channel is active to we recognize the ProxyConnection as connected.
 
 指定者:
 
 channelActive 在接口中 ChannelInboundHandler
 
 覆盖:
 
 channelActive 在类中 ChannelInboundHandlerAdapter
 
 抛出:
 
 Exception
 - channelInactive
```
public final void channelInactive(ChannelHandlerContext ctx)
 throws Exception
```
 As soon as the Netty Channel is inactive, we recognize the ProxyConnection as disconnected.
 
 指定者:
 
 channelInactive 在接口中 ChannelInboundHandler
 
 覆盖:
 
 channelInactive 在类中 ChannelInboundHandlerAdapter
 
 抛出:
 
 Exception
 - channelWritabilityChanged
```
public final void channelWritabilityChanged(ChannelHandlerContext ctx)
 throws Exception
```
 指定者:
 
 channelWritabilityChanged 在接口中 ChannelInboundHandler
 
 覆盖:
 
 channelWritabilityChanged 在类中 ChannelInboundHandlerAdapter
 
 抛出:
 
 Exception
 - exceptionCaught
```
public final void exceptionCaught(ChannelHandlerContext ctx,
 Throwable cause)
 throws Exception
```
 指定者:
 
 exceptionCaught 在接口中 ChannelHandler
 
 指定者:
 
 exceptionCaught 在接口中 ChannelInboundHandler
 
 覆盖:
 
 exceptionCaught 在类中 ChannelInboundHandlerAdapter
 
 抛出:
 
 Exception
 - userEventTriggered
```
public void userEventTriggered(ChannelHandlerContext ctx,
 Object evt)
 throws Exception
```
 We're looking for IdleStateEvents to see if we need to disconnect.
 
 Note - we don't care what kind of IdleState we got. Thanks to qbast for pointing this out.
 
 指定者:
 
 userEventTriggered 在接口中 ChannelInboundHandler
 
 覆盖:
 
 userEventTriggered 在类中 ChannelInboundHandlerAdapter
 
 抛出:
 
 Exception
 - getChannel
```
public Channel getChannel()
```
 - getApplicationName
```
protected String getApplicationName()
```

类 ProxyConnection<I>

嵌套类概要

从接口继承的嵌套类/接口 io.netty.channel.ChannelHandler

字段概要

构造器概要

方法概要

从类继承的方法 io.netty.channel.SimpleChannelInboundHandler

从类继承的方法 io.netty.channel.ChannelInboundHandlerAdapter

从类继承的方法 io.netty.channel.ChannelHandlerAdapter

从类继承的方法 java.lang.Object

从接口继承的方法 io.netty.channel.ChannelHandler

字段详细资料

log

logger

proxyManager

ctx

channel

currentState

lastReadTime

sslEngine

applicationName

构造器详细资料

ProxyConnection

方法详细资料

readIncoming

readProxyIncoming

writeRaw

writeToChannel

connected

disconnected

timedOut

encrypt

encrypt

becameSaturated

becameWritable

exceptionCaught

disconnect

closeChannel

isSaturated

is

isConnecting

become

getCurrentState

getSslEngine

stopReading

resumeReading

getLOG

channelRead0

channelRegistered

channelRegistered0

channelActive

channelInactive

channelWritabilityChanged

exceptionCaught

userEventTriggered

getChannel

getApplicationName