Netty-搭建一个简单的HTTP服务器

最新推荐文章于 2025-03-17 21:37:35 发布
最新推荐文章于 2025-03-17 21:37:35 发布
阅读量617 收藏 2
点赞数
分类专栏： Netty 文章标签： http 网络协议 网络 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yimint/article/details/132188710
版权

前言

前面几篇文章用Netty搭建了不同传输协议的的消息接收发送服务并解决的粘包半包问题。

Netty-搭建一个简单的消息接收发送服务icon-default.png?t=N6B9https://blog.youkuaiyun.com/yimint/article/details/132061057?spm=1001.2014.3001.5501Netty-搭建一个简单的Json协议消息接收发送服务icon-default.png?t=N6B9https://blog.youkuaiyun.com/yimint/article/details/132075254?spm=1001.2014.3001.5501Netty-搭建一个简单的Protobuf协议消息接收发送服务icon-default.png?t=N6B9https://blog.youkuaiyun.com/yimint/article/details/132145975?spm=1001.2014.3001.5501

这篇文章用Netty搭建一个简单的HTTP服务器。

一、Netty——HTTP

在这之前先了解Http协议和特点以及Netty对HTTP的封装，相关文章网上已经有非常详细的资料了，我推荐以下两篇文章：

Netty之Httpicon-default.png?t=N6B9https://zhuanlan.zhihu.com/p/135239211netty对http协议解析原理解析icon-default.png?t=N6B9https://cloud.tencent.com/developer/article/1035923

二、Netty搭建HTTP服务器

1.引入依赖

    <dependencies>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.22</version>
        </dependency>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.21.Final</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>3.20.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.3</version>
        </dependency>
    </dependencies>

2.服务端

public class EchoHttpServer {
    private final static Logger LOGGER = LoggerFactory.getLogger(EchoHttpServer.class);
    public static final String SERVER_IP = "127.0.0.1";
    public static final int SERVER_PORT = 54123;

    public static void main(String[] args) {

        ServerBootstrap b = new ServerBootstrap();
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            b.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {

                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            //请求解码器和响应编码器,等价于下面两行
                            // pipeline.addLast(new HttpServerCodec());
                            //请求解码器
                            pipeline.addLast(new HttpRequestDecoder());
                            //响应编码器
                            pipeline.addLast(new HttpResponseEncoder());
                            // HttpObjectAggregator 将HTTP消息的多个部分合成一条完整的HTTP消息
                            // HttpObjectAggregator 用于解析Http完整请求
                            // 把多个消息转换为一个单一的完全FullHttpRequest或是FullHttpResponse，
                            // 原因是HTTP解码器会在解析每个HTTP消息中生成多个消息对象
                            // 如 HttpRequest/HttpResponse,HttpContent,LastHttpContent
                            pipeline.addLast(new HttpObjectAggregator(65535));
                            pipeline.addLast(new ChunkedWriteHandler());
                            // 自定义的业务handler
                            pipeline.addLast(new HttpEchoHandler());
                        }
                    });
            Channel ch = b.bind(SERVER_PORT).sync().channel();
            LOGGER.info("HTTP ECHO 服务已经启动 http://{}:{}/", "127.0.0.1", SERVER_PORT);
            // 等待服务端监听到端口关闭
            ch.closeFuture().sync();
        } catch (Exception ex) {
            LOGGER.error(ExceptionUtil.stacktraceToString(ex));
        }finally {
            workGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}
