import io.netty.handler.codec.http2.HttpToHttp2ConnectionHandler; //导入依赖的package包/类
@Override
public void initChannel(SocketChannel ch) throws Exception {
    final Http2Connection connection = new DefaultHttp2Connection(false);
    final Http2FrameWriter frameWriter = frameWriter();
    connectionHandler = new HttpToHttp2ConnectionHandler(connection,
            frameReader(),
            frameWriter,
            new DelegatingDecompressorFrameListener(connection,
                    new InboundHttp2ToHttpAdapter.Builder(connection)
                            .maxContentLength(maxContentLength)
                            .propagateSettings(true)
                            .build()));
    responseHandler = new HttpResponseHandler();
    settingsHandler = new Http2SettingsHandler(ch.newPromise());
    configureClearText(ch);
}
 

import io.netty.handler.codec.http2.HttpToHttp2ConnectionHandler; //导入依赖的package包/类
@Override
public void initChannel(SocketChannel ch) throws Exception {
    final Http2Connection connection = new DefaultHttp2Connection(false);

    connectionHandler = new HttpToHttp2ConnectionHandler(connection,
            frameReader(),
            frameWriter(),
            new DelegatingDecompressorFrameListener(connection,
                    new InboundHttp2ToHttpAdapter.Builder(connection)
                            .maxContentLength(maxContentLength)
                            .propagateSettings(true)
                            .build()));
    responseHandler = new HttpResponseHandler();
    settingsHandler = new Http2SettingsHandler(ch.newPromise());
    if (sslCtx != null) {
        configureSsl(ch);
    } else {
        configureClearText(ch);
    }
}
 

import io.netty.handler.codec.http2.HttpToHttp2ConnectionHandler; //导入依赖的package包/类
private Http2ConnectionHandler newHttp2ConnectionHandler(final ChannelPipeline p) {
  DefaultHttp2Connection connection = new DefaultHttp2Connection(true);
  InboundHttp2ToHttpAdapter listener = new InboundHttp2ToHttpAdapterBuilder(connection)
      .propagateSettings(false)
      .validateHttpHeaders(false)
      .maxContentLength(maxContentLength)
      .build();

  HttpToHttp2ConnectionHandler http2handler = new HttpToHttp2ConnectionHandlerBuilder()
      .frameListener(listener)
      .frameLogger(new Http2FrameLogger(LogLevel.DEBUG))
      .connection(connection)
      .build();

  return http2handler;
}
 

import io.netty.handler.codec.http2.HttpToHttp2ConnectionHandler; //导入依赖的package包/类
@BeforeClass
public static void setUp() throws IOException, URISyntaxException,
    TimeoutException {
  CLUSTER = new MiniDFSCluster.Builder(CONF).numDataNodes(1).build();
  CLUSTER.waitActive();

  RESPONSE_HANDLER = new Http2ResponseHandler();
  Bootstrap bootstrap =
      new Bootstrap()
          .group(WORKER_GROUP)
          .channel(NioSocketChannel.class)
          .remoteAddress("127.0.0.1",
            CLUSTER.getDataNodes().get(0).getInfoPort())
          .handler(new ChannelInitializer<Channel>() {

            @Override
            protected void initChannel(Channel ch) throws Exception {
              Http2Connection connection = new DefaultHttp2Connection(false);
              Http2ConnectionHandler connectionHandler =
                  new HttpToHttp2ConnectionHandler(connection, frameReader(),
                      frameWriter(), new DelegatingDecompressorFrameListener(
                          connection, new InboundHttp2ToHttpAdapter.Builder(
                              connection).maxContentLength(Integer.MAX_VALUE)
                              .propagateSettings(true).build()));
              ch.pipeline().addLast(connectionHandler, RESPONSE_HANDLER);
            }
          });
  CHANNEL = bootstrap.connect().syncUninterruptibly().channel();

}
 

import io.netty.handler.codec.http2.HttpToHttp2ConnectionHandler; //导入依赖的package包/类
@Override
public void initChannel(SocketChannel ch) throws Exception {
    final ChannelPipeline p = ch.pipeline();
    final Http2Connection conn = new DefaultHttp2Connection(false);
    final HttpToHttp2ConnectionHandler connHandler = new HttpToHttp2ConnectionHandlerBuilder()
            .connection(conn)
            .frameListener(new DelegatingDecompressorFrameListener(
                    conn,
                    new InboundHttp2ToHttpAdapterBuilder(conn)
                            .maxContentLength(Integer.MAX_VALUE)
                            .propagateSettings(true).build()))
            .build();

    clientHandler = new THttp2ClientHandler(ch.eventLoop());

    if (sslCtx != null) {
        p.addLast(sslCtx.newHandler(p.channel().alloc()));
        p.addLast(connHandler);
        configureEndOfPipeline(p);
    } else {
        Http1ClientCodec sourceCodec = new Http1ClientCodec();
        HttpClientUpgradeHandler upgradeHandler = new HttpClientUpgradeHandler(
                sourceCodec, new Http2ClientUpgradeCodec(connHandler), 65536);

        p.addLast(sourceCodec, upgradeHandler, new UpgradeRequestHandler());
    }
}
 

import io.netty.handler.codec.http2.HttpToHttp2ConnectionHandler; //导入依赖的package包/类
public NettyPush(final ChannelHandlerContext ctx, final int streamId, final String authority,
    final String scheme) {
  this.ctx = ctx;
  HttpToHttp2ConnectionHandler handler = ctx.pipeline().get(HttpToHttp2ConnectionHandler.class);
  this.encoder = handler.encoder();
  this.streamId = streamId;
  this.authority = authority;
  this.scheme = scheme;
}