Http2FrameCodec (Netty API Reference (4.1.11.Final))

java.lang.Object
- io.netty.channel.ChannelHandlerAdapter
- - io.netty.channel.ChannelInboundHandlerAdapter
  - - io.netty.channel.ChannelDuplexHandler
    - - io.netty.handler.codec.http2.Http2FrameCodec

All Implemented Interfaces:: ChannelHandler, ChannelInboundHandler, ChannelOutboundHandler

@UnstableApi
public class Http2FrameCodec
extends ChannelDuplexHandler

An HTTP/2 handler that maps HTTP/2 frames to Http2Frame objects and vice versa. For every incoming HTTP/2 frame a Http2Frame object is created and propagated via ChannelInboundHandlerAdapter.channelRead(io.netty.channel.ChannelHandlerContext, java.lang.Object). Outbound Http2Frame objects received via write(io.netty.channel.ChannelHandlerContext, java.lang.Object, io.netty.channel.ChannelPromise) are converted to the HTTP/2 wire format.

A change in stream state is propagated through the channel pipeline as a user event via Http2StreamStateEvent objects. When a HTTP/2 stream first becomes active a Http2StreamActiveEvent and when it gets closed a Http2StreamClosedEvent is emitted.

Server-side HTTP to HTTP/2 upgrade is supported in conjunction with Http2ServerUpgradeCodec; the necessary HTTP-to-HTTP/2 conversion is performed automatically.

This API is very immature. The Http2Connection-based API is currently preferred over this API. This API is targeted to eventually replace or reduce the need for the Http2Connection-based API.

Opening and Closing Streams

When the remote side opens a new stream, the frame codec first emits a Http2StreamActiveEvent with the stream identifier set.

 Http2FrameCodec                                     Http2MultiplexCodec
        +                                                             +
        |         Http2StreamActiveEvent(streamId=3, headers=null)    |
        +------------------------------------------------------------->
        |                                                             |
        |         Http2HeadersFrame(streamId=3)                       |
        +------------------------------------------------------------->
        |                                                             |
        +                                                             +

When a stream is closed either due to a reset frame by the remote side, or due to both sides having sent frames with the END_STREAM flag, then the frame codec emits a Http2StreamClosedEvent.

 Http2FrameCodec                                 Http2MultiplexCodec
        +                                                         +
        |         Http2StreamClosedEvent(streamId=3)              |
        +--------------------------------------------------------->
        |                                                         |
        +                                                         +

When the local side wants to close a stream, it has to write a Http2ResetFrame to which the frame codec will respond to with a Http2StreamClosedEvent.

 Http2FrameCodec                                 Http2MultiplexCodec
        +                                                         +
        |         Http2ResetFrame(streamId=3)                     |
        <---------------------------------------------------------+
        |                                                         |
        |         Http2StreamClosedEvent(streamId=3)              |
        +--------------------------------------------------------->
        |                                                         |
        +                                                         +

Opening an outbound/local stream works by first sending the frame codec a Http2HeadersFrame with no stream identifier set (such that Http2CodecUtil.isStreamIdValid(int) returns false). If opening the stream was successful, the frame codec responds with a Http2StreamActiveEvent that contains the stream's new identifier as well as the same Http2HeadersFrame object that opened the stream.

 Http2FrameCodec                                                                  Http2MultiplexCodec
        +                                                                                               +
        |         Http2HeadersFrame(streamId=-1)                                                        |
        <-----------------------------------------------------------------------------------------------+
        |                                                                                               |
        |         Http2StreamActiveEvent(streamId=2, headers=Http2HeadersFrame(streamId=-1))            |
        +----------------------------------------------------------------------------------------------->
        |                                                                                               |
        +                                                                                               +

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

Constructor Summary

Constructors
Constructor and Description
`Http2FrameCodec(boolean server)` Construct a new handler.
`Http2FrameCodec(boolean server, Http2FrameLogger frameLogger)` Construct a new handler.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`exceptionCaught(ChannelHandlerContext ctx, Throwable cause)` Calls `ChannelHandlerContext.fireExceptionCaught(Throwable)` to forward to the next `ChannelHandler` in the `ChannelPipeline`.
`void`	`handlerAdded(ChannelHandlerContext ctx)` Load any dependencies.
`void`	`handlerRemoved(ChannelHandlerContext ctx)` Clean up any dependencies.
`void`	`userEventTriggered(ChannelHandlerContext ctx, Object evt)` Handles the cleartext HTTP upgrade event.
`void`	`write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)` Processes all `Http2Frame`s.

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

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter
channelActive, channelInactive, channelRead, channelReadComplete, channelRegistered, channelUnregistered, channelWritabilityChanged

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

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

- Constructor Detail
  - Http2FrameCodec
```
public Http2FrameCodec(boolean server)
```
    Construct a new handler.
    
    Parameters:
    
    server - true this is a server
  - Http2FrameCodec
```
public Http2FrameCodec(boolean server,
                       Http2FrameLogger frameLogger)
```
    Construct a new handler.
    
    Parameters:
    
    server - true this is a server
- Method Detail
  - handlerAdded
```
public void handlerAdded(ChannelHandlerContext ctx)
                  throws Exception
```
    Load any dependencies.
    
    Specified by:
    
    handlerAdded in interface ChannelHandler
    
    Overrides:
    
    handlerAdded in class ChannelHandlerAdapter
    
    Throws:
    
    Exception
  - handlerRemoved
```
public void handlerRemoved(ChannelHandlerContext ctx)
                    throws Exception
```
    Clean up any dependencies.
    
    Specified by:
    
    handlerRemoved in interface ChannelHandler
    
    Overrides:
    
    handlerRemoved in class ChannelHandlerAdapter
    
    Throws:
    
    Exception
  - userEventTriggered
```
public void userEventTriggered(ChannelHandlerContext ctx,
                               Object evt)
                        throws Exception
```
    Handles the cleartext HTTP upgrade event. If an upgrade occurred, sends a simple response via HTTP/2 on stream 1 (the stream specifically reserved for cleartext HTTP upgrade).
    
    Specified by:
    
    userEventTriggered in interface ChannelInboundHandler
    
    Overrides:
    
    userEventTriggered in class ChannelInboundHandlerAdapter
    
    Throws:
    
    Exception
  - exceptionCaught
```
public void exceptionCaught(ChannelHandlerContext ctx,
                            Throwable cause)
```
    Description copied from class: ChannelInboundHandlerAdapter
    
    Calls ChannelHandlerContext.fireExceptionCaught(Throwable) to forward to the next ChannelHandler in the ChannelPipeline. Sub-classes may override this method to change behavior.
    
    Specified by:
    
    exceptionCaught in interface ChannelHandler
    
    Specified by:
    
    exceptionCaught in interface ChannelInboundHandler
    
    Overrides:
    
    exceptionCaught in class ChannelInboundHandlerAdapter
  - write
```
public void write(ChannelHandlerContext ctx,
                  Object msg,
                  ChannelPromise promise)
```
    Processes all Http2Frames. Http2StreamFrames may only originate in child streams.
    
    Specified by:
    
    write in interface ChannelOutboundHandler
    
    Overrides:
    
    write in class ChannelDuplexHandler
    
    Parameters:
    
    ctx - the ChannelHandlerContext for which the write operation is made
    
    msg - the message to write
    
    promise - the ChannelPromise to notify once the operation completes

Class Http2FrameCodec

Opening and Closing Streams

Nested Class Summary

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

Constructor Summary

Method 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

Constructor Detail

Http2FrameCodec

Http2FrameCodec

Method Detail

handlerAdded

handlerRemoved

userEventTriggered

exceptionCaught

write