public class HttpEchoHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
    private final static Logger LOGGER = LoggerFactory.getLogger(HttpEchoHandler.class);
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
        if (!request.decoderResult().isSuccess()) {//判断解码是否成功
            HttpProtocolHelper.sendError(ctx, BAD_REQUEST);
            return;
        }
        /**
         * 缓存HTTP协议的版本号
         */
        HttpProtocolHelper.cacheHttpProtocol(ctx, request);

        Map<String, Object> echo = new HashMap<>();
        // 1.获取URI
        String uri = request.uri();
        echo.put("request uri", uri);
        LOGGER.info("request uri：{}", uri);
        // 2.获取请求方法
        HttpMethod method = request.method();
        echo.put("request method", method.toString());
        LOGGER.info("request method：{}", method);
        // 3.获取请求头
        Map<String, Object> echoHeaders = new HashMap<>();
        HttpHeaders headers = request.headers();
        for (Map.Entry<String, String> header : headers.entries()) {
            echoHeaders.put(header.getKey(), header.getValue());
        }

        echo.put("request header", echoHeaders);
        LOGGER.info("request header：{}", echoHeaders);
        /**
         * 获取uri请求参数
         */
        Map<String, Object> uriDatas = paramsFromUri(request);
        echo.put("paramsFromUri", uriDatas);
        LOGGER.info("request paramsFromUri：{}", uriDatas);
        // 处理POST请求
        if (POST.equals(request.method())) {
            /**
             * 获取请求体数据到 map
             */
            Map<String, Object> postData = dataFromPost(request);
            echo.put("dataFromPost", postData);
            LOGGER.info("request dataFromPost：{}", postData);
        }


        /**
         * 回显内容转换成json字符串
         */
        String sendContent = JSONUtil.toJsonStr(echo);
        /**
         * 发送回显内容到客户端
         */
        HttpProtocolHelper.sendJsonContent(ctx, sendContent);
    }

    /*
     * 从URI后面获取请求的参数
     */
    private Map<String, Object> paramsFromUri(FullHttpRequest fullHttpRequest) {
        Map<String, Object> params = new HashMap<String, Object>();
        // 把URI后面的参数串，分割成key-value形式
        QueryStringDecoder decoder = new QueryStringDecoder(fullHttpRequest.uri());
        // 提取key-value形式的参数串
        Map<String, List<String>> paramList = decoder.parameters();
        //迭代key-value形式的参数串
        for (Map.Entry<String, List<String>> entry : paramList.entrySet()) {
            params.put(entry.getKey(), entry.getValue().get(0));
        }
        return params;
    }

    /*
     * 获取POST方式传递的请求体数据
     */
    private Map<String, Object> dataFromPost(FullHttpRequest fullHttpRequest) {

        Map<String, Object> postData = null;
        try {
            String contentType = fullHttpRequest.headers().get("Content-Type").trim();
            //普通form表单数据，非multipart形式表单
            if (contentType.contains("application/x-www-form-urlencoded")) {
                postData = formBodyDecode(fullHttpRequest);
            }
            //multipart形式表单
            else if (contentType.contains("multipart/form-data")) {
                postData = formBodyDecode(fullHttpRequest);
            }
            // 解析json数据
            else if (contentType.contains("application/json")) {
                postData = jsonBodyDecode(fullHttpRequest);
            } else if (contentType.contains("text/plain")) {
                ByteBuf content = fullHttpRequest.content();
                byte[] reqContent = new byte[content.readableBytes()];
                content.readBytes(reqContent);
                String text = new String(reqContent, StandardCharsets.UTF_8);
                postData = new HashMap<>();
                postData.put("text", text);
            }
            return postData;
        } catch (UnsupportedEncodingException e) {
            return null;
        }
    }

    /*
     * 解析from表单数据
     */
    private Map<String, Object> formBodyDecode(FullHttpRequest fullHttpRequest) {
        Map<String, Object> params = new HashMap<String, Object>();
        try {
            HttpPostRequestDecoder decoder =
                    new HttpPostRequestDecoder(new DefaultHttpDataFactory(DefaultHttpDataFactory.MINSIZE),
                            fullHttpRequest,
                            CharsetUtil.UTF_8);

            List<InterfaceHttpData> postData = decoder.getBodyHttpDatas();
            if (postData == null || postData.isEmpty()) {
                decoder = new HttpPostRequestDecoder(fullHttpRequest);
                if (fullHttpRequest.content().isReadable()) {
                    String json = fullHttpRequest.content().toString(CharsetUtil.UTF_8);
                    params.put("body", json);
                }
            }

            for (InterfaceHttpData data : postData) {
                if (data.getHttpDataType() == InterfaceHttpData.HttpDataType.Attribute) {
                    MixedAttribute attribute = (MixedAttribute) data;
                    params.put(attribute.getName(), attribute.getValue());
                } else if (data.getHttpDataType() == InterfaceHttpData.HttpDataType.FileUpload) {
                    MixedFileUpload fileUpload = (MixedFileUpload) data;
                    String filename = fileUpload.getFilename();
                    byte[] content = fileUpload.get();
                    String contentType = fileUpload.getContentType();
                    params.put("filename", filename);
                    params.put("contentType", contentType);
                    params.put("content", Arrays.toString(content));
                    fileUpload.release();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return params;
    }

    /*
     * 解析json数据（Content-Type = application/json）
     */
    private Map<String, Object> jsonBodyDecode(FullHttpRequest fullHttpRequest) throws UnsupportedEncodingException {
        ByteBuf content = fullHttpRequest.content();
        byte[] reqContent = new byte[content.readableBytes()];
        if (reqContent.length == 0) {
            return null;
        }
        Map<String, Object> params = new HashMap<String, Object>();
        content.readBytes(reqContent);
        String strContent = new String(reqContent, StandardCharsets.UTF_8);

        JSONObject jsonParams = JSONUtil.parseObj(strContent);

        for (Object key : jsonParams.keySet()) {
            params.put(key.toString(), jsonParams.get(key));
        }

        return params;
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        if (ctx.channel().isActive()) {
            HttpProtocolHelper.sendError(ctx, INTERNAL_SERVER_ERROR);
        }
    }
}

 三、请求测试

 启动HTTP服务器

 浏览器GET请求服务

 postman POST请求服务

总结

至此，一个简单的基于Netty的HTTP服务器就搭完了，HTTP相关知识点还是很重要的，为后续基于Netty搭建一个轻量级的WEB框架打下基础。

项目地址：https://github.com/YIminta/Netty-learning

【使用Netty实现Http服务器一】
ThinkLess404的专栏
06-03 1275
这里MyHttpServerHandler 继承类时传入的泛型是FullHttpRequest，这里的类型与你上一个处理的handler有关，我们示例中上一个handler是HttpObjectAggregator，聚合后的数据我们读取就是FullHttpRequest类型了。到这里我们已经完成了一个简单的HTTP服务，如果我们要实现一个静态的web服务器，指定一个路径为基地址，通过path访问路径下的html，要如何做呢。实现在运行目录的app目录下作为网站基地址，实现静态网页的访问。
netty构建http服务器
svygh123的专栏
07-27 793
Netty 是一个高性能的异步事件驱动的网络应用框架，用于快速开发可维护的高性能协议服务器和客户端。要使用 Netty 搭建一个支持 HTTP 方法（GET, POST, PUT, DELETE）的简单 HTTP 服务器，你可以按照以下步骤进行操作。
Netty基础—7.Netty实现消息推送服务一
最新发布
mjunz的博客
03-17 619
首先添加HTTP请求消息解码器HttpRequestDecoder，因为浏览器会把按照HTTP协议组织起来的请求数据序列化成字节数组发送给服务器，而HttpRequestDecoder可以按照HTTP协议从接收到的字节数组中读取出一个完整的请求数据。浏览器里面运行的是HTML网页代码，WebSocket就是在HTML网页代码里嵌入WebSocket代码，可以让浏览器里的HTML网页代码跟NettyServer建立连接，并且是基于长连接发送数据。HTTP请求消息由三部分组成：请求行、请求头、请求体。
通过netty实现http服务器
旭旭1998的博客
03-27 1162
***/@Slf4j@Overridepipeline.addLast("http编解码器", new HttpServerCodec());pipeline.addLast("http大数据包处理器", new ChunkedWriteHandler());pipeline.addLast("http报文聚合器", new HttpObjectAggregator(64 * 1024));
netty-搭建简单http服务器
小尘_OnMyWay的博客
04-06 1404
netty中提供了许多定义好的协议，如HTTP编解码器，我们利用它可以快速地开发一个基于netty的web服务器。 package com.throne.netty.test1.protocol; import io.netty.bootstrap.Bootstrap; import io.netty.bootstrap.ServerBootstrap; import io.netty.buffer.ByteBuf; import io.netty.channel.*; import io.netty.c
基于Netty实现一个HTTP服务器
HackDaily
01-31 4028
基于Netty实现HTTP传输，实现一个HTTP服务器。跟Nginx类似，Netty在HTTP协议栈上也有优越的性能表现，不需要依赖Web容器，所以相比的Tomcat、Jetty等Web容器会更轻量和轻巧。
基于netty实现mqtt协议 服务器端开发，可解码http、mqtt协议请求
04-29
1.基于netty绑定端口监听，对于mqtt消息和http请求消息分别绑定不同的监听端口； 2.在MQTTServerInitializer中，分别添加mqtt编码解码器和http编码解码器，并分别将自定义的mqtt消息处理handle类和http消息handle类...
Netty - Socket.io
aRtHuR1207的博客
09-25 3141
注意，这里存在一个关键点：需要设置自定义存储工厂，以便获取 AuthorizationResult 中的 storeParams。在本示例中，我们采用 Redisson 作为存储工厂。修改nacos配置socketio:# redis服务redis:sentinel:更新socketio启动配置类/***/@Slf4j@Autowired@Autowired@Autowired@Autowired@Autowired。
netty实战-启动一个简单http服务器
qq_33791052的博客
10-26 326
搭建一个简单的http服务器 搭建http服务器，配置相关参数并启动 从浏览器或者终端发起请求 得到响应 maven依赖 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.42.Final</version> </dependency&g
基于netty-websocket-springboot搭建IM通讯
qq_50743124的博客
08-07 845
本文基于文本进行通信，可以自行修改成二进制通信
Netty实现一个简单的Http服务器
q160336802的博客
03-10 5446
Netty简单介绍，Netty实现简单http服务器
基于netty构建http服务器
热门推荐
morris
11-24 1万+
基于netty构建http服务器 基于Netty构建Http服务的流程如下： Client向Server发送http请求。 Server端对http请求进行解析。 Server端向Client发送http响应。 Client对http响应进行解析。 流程图如下： 服务器端实现 package com.morris.netty.protocol.http; import io.netty.bootstrap.ServerBootstrap; import io.netty.buffer.ByteBuf
Netty实现HTTP服务器端（一）
weixin_34150224的博客
05-27 231
2019独角兽企业重金招聘Python工程师标准>>> ...
简单使用netty搭建一个http服务器
收破烂的小熊猫
11-25 1707
世上无难事,只要肯登攀。——毛泽东 Netty的入门使用 常见的http服务器有Tomcat、jetty等，netty也可以方便的开发一个Http服务器。 想要完整的实现一个高性能、功能完善的http服务器非常的复杂，本文仅为了方便理解 Netty 网络应用开发的基本过程，所以只实现最基本的请求响应的流程： 搭建 HTTP 服务器，配置相关参数并启动。 从浏览器或者终端发起 HTTP 请求。 成功得到服务端的响应结果。 准备工作 先创建一个maven项目，引入netty依赖，这里使用4.1.52...
Netty搭建http服务端
archer的技术故事
09-02 1148
最近一直在看netty的相关资料。现在模拟一个简单的http服务端程序： package com.xueyou.demo.server; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; im...
netty创建http服务
cxxiaoyuan的博客
02-08 1059
使用netty4创建http服务，代码如下： NettyHttpServer:import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.EventLoopG...
netty服务器搭建-http
Aaron_lovesky的博客
12-22 433
netty+http+handler
Netty 实现HTTP文件服务器
weixin_34197488的博客
04-07 239
一，需求 文件服务器使用HTTP协议对外提供服务。用户通过浏览器访问文件服务器，首先对URL进行检查，若失败返回403错误；若通过校验，以链接的方式打开当前目录，每个目录或文件都以超链接的形式展现，可递归访问，并下载文件。   二，关键实现代码 ①文件服务器启动类 需要添加的通道处理器如下： @Override protected void ini...
利用netty实现一个http服务器
miaoxu9999的专栏
08-11 493
主要分为五个步骤 设置主从线程组 设置服务器启动类 为服务器设置channel 设置启动类的助手类 监听和关闭 接下来解释为什么会有这五步： 为什么设置主从线程组 放张图，讲述线程模型 为什么设置服务器启动类 这个服务器启动类，在我看来，相当于管理中心，他负责整体调度，和初始化设置，比如，我们之前创建了主从线程组，他要管理主从线程组，要不然，之前，创建的线程组，放在那里，怎么用，没人管啊！所以...
Netty与JAX-RS结合构建高效HTTP服务
Netty通过它的异步特性、事件循环和可插拔的通信机制能够提供一个稳定的服务器平台，而JAX-RS提供了一组丰富的注解，让开发者能够通过简单的声明式接口来定义资源、映射HTTP方法到方法调用以及管理内容的序列化和反...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值