Class HTTP2Client

java.lang.Object
org.eclipse.jetty.util.component.AbstractLifeCycle
org.eclipse.jetty.util.component.ContainerLifeCycle
org.eclipse.jetty.http2.client.HTTP2Client
All Implemented Interfaces:
AutoCloseable, Container, Destroyable, Dumpable, Dumpable.DumpableContainer, LifeCycle
@ManagedObject public class HTTP2Client extends ContainerLifeCycle implements AutoCloseable

HTTP2Client provides an asynchronous, non-blocking implementation to send HTTP/2 frames to a server.

Typical usage:

 
 // Create and start HTTP2Client.
 HTTP2Client http2Client = new HTTP2Client();
 http2Client.start();
 SslContextFactory sslContextFactory = http2Client.getClientConnector().getSslContextFactory();

 // Connect to host.
 String host = "webtide.com";
 int port = 443;

 CompletableFuture<Session> sessionPromise = http2Client.connect(sslContextFactory, new InetSocketAddress(host, port), new ServerSessionListener() {});

 // Obtain the client-side Session object.
 Session session = sessionPromise.get(5, TimeUnit.SECONDS);

 // Prepare the HTTP request headers.
 HttpFields.Mutable requestFields = HttpFields.build();
 requestFields.put("User-Agent", http2Client.getClass().getName() + "/" + Jetty.VERSION);
 // Prepare the HTTP request object.
 MetaData.Request request = new MetaData.Request("PUT", HttpURI.from("https://" + host + ":" + port + "/"), HttpVersion.HTTP_2, requestFields);
 // Create the HTTP/2 HEADERS frame representing the HTTP request.
 HeadersFrame headersFrame = new HeadersFrame(request, null, false);

 // Prepare the listener to receive the HTTP response frames.
 Stream.Listener responseListener = new Stream.Listener()
 {
      @Override
      public void onHeaders(Stream stream, HeadersFrame frame)
      {
          System.err.println(frame);
      }

      @Override
      public void onData(Stream stream, DataFrame frame, Callback callback)
      {
          System.err.println(frame);
          callback.succeeded();
      }
 };

 // Send the HEADERS frame to create a stream.
 CompletableFuture<Stream> streamPromise = session.newStream(headersFrame, responseListener);
 Stream stream = streamPromise.get(5, TimeUnit.SECONDS);

 // Use the Stream object to send request content, if any, using a DATA frame.
 ByteBuffer content = UTF_8.encode("hello");
 DataFrame requestContent = new DataFrame(stream.getId(), content, true);
 stream.data(requestContent, Callback.NOOP);

 // When done, stop the HTTP2Client.
 http2Client.stop();

  • Field Details

    • CONTEXT_KEY

      public static final String CONTEXT_KEY

    • SESSION_PROMISE_CONTEXT_KEY

      public static final String SESSION_PROMISE_CONTEXT_KEY

    • SESSION_LISTENER_CONTEXT_KEY

      public static final String SESSION_LISTENER_CONTEXT_KEY

  • Constructor Details

    • HTTP2Client

      public HTTP2Client()

    • HTTP2Client

      public HTTP2Client(ClientConnector connector)

  • Method Details

    • getClientConnector

      public ClientConnector getClientConnector()

    • getExecutor

      public Executor getExecutor()

    • setExecutor

      public void setExecutor(Executor executor)

    • getScheduler

      public Scheduler getScheduler()

    • setScheduler

      public void setScheduler(Scheduler scheduler)

    • getByteBufferPool

      public ByteBufferPool getByteBufferPool()

    • setByteBufferPool

      public void setByteBufferPool(ByteBufferPool bufferPool)

    • getFlowControlStrategyFactory

      public FlowControlStrategy.Factory getFlowControlStrategyFactory()

    • setFlowControlStrategyFactory

      public void setFlowControlStrategyFactory(FlowControlStrategy.Factory flowControlStrategyFactory)

    • getSelectors

      @ManagedAttribute("The number of selectors") public int getSelectors()

    • setSelectors

      public void setSelectors(int selectors)

    • getIdleTimeout

      @ManagedAttribute("The idle timeout in milliseconds") public long getIdleTimeout()

    • setIdleTimeout

      public void setIdleTimeout(long idleTimeout)

    • getStreamIdleTimeout

      @ManagedAttribute("The stream idle timeout in milliseconds") public long getStreamIdleTimeout()

    • setStreamIdleTimeout

      public void setStreamIdleTimeout(long streamIdleTimeout)

    • getConnectTimeout

      @ManagedAttribute("The connect timeout in milliseconds") public long getConnectTimeout()

    • setConnectTimeout

      public void setConnectTimeout(long connectTimeout)

    • isConnectBlocking

      @ManagedAttribute("Whether the connect() operation is blocking") public boolean isConnectBlocking()

    • setConnectBlocking

      public void setConnectBlocking(boolean connectBlocking)

    • getBindAddress

      public SocketAddress getBindAddress()

    • setBindAddress

      public void setBindAddress(SocketAddress bindAddress)

    • getInputBufferSize

      @ManagedAttribute("The size of the buffer used to read from the network") public int getInputBufferSize()

    • setInputBufferSize

      public void setInputBufferSize(int inputBufferSize)

    • getApplicationProtocols

      @ManagedAttribute("The ALPN protocol list") public List<String> getApplicationProtocols()

    • setApplicationProtocols

      public void setApplicationProtocols(List<String> protocols)

    • getInitialSessionRecvWindow

      @ManagedAttribute("The initial size of session's flow control receive window") public int getInitialSessionRecvWindow()

    • setInitialSessionRecvWindow

      public void setInitialSessionRecvWindow(int initialSessionRecvWindow)

    • getInitialStreamRecvWindow

      @ManagedAttribute("The initial size of stream's flow control receive window") public int getInitialStreamRecvWindow()

    • setInitialStreamRecvWindow

      public void setInitialStreamRecvWindow(int initialStreamRecvWindow)

    • getMaxFrameSize

      @ManagedAttribute("The max frame size in bytes") public int getMaxFrameSize()

    • setMaxFrameSize

      public void setMaxFrameSize(int maxFrameSize)

    • getMaxConcurrentPushedStreams

      @ManagedAttribute("The max number of concurrent pushed streams") public int getMaxConcurrentPushedStreams()

    • setMaxConcurrentPushedStreams

      public void setMaxConcurrentPushedStreams(int maxConcurrentPushedStreams)

    • getMaxSettingsKeys

      @ManagedAttribute("The max number of keys in all SETTINGS frames") public int getMaxSettingsKeys()

    • setMaxSettingsKeys

      public void setMaxSettingsKeys(int maxSettingsKeys)

    • getMaxEncoderTableCapacity

      @ManagedAttribute("The HPACK encoder dynamic table maximum capacity") public int getMaxEncoderTableCapacity()

    • setMaxEncoderTableCapacity

      public void setMaxEncoderTableCapacity(int maxEncoderTableCapacity)

      Sets the limit for the encoder HPACK dynamic table capacity.

      Setting this value to 0 disables the use of the dynamic table.

      Parameters:
      maxEncoderTableCapacity - The HPACK encoder dynamic table maximum capacity

    • getMaxDecoderTableCapacity

      @ManagedAttribute("The HPACK decoder dynamic table maximum capacity") public int getMaxDecoderTableCapacity()

    • setMaxDecoderTableCapacity

      public void setMaxDecoderTableCapacity(int maxDecoderTableCapacity)

    • getMaxHeaderBlockFragment

      @ManagedAttribute("The max size of header block fragments") public int getMaxHeaderBlockFragment()

    • setMaxHeaderBlockFragment

      public void setMaxHeaderBlockFragment(int maxHeaderBlockFragment)

    • getMaxRequestHeadersSize

      @ManagedAttribute("The max size of request headers") public int getMaxRequestHeadersSize()

    • setMaxRequestHeadersSize

      public void setMaxRequestHeadersSize(int maxRequestHeadersSize)

    • getMaxResponseHeadersSize

      @ManagedAttribute("The max size of response headers") public int getMaxResponseHeadersSize()

    • setMaxResponseHeadersSize

      public void setMaxResponseHeadersSize(int maxResponseHeadersSize)

    • isUseInputDirectByteBuffers

      @ManagedAttribute("Whether to use direct ByteBuffers for reading") public boolean isUseInputDirectByteBuffers()

    • setUseInputDirectByteBuffers

      public void setUseInputDirectByteBuffers(boolean useInputDirectByteBuffers)

    • isUseOutputDirectByteBuffers

      @ManagedAttribute("Whether to use direct ByteBuffers for writing") public boolean isUseOutputDirectByteBuffers()

    • setUseOutputDirectByteBuffers

      public void setUseOutputDirectByteBuffers(boolean useOutputDirectByteBuffers)

    • isUseALPN

      @ManagedAttribute("Whether ALPN should be used when establishing connections") public boolean isUseALPN()

    • setUseALPN

      public void setUseALPN(boolean useALPN)

    • connect

      public CompletableFuture<Session> connect(SocketAddress address, Session.Listener listener)

      Connect for clear-text HTTP/2.

      Parameters:
      address - the address to connect to
      listener - the listener to notify of session events
      Returns:
      a CompletableFuture that is completed when the connect operation is complete

    • connect

      public void connect(SocketAddress address, Session.Listener listener, Promise<Session> promise)

      Connect for clear-text HTTP/2.

      Parameters:
      address - the address to connect to
      listener - the listener to notify of session events
      promise - the Promise that is completed when the connect operation is complete

    • connect

      public CompletableFuture<Session> connect(SslContextFactory.Client sslContextFactory, SocketAddress address, Session.Listener listener)

      Connect for clear-text or secure HTTP/2.

      Parameters:
      sslContextFactory - null for clear-text, non-null for secure HTTP/2
      address - the address to connect to
      listener - the listener to notify of session events
      Returns:
      a CompletableFuture that is completed when the connect operation is complete

    • connect

      public void connect(SslContextFactory.Client sslContextFactory, SocketAddress address, Session.Listener listener, Promise<Session> promise)

      Connect for clear-text or secure HTTP/2.

      Parameters:
      sslContextFactory - null for clear-text, non-null for secure HTTP/2
      address - the address to connect to
      listener - the listener to notify of session events
      promise - the Promise that is completed when the connect operation is complete

    • connect

      public CompletableFuture<Session> connect(Transport transport, SslContextFactory.Client sslContextFactory, SocketAddress address, Session.Listener listener)

      Connect for clear-text or secure HTTP/2 with the specified Transport.

      Parameters:
      transport - the Transport to use
      sslContextFactory - null for clear-text, non-null for secure HTTP/2
      address - the address to connect to
      listener - the listener to notify of session events
      Returns:
      a CompletableFuture that is completed when the connect operation is complete

    • connect

      public void connect(Transport transport, SslContextFactory.Client sslContextFactory, SocketAddress address, Session.Listener listener, Promise<Session> promise)

      Connect for clear-text or secure HTTP/2 with the specified Transport.

      Parameters:
      transport - the Transport to use
      sslContextFactory - null for clear-text, non-null for secure HTTP/2
      address - the address to connect to
      listener - the listener to notify of session events
      promise - the Promise that is completed when the connect operation is complete

    • connect

      public void connect(Transport transport, SslContextFactory.Client sslContextFactory, SocketAddress address, Session.Listener listener, Promise<Session> promise, Map<String,Object> context)

    • accept

      public void accept(SslContextFactory.Client sslContextFactory, SocketChannel channel, Session.Listener listener, Promise<Session> promise)

      Accepts the already connected SocketChannel for clear-text or secure HTTP/2.

      Parameters:
      sslContextFactory - null for clear-text, non-null for secure HTTP/2
      channel - the already connected SocketChannel
      listener - the listener to notify of session events
      promise - the Promise that is completed when the connect operation is complete

    • accept

      public void accept(Transport transport, SslContextFactory.Client sslContextFactory, SocketChannel channel, Session.Listener listener, Promise<Session> promise)

      Accepts the already connected SocketChannel for clear-text or secure HTTP/2 with the specified Transport.

      Parameters:
      transport - the Transport to use
      sslContextFactory - null for clear-text, non-null for secure HTTP/2
      channel - the already connected SocketChannel
      listener - the listener to notify of session events
      promise - the Promise that is completed when the connect operation is complete

    • close

      public void close() throws Exception
      Specified by:
      close in interface AutoCloseable
      Throws:
      Exception