HttpProxyConnection (Zodiac Server Proxy 1.3.12 API)

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

类型参数:

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

所有已实现的接口:

ChannelHandler, ChannelInboundHandler

直接已知子类:

ClientToProxyConnection, ProxyToServerConnection
```
public abstract class HttpProxyConnection<I extends io.netty.handler.codec.http.HttpObject>
extends ProxyConnection<Object>
```
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`	`HttpProxyConnection.RequestReadMonitor` Utility handler for monitoring requests read on this connection.
`protected class`	`HttpProxyConnection.RequestWrittenMonitor` Utility handler for monitoring requests written on this connection.
`protected class`	`HttpProxyConnection.ResponseReadMonitor` Utility handler for monitoring responses read on this connection.
`protected class`	`HttpProxyConnection.ResponseWrittenMonitor` Utility handler for monitoring responses written on this connection.

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

字段概要

字段
限定符和类型字段和说明

protected ProxyConnectionLogger log

protected HttpProxyManager proxyManager
- 从类继承的字段 org.zodiac.server.proxy.impl.ProxyConnection
  channel, ctx, lastReadTime, logger, sslEngine

字段
限定符和类型	字段和说明
`protected ProxyConnectionLogger`	`log`
`protected HttpProxyManager`	`proxyManager`

构造器概要

构造器
限定符	构造器和说明
`protected`	`HttpProxyConnection(ConnectionState initialState, HttpProxyManager proxyManager, 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.
`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.
`(专用程序包) void`	`doWrite(Object msg)`
`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.
`protected void`	`exceptionCaught(Throwable cause)` Override this to handle exceptions that occurred during asynchronous processing on the `Channel`.
`protected HttpFilters`	`getHttpFiltersFromProxyServer(io.netty.handler.codec.http.HttpRequest httpRequest)` Request the ProxyServer for Filters.
`(专用程序包) ProxyConnectionLogger`	`getLOG()`
`SSLEngine`	`getSslEngine()`
`protected boolean`	`isSaturated()` Indicates whether or not this connection is saturated (i.e. not writeable).
`private void`	`readHTTP(io.netty.handler.codec.http.HttpObject httpObject)` Handles reading `HttpObject`.
`protected abstract void`	`readHTTPChunk(io.netty.handler.codec.http.HttpContent chunk)` Implement this to handle reading a chunk in a chunked transfer.
`protected abstract ConnectionState`	`readHTTPInitial(I httpObject)` Implement this to handle reading the initial object (e.g.
`protected void`	`readProxyIncoming(Object msg)` Reading
`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`	`write(Object msg)` This method is called by users of the ProxyConnection to send stuff out over the socket.
`protected void`	`writeHttp(io.netty.handler.codec.http.HttpObject httpObject)` Writes HttpObjects to the connection asynchronously.
`protected void`	`writeRaw(io.netty.buffer.ByteBuf buf)` Writes raw buffers to the connection.
`protected ChannelFuture`	`writeToChannel(Object msg)`
`protected ChannelFuture`	`writeToChannelNoFlush(Object msg)`

从类继承的方法 org.zodiac.server.proxy.impl.ProxyConnection
become, channelActive, channelInactive, channelRead0, channelRegistered, channelRegistered0, channelWritabilityChanged, exceptionCaught, getApplicationName, getChannel, getCurrentState, is, isConnecting, readIncoming, userEventTriggered

从类继承的方法 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
```
  - proxyManager
```
protected final HttpProxyManager proxyManager
```
- 构造器详细资料
  - HttpProxyConnection
```
protected HttpProxyConnection(ConnectionState initialState,
                              HttpProxyManager proxyManager,
                              String applicationName)
```
    Construct a new ProxyConnection.
    
    参数:
    
    initialState - the state in which this connection starts out
    
    proxyManager - the HttpProxyManager in which we're running
    
    applicationName - the application name in which we're running
- 方法详细资料
  - readProxyIncoming
```
protected void readProxyIncoming(Object msg)
```
    Reading
    
    指定者:
    
    readProxyIncoming 在类中 ProxyConnection<Object>
  - readHTTP
```
private void readHTTP(io.netty.handler.codec.http.HttpObject httpObject)
```
    Handles reading HttpObject.
    
    参数:
    
    httpObject - http object
  - readHTTPInitial
```
protected abstract ConnectionState readHTTPInitial(I httpObject)
```
    Implement this to handle reading the initial object (e.g. HttpRequest or HttpResponse).
    
    参数:
    
    httpObject - http object
    
    返回:
    
    connection state
  - readHTTPChunk
```
protected abstract void readHTTPChunk(io.netty.handler.codec.http.HttpContent chunk)
```
    Implement this to handle reading a chunk in a chunked transfer.
    
    参数:
    
    chunk - http content
  - write
```
void write(Object msg)
```
    This method is called by users of the ProxyConnection to send stuff out over the socket.
    
    参数:
    
    msg - message
  - doWrite
```
void doWrite(Object msg)
```
  - writeHttp
```
protected void writeHttp(io.netty.handler.codec.http.HttpObject httpObject)
```
    Writes HttpObjects to the connection asynchronously.
    
    参数:
    
    httpObject - http bject
  - writeRaw
```
protected void writeRaw(io.netty.buffer.ByteBuf buf)
```
    Writes raw buffers to the connection.
    
    覆盖:
    
    writeRaw 在类中 ProxyConnection<Object>
    
    参数:
    
    buf - byte buffer
  - writeToChannel
```
protected ChannelFuture writeToChannel(Object msg)
```
    覆盖:
    
    writeToChannel 在类中 ProxyConnection<Object>
  - writeToChannelNoFlush
```
protected ChannelFuture writeToChannelNoFlush(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.
    
    覆盖:
    
    connected 在类中 ProxyConnection<Object>
  - disconnected
```
protected void disconnected()
```
    This method is called as soon as the underlying Channel becomes disconnected.
    
    覆盖:
    
    disconnected 在类中 ProxyConnection<Object>
  - timedOut
```
protected void timedOut()
```
    This method is called when the underlying Channel times out due to an idle timeout.
    
    覆盖:
    
    timedOut 在类中 ProxyConnection<Object>
  - encrypt
```
protected io.netty.util.concurrent.Future<Channel> encrypt(SSLEngine sslEngine)
```
    Encrypts traffic on this connection with SSL/TLS.
    
    覆盖:
    
    encrypt 在类中 ProxyConnection<Object>
    
    参数:
    
    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.
    
    覆盖:
    
    encrypt 在类中 ProxyConnection<Object>
    
    参数:
    
    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.
    
    覆盖:
    
    becameSaturated 在类中 ProxyConnection<Object>
  - becameWritable
```
protected void becameWritable()
```
    Callback that's invoked when this connection becomes writeable again.
    
    覆盖:
    
    becameWritable 在类中 ProxyConnection<Object>
  - exceptionCaught
```
protected void exceptionCaught(Throwable cause)
```
    Override this to handle exceptions that occurred during asynchronous processing on the Channel.
    
    覆盖:
    
    exceptionCaught 在类中 ProxyConnection<Object>
    
    参数:
    
    cause - raised error
  - disconnect
```
io.netty.util.concurrent.Future<Void> disconnect()
```
    Disconnects. This will wait for pending writes to be flushed before disconnecting.
    
    覆盖:
    
    disconnect 在类中 ProxyConnection<Object>
    
    返回:
    
    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).
    
    覆盖:
    
    isSaturated 在类中 ProxyConnection<Object>
    
    返回:
    
    saturated or not
  - getSslEngine
```
public SSLEngine getSslEngine()
```
    覆盖:
    
    getSslEngine 在类中 ProxyConnection<Object>
  - stopReading
```
protected void stopReading()
```
    Call this to stop reading.
    
    覆盖:
    
    stopReading 在类中 ProxyConnection<Object>
  - resumeReading
```
protected void resumeReading()
```
    Call this to resume reading.
    
    覆盖:
    
    resumeReading 在类中 ProxyConnection<Object>
  - getHttpFiltersFromProxyServer
```
protected HttpFilters getHttpFiltersFromProxyServer(io.netty.handler.codec.http.HttpRequest httpRequest)
```
    Request the ProxyServer for Filters. By default, no-op filters are returned by DefaultHttpProxyServer. Subclasses of ProxyConnection can change this behaviour.
    
    参数:
    
    httpRequest - Filter attached to the give HttpRequest (if any)
    
    返回:
    
    filters
  - getLOG
```
ProxyConnectionLogger getLOG()
```
    覆盖:
    
    getLOG 在类中 ProxyConnection<Object>

类 HttpProxyConnection<I extends io.netty.handler.codec.http.HttpObject>

嵌套类概要

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

字段概要

从类继承的字段 org.zodiac.server.proxy.impl.ProxyConnection

构造器概要

方法概要

从类继承的方法 org.zodiac.server.proxy.impl.ProxyConnection

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

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

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

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

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

字段详细资料

log

proxyManager

构造器详细资料

HttpProxyConnection

方法详细资料

readProxyIncoming

readHTTP

readHTTPInitial

readHTTPChunk

write

doWrite

writeHttp

writeRaw

writeToChannel

writeToChannelNoFlush

connected

disconnected

timedOut

encrypt

encrypt

becameSaturated

becameWritable

exceptionCaught

disconnect

closeChannel

isSaturated

getSslEngine

stopReading

resumeReading

getHttpFiltersFromProxyServer

getLOG