How to use org.asynchttpclient.netty

 @Override
 public HttpResponseBodyPart newResponseBodyPart(ByteBuf buf, boolean last) {
  return new LazyResponseBodyPart(buf, last);
 }
};

WriteListener(NettyResponseFuture<?> future, boolean notifyHeaders) {
 this.future = future;
 this.progressAsyncHandler = future.getAsyncHandler() instanceof ProgressAsyncHandler ? (ProgressAsyncHandler<?>) future.getAsyncHandler() : null;
 this.notifyHeaders = notifyHeaders;
}

 @Override
 public HttpResponseBodyPart newResponseBodyPart(ByteBuf buf, boolean last) {
  return new EagerResponseBodyPart(buf, last);
 }
},

private void scheduleRequestTimeout(NettyResponseFuture<?> nettyResponseFuture,
                  InetSocketAddress originalRemoteAddress) {
 nettyResponseFuture.touch();
 TimeoutsHolder timeoutsHolder = new TimeoutsHolder(nettyTimer, nettyResponseFuture, this, config,
     originalRemoteAddress);
 nettyResponseFuture.setTimeoutsHolder(timeoutsHolder);
}

 public boolean exitAfterHandling100(final Channel channel, final NettyResponseFuture<?> future) {
  future.setHeadersAlreadyWrittenOnContinue(true);
  future.setDontWriteBodyBecauseExpectContinue(false);
  // directly send the body
  Channels.setAttribute(channel, new OnLastHttpContentCallback(future) {
   @Override
   public void call() {
    Channels.setAttribute(channel, future);
    requestSender.writeRequest(future, channel);
   }
  });
  return true;
 }
}

private boolean futureIsAlreadyCancelled(Channel channel) {
 // FIXME should we only check isCancelled?
 if (future.isDone()) {
  Channels.silentlyCloseChannel(channel);
  return true;
 }
 return false;
}

private void scheduleReadTimeout(NettyResponseFuture<?> nettyResponseFuture) {
 TimeoutsHolder timeoutsHolder = nettyResponseFuture.getTimeoutsHolder();
 if (timeoutsHolder != null) {
  // on very fast requests, it's entirely possible that the response has already
  // been completed
  // by the time we try to schedule the read timeout
  nettyResponseFuture.touch();
  timeoutsHolder.startReadTimeout();
 }
}

/**
 * Build a {@link Response} instance
 *
 * @return a {@link Response} instance
 */
public Response build() {
 return status == null ? null : new NettyResponse(status, headers, bodyParts);
}

@Override
public boolean isDone() {
 return isDone != 0 || isCancelled();
}

private boolean terminateAndExit() {
 releasePartitionKeyLock();
 cancelTimeouts();
 this.channel = null;
 this.reuseChannel = false;
 return IS_DONE_FIELD.getAndSet(this, 1) != 0 || isCancelled != 0;
}

private void releasePartitionKeyLock() {
 if (connectionSemaphore == null) {
  return;
 }
 Object partitionKey = takePartitionKeyLock();
 if (partitionKey != null) {
  connectionSemaphore.releaseChannelLock(partitionKey);
 }
}

@Override
public byte[] getResponseBodyAsBytes() {
 return getResponseBodyAsByteBuffer().array();
}

@Override
public InputStream getResponseBodyAsStream() {
 return new ByteArrayInputStream(getResponseBodyAsBytes());
}

@Override
public final void operationComplete(ChannelFuture future) {
 Channel channel = future.channel();
 if (future.isSuccess()) {
  onSuccess(channel);
 } else {
  onFailure(channel, future.cause());
 }
}

@Override
public final void operationComplete(Future<V> future) throws Exception {
 if (future.isSuccess()) {
  onSuccess(future.getNow());
 } else {
  onFailure(future.cause());
 }
}

@Override
public final String getContentType() {
 return headers != null ? getHeader(CONTENT_TYPE) : null;
}

@Override
public List<Cookie> getCookies() {
 if (headers == null) {
  return Collections.emptyList();
 }
 if (cookies == null) {
  cookies = buildCookies();
 }
 return cookies;
}

@Override
public AbstractHandler configureHandler() throws Exception {
 return new SlowHandler();
}

public void attachChannel(Channel channel, boolean reuseChannel) {
 // future could have been cancelled first
 if (isDone()) {
  Channels.silentlyCloseChannel(channel);
 }
 this.channel = channel;
 this.reuseChannel = reuseChannel;
}

private static WebSocketUpgradeHandler getWebSocketUpgradeHandler(NettyResponseFuture<?> future) {
 return (WebSocketUpgradeHandler) future.getAsyncHandler();
}