Wie RO Netty HTTP -Antwort von Channel Handler zurückgibt, um die Methode auszuführen ⇐ Java

[Anonymous]

Ich versuche, den HTTP-Client mithilfe der Netty-Bibliothek zu implementieren.public class NettyHttpClient {
private final EventLoopGroup group;

private final Bootstrap bootstrap;
private final URI uri;
private int port;

public NettyHttpClient(String url) throws Exception {
this.group = new MultiThreadIoEventLoopGroup(EpollIoHandler.newFactory());
uri = new URI(url);
String scheme = uri.getScheme() == null ? "http" : uri.getScheme();
// Configure the client
int port = uri.getPort();
if (port == -1) {
if ("http".equalsIgnoreCase(scheme)) {
this.port = 80;
} else if ("https".equalsIgnoreCase(scheme)) {
this.port = 443;
}
} else {
this.port = port;
}
this.bootstrap = new Bootstrap()
.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.handler(new HttpChannelInitializer("https".equalsIgnoreCase(uri.getScheme()), uri.getHost(), this.port));
}

private void executeRequest() {
try {
// Start the client
Channel channel = bootstrap.connect(uri.getHost(), this.port).sync().channel();

// Prepare the HTTP request
DefaultFullHttpRequest request;
if (content != null) {
request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET,, uri.getRawPath(), content);
request.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
request.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/json");
} else {
request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET,, uri.getRawPath());
}

// Set headers
request.headers().set(HttpHeaderNames.HOST, uri.getHost());
request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE);
request.headers().set(HttpHeaderNames.ACCEPT_ENCODING, HttpHeaderValues.GZIP);

// Send the HTTP request
channel.writeAndFlush(request);
} catch (Exception e) {
throw new RuntimeException(e);
}
}

public void shutdown() {
group.shutdownGracefully();
}
< /code>
Unten findenpublic class HttpChannelInitializer extends ChannelInitializer {

private final SslContext sslContext;
private final boolean ssl;
private final String host;
private final int port;
private final CompletableFuture responseFuture;

public HttpChannelInitializer(boolean ssl, String host, int port) {
this.sslContext = Main.sslContext;
this.ssl = ssl;
this.host = host;
this.port = port;
this.responseFuture = new CompletableFuture();
}

@Override
protected void initChannel(Channel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
if (ssl) {
p.addLast(sslContext.newHandler(ch.alloc(), host, port));
}
p.addLast(new HttpClientCodec());
p.addLast(new HttpContentDecompressor());
p.addLast(new HttpObjectAggregator(1048576)); // Aggregate HTTP messages
p.addLast(new HttpResponseHandler(responseFuture));

// Wait for the server to close the connection
ch.closeFuture().addListener((ChannelFutureListener) future -> {
if (!responseFuture.isDone()) {
responseFuture.completeExceptionally(new RuntimeException("Connection closed without response"));
}
});
}
}
< /code>
Unten finden Sie die httpserverResponseHandler, während die HTTP-Antwort vom Server-< /p>
">"> ">class HttpResponseHandler extends SimpleChannelInboundHandler {
private final CompletableFuture responseFuture;

public HttpResponseHandler(CompletableFuture responseFuture) {
this.responseFuture = responseFuture;
}

@Override
protected void channelRead0(ChannelHandlerContext ctx, FullHttpResponse response) {
String content = response.content().toString(CharsetUtil.UTF_8);
System.out.println("Response: " + content);
responseFuture.complete(content);
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
responseFuture.completeExceptionally(cause);

ctx.close();
}
}
< /code>
Unten finden Sie das Hauptprogramm-< /p>
public class Main {

public static SslContext sslContext = null;
static {
try {
sslContext = SslContextBuilder.forClient()
.trustManager(InsecureTrustManagerFactory.INSTANCE)
.build();
} catch (SSLException e) {
throw new RuntimeException(e);
}
}

public static void main(String[] args) throws Exception {

NettyHttpClient client = new NettyHttpClient("https://example.com");
try {
// Example GET request
client.executeRequest();

Thread.sleep(5000);
} finally {
client.shutdown();
}
}
}
< /code>
Dieser Code druckt die Antwort in der Funktion httPresponseHandler.ChannelRead0. Das?