netty 处理http请求

已于 2022-05-29 17:11:10 修改
阅读量2.1k 收藏 6
点赞数 3
分类专栏： netty 文章标签： netty
于 2022-05-28 18:08:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43931625/article/details/125021197
版权

netty 处理http请求

       

               

                                 

请求响应类

          

FullHttpRequest

public interface FullHttpRequest extends HttpRequest, FullHttpMessage {

    FullHttpRequest duplicate();
    FullHttpRequest retainedDuplicate();

    FullHttpRequest copy();
    FullHttpRequest replace(ByteBuf var1);

    FullHttpRequest retain();
    FullHttpRequest retain(int var1);

    FullHttpRequest touch();
    FullHttpRequest touch(Object var1);

    FullHttpRequest setUri(String var1);
    FullHttpRequest setMethod(HttpMethod var1);
    FullHttpRequest setProtocolVersion(HttpVersion var1);
}

        

HttpRequest

public interface HttpRequest extends HttpMessage {

    HttpMethod method();
    HttpRequest setMethod(HttpMethod var1);

    String uri();
    HttpRequest setUri(String var1);

    HttpRequest setProtocolVersion(HttpVersion var1);
}

         

DefaultFullHttpRequest

public class DefaultFullHttpRequest extends DefaultHttpRequest implements FullHttpRequest {
    private final ByteBuf content;
    private final HttpHeaders trailingHeader;
    private int hash;

    public DefaultFullHttpRequest(HttpVersion httpVersion, HttpMethod method, String uri) {
    public DefaultFullHttpRequest(HttpVersion httpVersion, HttpMethod method, String uri, ByteBuf content) {
    public DefaultFullHttpRequest(HttpVersion httpVersion, HttpMethod method, String uri, boolean validateHeaders) {
    public DefaultFullHttpRequest(HttpVersion httpVersion, HttpMethod method, String uri, ByteBuf content, boolean validateHeaders) {

    public DefaultFullHttpRequest(HttpVersion httpVersion, HttpMethod method, String uri, ByteBuf content, HttpHeaders headers, HttpHeaders trailingHeader) {
        super(httpVersion, method, uri, headers);
        this.content = (ByteBuf)ObjectUtil.checkNotNull(content, "content");
        this.trailingHeader = (HttpHeaders)ObjectUtil.checkNotNull(trailingHeader, "trailingHeader");
    }


    public HttpHeaders trailingHeaders() {
    public ByteBuf content() {

    public int refCnt() {

    public FullHttpRequest retain() {
    public FullHttpRequest retain(int increment) {

    public FullHttpRequest touch() {
    public FullHttpRequest touch(Object hint) {

    public boolean release() {
    public boolean release(int decrement) {

    public FullHttpRequest setUri(String uri) {
    public FullHttpRequest setMethod(HttpMethod method) {
    public FullHttpRequest setProtocolVersion(HttpVersion version) {

    public FullHttpRequest duplicate() {
    public FullHttpRequest retainedDuplicate() {

    public FullHttpRequest copy() {
    public FullHttpRequest replace(ByteBuf content) {

    public int hashCode() {
    public boolean equals(Object o) {
    public String toString() {

         

FullHttpResponse

public interface FullHttpResponse extends HttpResponse, FullHttpMessage {

    FullHttpResponse duplicate();
    FullHttpResponse retainedDuplicate();

    FullHttpResponse copy();
    FullHttpResponse replace(ByteBuf var1);

    FullHttpResponse retain();
    FullHttpResponse retain(int var1);

    FullHttpResponse touch();
    FullHttpResponse touch(Object var1);

    FullHttpResponse setProtocolVersion(HttpVersion var1);
    FullHttpResponse setStatus(HttpResponseStatus var1);
}

         

HttpResponse

public interface HttpResponse extends HttpMessage {

    HttpResponseStatus status();
    HttpResponse setStatus(HttpResponseStatus var1);

    HttpResponse setProtocolVersion(HttpVersion var1);
}

              

DefaultFullHttpResponse

public class DefaultFullHttpResponse extends DefaultHttpResponse implements FullHttpResponse {
    private final ByteBuf content;
    private final HttpHeaders trailingHeaders;
    private int hash;

    public DefaultFullHttpResponse(HttpVersion version, HttpResponseStatus status) {
    public DefaultFullHttpResponse(HttpVersion version, HttpResponseStatus status, ByteBuf content) {
    public DefaultFullHttpResponse(HttpVersion version, HttpResponseStatus status, boolean validateHeaders) {
    public DefaultFullHttpResponse(HttpVersion version, HttpResponseStatus status, boolean validateHeaders, boolean singleFieldHeaders) {
    public DefaultFullHttpResponse(HttpVersion version, HttpResponseStatus status, ByteBuf content, boolean validateHeaders) {
    public DefaultFullHttpResponse(HttpVersion version, HttpResponseStatus status, ByteBuf content, boolean validateHeaders, boolean singleFieldHeaders) {

    public DefaultFullHttpResponse(HttpVersion version, HttpResponseStatus status, ByteBuf content, HttpHeaders headers, HttpHeaders trailingHeaders) {
        super(version, status, headers);
        this.content = (ByteBuf)ObjectUtil.checkNotNull(content, "content");
        this.trailingHeaders = (HttpHeaders)ObjectUtil.checkNotNull(trailingHeaders, "trailingHeaders");
    }


    public HttpHeaders trailingHeaders() {
    public ByteBuf content() {

    public int refCnt() {

    public FullHttpResponse retain() {
    public FullHttpResponse retain(int increment) {

    public FullHttpResponse touch() {
    public FullHttpResponse touch(Object hint) {

    public boolean release() {
    public boolean release(int decrement) {

    public FullHttpResponse setProtocolVersion(HttpVersion version) {
    public FullHttpResponse setStatus(HttpResponseStatus status) {

    public FullHttpResponse duplicate() {
    public FullHttpResponse retainedDuplicate() {

    public FullHttpResponse copy() {
    public FullHttpResponse replace(ByteBuf content) {

    public int hashCode() {    public boolean equals(Object o) {
    public String toString() {

          

HttpMessage

public interface HttpMessage extends HttpObject {

    HttpVersion protocolVersion();
    HttpMessage setProtocolVersion(HttpVersion var1);

    HttpHeaders headers();
}

      

HttpObject

public interface HttpObject extends DecoderResultProvider {
    /** @deprecated */
    @Deprecated
    DecoderResult getDecoderResult();
}

                  

DecoderResultProvider

public interface DecoderResultProvider {

    DecoderResult decoderResult();
    void setDecoderResult(DecoderResult var1);
}

       

             

                                 

编解码类

     

QueryStringDecoder

public class QueryStringDecoder {
    private static final int DEFAULT_MAX_PARAMS = 1024;
    private final Charset charset;
    private final String uri;
    private final int maxParams;
    private final boolean semicolonIsNormalChar;
    private int pathEndIdx;
    private String path;
    private Map<String, List<String>> params;


    public QueryStringDecoder(String uri) {
    public QueryStringDecoder(String uri, boolean hasPath) {
    public QueryStringDecoder(String uri, Charset charset) {
    public QueryStringDecoder(String uri, Charset charset, boolean hasPath) {
    public QueryStringDecoder(String uri, Charset charset, boolean hasPath, int maxParams) {
    public QueryStringDecoder(String uri, Charset charset, boolean hasPath, int maxParams, boolean semicolonIsNormalChar) {

    public QueryStringDecoder(URI uri) {
    public QueryStringDecoder(URI uri, Charset charset) {
    public QueryStringDecoder(URI uri, Charset charset, int maxParams) {
    public QueryStringDecoder(URI uri, Charset charset, int maxParams, boolean semicolonIsNormalChar) {


    public String uri() {
    public String path() {

    public String rawPath() {
    public String rawQuery() {
    public Map<String, List<String>> parameters() {


    public static String decodeComponent(String s) {
    public static String decodeComponent(String s, Charset charset) {

    public String toString() {


    private int pathEndIdx() {
    private static int findPathEndIndex(String uri) {
    private static String decodeComponent(String s, int from, int toExcluded, Charset charset, boolean isPath) {
    private static boolean addParam(String s, int nameStart, int valueStart, int valueEnd, Map<String, List<String>> params, Charset charset) {
    private static Map<String, List<String>> decodeParams(String s, int from, Charset charset, int paramsLimit, boolean semicolonIsNormalChar) {

          

HttpPostRequestDecoder

public class HttpPostRequestDecoder implements InterfaceHttpPostRequestDecoder {
    static final int DEFAULT_DISCARD_THRESHOLD = 10485760;
    private final InterfaceHttpPostRequestDecoder decoder;


    public HttpPostRequestDecoder(HttpRequest request) {
    public HttpPostRequestDecoder(HttpDataFactory factory, HttpRequest request) {
    public HttpPostRequestDecoder(HttpDataFactory factory, HttpRequest request, Charset charset) {


    public static boolean isMultipart(HttpRequest request) {
    public boolean isMultipart() {

    public void setDiscardThreshold(int discardThreshold) {
    public int getDiscardThreshold() {

    public List<InterfaceHttpData> getBodyHttpDatas() {
    public List<InterfaceHttpData> getBodyHttpDatas(String name) {
    public InterfaceHttpData getBodyHttpData(String name) {

    public InterfaceHttpPostRequestDecoder offer(HttpContent content) {

    public boolean hasNext() {
    public InterfaceHttpData next() {
    public InterfaceHttpData currentPartialHttpData() {

    public void destroy() {
    public void cleanFiles() {
    public void removeHttpDataFromClean(InterfaceHttpData data) {

    protected static String[] getMultipartDataBoundary(String contentType) {

    private static String[] splitHeaderContentType(String sb) {


*******
内部类：HttpPostRequestDecoder.ErrorDataDecoderException

    public static class ErrorDataDecoderException extends DecoderException {
        private static final long serialVersionUID = 5020247425493164465L;

        public ErrorDataDecoderException() {
        public ErrorDataDecoderException(String msg) {
        public ErrorDataDecoderException(Throwable cause) {
        public ErrorDataDecoderException(String msg, Throwable cause) {


*******
内部类：HttpPostRequestDecoder.EndOfDataDecoderException

    public static class EndOfDataDecoderException extends DecoderException {
        private static final long serialVersionUID = 1336267941020800769L;

        public EndOfDataDecoderException() {


*******
内部类：HttpPostRequestDecoder.NotEnoughDataDecoderException

    public static class NotEnoughDataDecoderException extends DecoderException {
        private static final long serialVersionUID = -7846841864603865638L;

        public NotEnoughDataDecoderException() {
        public NotEnoughDataDecoderException(String msg) {
        public NotEnoughDataDecoderException(Throwable cause) {
        public NotEnoughDataDecoderException(String msg, Throwable cause) {


*******
内部枚举：MultiPartStatus

    protected static enum MultiPartStatus {
        NOTSTARTED,
        PREAMBLE,
        HEADERDELIMITER,
        DISPOSITION,
        FIELD,
        FILEUPLOAD,
        MIXEDPREAMBLE,
        MIXEDDELIMITER,
        MIXEDDISPOSITION,
        MIXEDFILEUPLOAD,
        MIXEDCLOSEDELIMITER,
        CLOSEDELIMITER,
        PREEPILOGUE,
        EPILOGUE;

        private MultiPartStatus() {
        }
    }
}

         

HttpResponseEncoder

public class HttpResponseEncoder extends HttpObjectEncoder<HttpResponse> {

    public HttpResponseEncoder() {
    public boolean acceptOutboundMessage(Object msg) throws Exception {

    protected void encodeInitialLine(ByteBuf buf, HttpResponse response) throws Exception {
    protected void sanitizeHeadersBeforeEncode(HttpResponse msg, boolean isAlwaysEmpty) {
    protected boolean isContentAlwaysEmpty(HttpResponse msg) {

            

                

                                 

使用示例

     

**********

服务端

      

CustomHttpHandler

public class CustomHttpHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, FullHttpRequest fullHttpRequest) throws Exception {
        switch (fullHttpRequest.method().name()){
            case "GET": processGetRequest(fullHttpRequest); break;
            case "POST": {
                if (fullHttpRequest.headers().get("Content-Type").contains("x-www-form-urlencoded")){
                    processPostFormRequest(fullHttpRequest);
                }else if (fullHttpRequest.headers().get("Content-Type").contains("application/json")){
                    processPostJsonRequest(fullHttpRequest);
                }
            }
        }

        ByteBuf buf = PooledByteBufAllocator.DEFAULT.buffer();
        buf.writeCharSequence("success", StandardCharsets.UTF_8);
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, buf);
        response.headers().set("Content-Type","application/json;charset=UTF-8");
        response.headers().set("Content-Length",response.content().readableBytes());

        channelHandlerContext.channel().writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }

    private void processGetRequest(FullHttpRequest request){
        System.out.println("处理get请求");

        QueryStringDecoder decoder = new QueryStringDecoder(request.uri());
        Map<String, List<String>> params = decoder.parameters();
        params.forEach((key, value) -> System.out.println(key + " ==> "+ value));
    }

    private void processPostFormRequest(FullHttpRequest request){
        System.out.println("处理post form请求");

        HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(request);
        List<InterfaceHttpData> httpDataList = decoder.getBodyHttpDatas();
        httpDataList.forEach(item -> {
            if (item.getHttpDataType() == InterfaceHttpData.HttpDataType.Attribute){
                Attribute attribute = (Attribute) item;

                try {
                    System.out.println(attribute.getName() + " ==> " + attribute.getValue());
                }catch (Exception e){
                    e.printStackTrace();
                }

            }
        });
    }

    private void processPostJsonRequest(FullHttpRequest request){
        System.out.println("处理post json请求");

        ByteBuf content = request.content();
        byte[] bytes = new byte[content.readableBytes()];
        content.readBytes(bytes);

        JSONObject jsonObject = JSONObject.parseObject(new String(bytes));
        jsonObject.getInnerMap().forEach((key,value) -> System.out.println(key + " ==> " + value));
    }
}

         

NettyServer

public class NettyServer {

    public static void startServer(int port){
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {

                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline channelPipeline = socketChannel.pipeline();
                            channelPipeline.addLast(new HttpRequestDecoder());
                            channelPipeline.addLast(new HttpResponseEncoder());
                            channelPipeline.addLast(new HttpObjectAggregator(65535));
                            channelPipeline.addLast(new CustomHttpHandler());
                        }
                    });

            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            channelFuture.channel().closeFuture().sync();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        startServer(8000);
    }
}

         

**********

使用测试

   

get 请求：localhost:8000/hello?name=瓜田李下&age=20

          

15:20:42.090 [nioEventLoopGroup-3-2] DEBUG io.netty.buffer.AbstractByteBuf - -Dio.netty.buffer.checkBounds: true
15:20:42.091 [nioEventLoopGroup-3-2] DEBUG io.netty.util.ResourceLeakDetectorFactory - Loaded default ResourceLeakDetector: io.netty.util.ResourceLeakDetector@236a9fe3
15:20:42.124 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.maxCapacityPerThread: 4096
15:20:42.126 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.ratio: 8
15:20:42.126 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.chunkSize: 32
15:20:42.126 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.blocking: false
处理get请求
name ==> [瓜田李下]
age ==> [20]

        

post form请求

          

15:33:25.270 [nioEventLoopGroup-3-1] DEBUG io.netty.buffer.AbstractByteBuf - -Dio.netty.buffer.checkBounds: true
15:33:25.271 [nioEventLoopGroup-3-1] DEBUG io.netty.util.ResourceLeakDetectorFactory - Loaded default ResourceLeakDetector: io.netty.util.ResourceLeakDetector@2e03ba32
15:33:25.307 [nioEventLoopGroup-3-2] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.maxCapacityPerThread: 4096
15:33:25.309 [nioEventLoopGroup-3-2] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.ratio: 8
15:33:25.309 [nioEventLoopGroup-3-2] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.chunkSize: 32
15:33:25.309 [nioEventLoopGroup-3-2] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.blocking: false
处理post form请求
name ==> 瓜田李下
age ==> 20

       

post json请求

          

15:35:44.038 [nioEventLoopGroup-3-2] DEBUG io.netty.buffer.AbstractByteBuf - -Dio.netty.buffer.checkBounds: true
15:35:44.039 [nioEventLoopGroup-3-2] DEBUG io.netty.util.ResourceLeakDetectorFactory - Loaded default ResourceLeakDetector: io.netty.util.ResourceLeakDetector@400ded19
15:35:44.072 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.maxCapacityPerThread: 4096
15:35:44.074 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.ratio: 8
15:35:44.074 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.chunkSize: 32
15:35:44.074 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.blocking: false
处理post json请求
name ==> 瓜田李下
age ==> 20

        

              

o_瓜田李下_o
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty结合SpringBoot 处理http请求示例源码
03-07
本示例源码旨在帮助开发者理解如何利用这两种技术处理HTTP请求，提升项目的处理能力。 Netty是一个高性能、异步事件驱动的网络应用框架，用于快速开发可维护的高性能协议服务器和客户端。它提供了丰富的网络编程...
netty-http3使用代码
07-11
这可能包括Netty的核心库，以及专门处理HTTP/3的模块。例如： ```groovy dependencies { implementation 'io.netty:netty-all:4.x.y' // 替换为最新的Netty版本 implementation 'io.netty:netty-quic:4.x.y' // ...
Netty之获取FullHttpRequest中的请求参数信息(x-www-form-urlencoded协议)
IUNIQUE技术册
12-01 8742
获取FullHttpRequest中的请求参数信息FullHttpRequestHTTP请求行HTTP请求头HTTP请求参数 FullHttpRequest 使用Netty开发一个HTTP服务器，Content-Type为 x-www-form-urlencoded的类型，需要从中获取请求参数信息 HTTP请求行 fullRequest.getMethod().name(); //获取请求方法 fullRequest.getMethod().getUri(); //获取请求URI fullRequest.g
Netty 实现http请求 并响应
AP0906424的博客
11-02 5283
什么是Netty? Netty 是一个利用Java 的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的API 的客户端/服务器 框架。 Netty 与 Tomcat Netty与tomcat 最大的区别在于通信协议。Tomcat 是基于Http 协议的，它的实质是一个基于Http协议的web 容器。 但是Netty 不一样，它能通过编程自定义各种协议，因为netty能够通过codec 自己来编码/解码 字节流。完成类似redis访问的功能。 这就是netty 和tomcat 最大的不同 N
Netty入门 - Netty接收请求过程源码分析
最新发布
qq_33240556的博客
06-07 229
启动服务器并绑定端口。使用处理连接和 I/O 操作。初始化Channel，配置处理器。接收新的连接请求并创建。将注册到EventLoop。触发read方法，读取数据并通过管道传递。处理器处理接收到的数据。通过分析 Netty 的源码，我们可以更好地理解其内部工作机制，为开发高性能网络应用提供坚实的基础。
netty实现http客户端请求远程http服务
feinifi的博客
11-08 1万+
一般http请求，我们会使用httpclient来实现连接池方式的连接，根据请求的类型，封装get,post等请求，设置参数，设置请求头，调用方法，发送请求之后等待请求返回结果，根据结果解析出我们需要的数据。netty也可以实现httpclient类似的功能，只不过，很多时候，我们使用netty构建tcp的连接，要么使用netty构建http服务端，很少用来构建http客户端，其实和tcp...
Netty4.0的DefaultHttpRequest与FullHttpRequest
naruto_Mr的专栏
04-10 1万+
本人用netty4.0做Http服务器模块时，出现了一个Bug，从平台发送过来的充值请求接收不到，充值请求是Post方式，自己写了个post工具模拟充值请求，发现：能收到HttpRequest，但收不到HttpContent。 消息分发器代码： protected void channelRead0(ChannelHandlerContext ctx, Object data) thr
netty对http协议解析原理解析
glowd的专栏
07-13 607
转载自 https://blog.csdn.net/xiangzhihong8/article/details/52029446 本文主要介绍netty对http协议解析原理，着重讲解keep-alive，gzip，truncked等机制，详细描述了netty如何实现对http解析的高性能。 1 http协议 1.1 描述 标示 ASCII 描述 字符 CR 13 Car...
netty http protobuf
08-04
2. **客户端**：Netty的HTTP客户端发送HTTP请求到服务器，请求体包含用Protobuf编码的数据。客户端首先将业务对象转换为Protobuf格式的字节流，然后将其封装在HTTP请求中。 3. **数据传输**：HTTP协议负责将客户端...
Java Netty HTTP服务实现过程解析
08-18
// 处理HTTP请求 // ... } } } ``` 在这个处理类中，你可以解析请求，执行业务逻辑，然后构建并返回HTTP响应。例如，可以检查请求的方法（GET、POST等），路径，查询参数，以及请求头，根据这些信息来决定如何...
netty http client & server
08-04
在 "netty-http-server" 文件中，我们可以找到一个使用 Netty 实现的 HTTP 服务器示例，它展示了如何接收和处理 HTTP 请求。而在 "netty-http-client" 文件中，包含了一个简单的 HTTP 客户端示例，演示了如何向...
Netty实现http请求处理
afggg_的博客
03-29 829
Netty实现http请求处理
netty入门使用
cxy1991xm的博客
04-27 161
public class HttpServer { public void start(int port) throws Exception { EventLoopGroup bossGroup = new NioEventLoopGroup(1); int availProcessors = Runtime.getRuntime().availa...
Netty4 学习笔记之四: Netty HTTP服务的实现
虚无境的博客
10-27 1万+
前言 目前主流的JAVA web 的HTTP服务主要是 springMVC和Struts2，更早的有JSP/servlet。 在学习Netty的时候，发现Netty 也可以作HTTP服务，于是便将此整理一篇博文，分享给大家。 开发准备 添加配置 将Netty作为HTTP服务，需要在过滤器中添加HttpRequest之类的配置，如: ph.addLast...
Netty实战入门详解——让你彻底记住什么是Netty（看不懂你来找我）
qq_48811377的博客
05-08 3425
Netty 是基于 Java NIO 的异步事件驱动的网络应用框架，使用 Netty 可以快速开发网络应用，Netty 提供了高层次的抽象来简化 TCP 和 UDP 服务器的编程，但是你仍然可以使用底层的 API。Netty 的内部实现是很复杂的，但是 Netty 提供了简单易用的API从网络处理代码中解耦业务逻辑。Netty 是完全基于 NIO 实现的，所以整个 Netty 都是异步的。
Netty使用篇：Http协议编解码
热门推荐
七叔的博客
11-20 2万+
Netty：Http协议编解码
Netty整合SpringMVC，实现高效的HTTP服务请求
weixin_44421461的博客
02-14 980
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！每天14:00更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细...
netty~http客户端与服务端
houkai的博客
10-07 883
描述 netty对http消息提供了FullHttpRequest接口，此接口合并HttpRequest和FullHttpMessage ，因此请求是一个完整的HTTP请求。 服务端消息处理器 /** * @describe: http服务端对消息的处理 * @author: houkai */ public class HttpHandler extends SimpleChannelInboundHandler<FullHttpRequest> { @Over...
netty发送http请求
05-16
Netty是一个基于NIO的网络编程框架，它可以帮助我们实现高性能、高可靠性的网络应用程序。在Netty中，我们可以使用HTTP客户端来发送HTTP请求。 下面是一个简单的Netty发送HTTP请求的示例： ```java import io.netty.bootstrap.Bootstrap; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioSocketChannel; import io.netty.handler.codec.http.DefaultFullHttpRequest; import io.netty.handler.codec.http.HttpMethod; import io.netty.handler.codec.http.HttpRequestEncoder; import io.netty.handler.codec.http.HttpResponseDecoder; import io.netty.handler.codec.http.HttpVersion; import java.net.URI; public class NettyHttpClient { private final String host; private final int port; public NettyHttpClient(String host, int port) { this.host = host; this.port = port; } public void sendGetRequest(String uri) throws Exception { EventLoopGroup group = new NioEventLoopGroup(); try { Bootstrap bootstrap = new Bootstrap(); bootstrap.group(group) .channel(NioSocketChannel.class) .option(ChannelOption.TCP_NODELAY, true) .handler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast(new HttpResponseDecoder()); ch.pipeline().addLast(new HttpRequestEncoder()); } }); URI requestUri = new URI(uri); String path = requestUri.getRawPath(); String query = requestUri.getRawQuery(); if (query != null && !query.isEmpty()) { path = path + "?" + query; } DefaultFullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, path); request.headers().set("Host", host); request.headers().set("Connection", "keep-alive"); request.headers().set("Accept", "*/*"); request.headers().set("User-Agent", "NettyHttpClient"); ChannelFuture future = bootstrap.connect(host, port).sync(); future.channel().write(request); future.channel().flush(); future.channel().closeFuture().sync(); } finally { group.shutdownGracefully(); } } } ``` 在上面的示例中，我们创建了一个NettyHttpClient类，它接受主机名和端口号作为参数。然后，我们定义了一个sendGetRequest方法，该方法接受URI作为参数，并发送HTTP GET请求。 在sendGetRequest方法中，我们创建了一个NioEventLoopGroup，它处理所有事件，例如连接、读取和写入。然后，我们创建了一个Bootstrap对象，并设置了TCP_NODELAY选项和一个ChannelInitializer对象，该对象将添加一个HttpResponseDecoder和一个HttpRequestEncoder到管道中。 接下来，我们解析URI，并创建一个DefaultFullHttpRequest对象，该对象包含HTTP版本、HTTP方法、路径和头信息。最后，我们使用Bootstrap对象连接到主机并发送请求。 这是一个简单的Netty发送HTTP请求的示例，可以根据需求进行修改和扩展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值