Netty整合SpringMVC，实现高效的HTTP服务请求

最新推荐文章于 2024-04-23 18:52:22 发布
最新推荐文章于 2024-04-23 18:52:22 发布
阅读量958 收藏 1
点赞数
文章标签： 中间件 java glassfish entity servlet
原文链接：https://mp.weixin.qq.com/s?__biz=MzUxOTc4NjEyMw==&mid=2247527027&idx=2&sn=f04a490ec5fdfa9c539e9a1f16ed3753&chksm=f9f67197ce81f8819cd15ae552884b5c0c4db747e26a9a40e907845881193c55c55e547c7aba&scene=126&&sessionid=0
版权

点击上方“Java基基”，选择“设为星标”

做积极的人，而不是积极废人！

每天 14:00 更新文章，每天掉亿点点头发...

源码精品专栏

 

来源：blog.csdn.net/shzy1988/

article/details/78841140

dde24d3c3a8b269bd12a4af1385501eb.png

首先，你必须要了解netty，说简单点：客户端通过TCP链接和服务器建立长连接，client和server都是通过管道（ChannelPipeline）的addLast方法的添加顺序来处理接收或者发送的数据。

这个和struts的filter的doFilter原理类似，处理完一个filter，如果后面还有其他的filter，就将数据chain.doFilter来继续处理。

然后，说说netty怎么来整合springMVC：当client和server建立连接后，我们在addLast的某个类中将client发来的请求，让DispatcherServlet来处理，然后将处理后的结果通过ChannelHandlerContext或者Channel将,结果writeAndFlush到client。

1.写一个netty sever的java代码

package com.magic.netty.server;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.DispatcherServlet;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

import com.magic.netty.HttpServerInitializer;

public class NettyHttpServer {

 public NettyHttpServer(Integer port) {
  this.port = port;
 }
 public NettyHttpServer(Integer port, DispatcherServlet servlet) {
  this.port = port;
  this.servlet = servlet;
 }

 public void start(){
  EventLoopGroup bossGroup = new NioEventLoopGroup();
  EventLoopGroup workerGroup = new NioEventLoopGroup();
  try {
   ServerBootstrap b = new ServerBootstrap();
   b.group(bossGroup, workerGroup)
     .channel(NioServerSocketChannel.class)
     .childHandler(new HttpServerInitializer(servlet))
     .option(ChannelOption.SO_BACKLOG, 128)
     .childOption(ChannelOption.SO_KEEPALIVE, true);

   System.out.println("NettyHttpServer Run successfully");
   // 绑定端口，开始接收进来的连接
   ChannelFuture f = b.bind(port).sync();
   // 等待服务器 socket 关闭 。在这个例子中，这不会发生，但你可以优雅地关闭你的服务器。
   f.channel().closeFuture().sync();
  } catch (Exception e) {
   log.error("NettySever start fail",e);
  } finally {
   workerGroup.shutdownGracefully();
   bossGroup.shutdownGracefully();
  }
 }
 private int port;
 private static Logger log = LoggerFactory.getLogger(NettyHttpServer.class);
 private DispatcherServlet servlet;
}

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能。

项目地址：https://github.com/YunaiV/ruoyi-vue-pro

2.初始化netty的channel管道

package com.magic.netty;

import org.springframework.web.servlet.DispatcherServlet;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpContentCompressor;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpRequestDecoder;
import io.netty.handler.codec.http.HttpResponseEncoder;
import io.netty.handler.stream.ChunkedWriteHandler;



public class HttpServerInitializer extends ChannelInitializer<SocketChannel> {

 public HttpServerInitializer(DispatcherServlet servlet) {
  this.servlet = servlet;
 }
 public HttpServerInitializer() {
  
 }

 @Override
 protected void initChannel(SocketChannel ch) throws Exception {
  ChannelPipeline pipeline = ch.pipeline();
  pipeline.addLast("decoder", new HttpRequestDecoder());
  pipeline.addLast("encoder", new HttpResponseEncoder());
  pipeline.addLast("aggregator", new HttpObjectAggregator(2147483647));
  pipeline.addLast("chunkedWriter", new ChunkedWriteHandler());
        pipeline.addLast("deflater", new HttpContentCompressor());
        pipeline.addLast("handler", new HttpRequestHandler(servlet));
 }
 private DispatcherServlet servlet;
}

基于微服务的思想，构建在 B2C 电商场景下的项目实战。核心技术栈，是 Spring Boot + Dubbo 。未来，会重构成 Spring Cloud Alibaba 。

项目地址：https://github.com/YunaiV/onemall

3.在handler里面处理client发来的请求

package com.magic.netty;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.servlet.ServletContext;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.handler.codec.http.multipart.DefaultHttpDataFactory;
import io.netty.handler.codec.http.multipart.HttpPostRequestDecoder;
import io.netty.handler.codec.http.multipart.InterfaceHttpData;
import io.netty.handler.codec.http.multipart.InterfaceHttpData.HttpDataType;
import io.netty.handler.codec.http.multipart.MemoryAttribute;
import io.netty.util.CharsetUtil;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.util.UriComponents;
import org.springframework.web.util.UriComponentsBuilder;
import org.springframework.web.util.UriUtils;

public class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

    public HttpRequestHandler(DispatcherServlet servlet) {
  this.servlet = servlet;
  this.servletContext = servlet.getServletConfig().getServletContext();
 }

 @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable e) throws Exception {
     logger.error(e.getMessage(),e);
        ctx.close();
    }

    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest fullHttpRequest) throws Exception {
     boolean flag = HttpMethod.POST.equals(fullHttpRequest.getMethod())
                || HttpMethod.GET.equals(fullHttpRequest.getMethod());
        
        Map<String, String>  parammap = getRequestParams(ctx,fullHttpRequest);
        if(flag && ctx.channel().isActive()){
            //HTTP请求、GET/POST
            MockHttpServletResponse servletResponse = new MockHttpServletResponse();
            MockHttpServletRequest servletRequest =new MockHttpServletRequest(servletContext);
            // headers
            for (String name : fullHttpRequest.headers().names()) {
                for (String value : fullHttpRequest.headers().getAll(name)) {
                    servletRequest.addHeader(name, value);
                }
            }
            String uri = fullHttpRequest.getUri();
            uri = new String(uri.getBytes("ISO8859-1"), "UTF-8");
            uri = URLDecoder.decode(uri, "UTF-8");
            UriComponents uriComponents = UriComponentsBuilder.fromUriString(uri).build();
            String path = uriComponents.getPath();
            path = URLDecoder.decode(path, "UTF-8");
            servletRequest.setRequestURI(path);
            servletRequest.setServletPath(path);
            servletRequest.setMethod(fullHttpRequest.getMethod().name());

            if (uriComponents.getScheme() != null) {
                servletRequest.setScheme(uriComponents.getScheme());
            }
            if (uriComponents.getHost() != null) {
                servletRequest.setServerName(uriComponents.getHost());
            }
            if (uriComponents.getPort() != -1) {
                servletRequest.setServerPort(uriComponents.getPort());
            }

            ByteBuf content = fullHttpRequest.content();
            content.readerIndex(0);
            byte[] data = new byte[content.readableBytes()];
            content.readBytes(data);
            servletRequest.setContent(data);

            try {
                if (uriComponents.getQuery() != null) {
                    String query = UriUtils.decode(uriComponents.getQuery(),"UTF-8");
                    servletRequest.setQueryString(query);
                }
                if(parammap!=null&&parammap.size()>0){
                 for (String key : parammap.keySet()) {
                        servletRequest.addParameter(UriUtils.decode(key,"UTF-8"), UriUtils.decode(parammap.get(key) == null ? "": parammap.get(key), "UTF-8"));
                    }
                }
                
            } catch (UnsupportedEncodingException ex) {
             ex.printStackTrace();
            }
            this.servlet.service(servletRequest,servletResponse);

            HttpResponseStatus status = HttpResponseStatus.valueOf(servletResponse.getStatus());
            String result = servletResponse.getContentAsString();
            result = StringUtils.isEmpty(result)?"":result;
            FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status,Unpooled.copiedBuffer(result,CharsetUtil.UTF_8));
            response.headers().set("Content-Type", "text/json;charset=UTF-8");
            response.headers().set("Access-Control-Allow-Origin", "*");
            response.headers().set("Access-Control-Allow-Headers", "Content-Type,Content-Length, Authorization, Accept,X-Requested-With,X-File-Name");
            response.headers().set("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
            response.headers().set("Content-Length", Integer.valueOf(response.content().readableBytes()));
            response.headers().set("Connection", "keep-alive");
            ChannelFuture writeFuture = ctx.writeAndFlush(response);
            writeFuture.addListener(ChannelFutureListener.CLOSE);
        }
    }

  /**
     * 获取post请求、get请求的参数保存到map中
     */
    private Map<String, String> getRequestParams(ChannelHandlerContext ctx, HttpRequest req){
        Map<String, String>requestParams=new HashMap<String, String>();
        // 处理get请求  
        if (req.getMethod() == HttpMethod.GET) {
            QueryStringDecoder decoder = new QueryStringDecoder(req.getUri());  
            Map<String, List<String>> parame = decoder.parameters();  
            Iterator<Entry<String, List<String>>> iterator = parame.entrySet().iterator();
            while(iterator.hasNext()){
                Entry<String, List<String>> next = iterator.next();
                requestParams.put(next.getKey(), next.getValue().get(0));
            }
        }
         // 处理POST请求  
        if (req.getMethod() == HttpMethod.POST) {
            HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(  
                    new DefaultHttpDataFactory(false), req);  
            List<InterfaceHttpData> postData = decoder.getBodyHttpDatas(); //
            for(InterfaceHttpData data:postData){
                if (data.getHttpDataType() == HttpDataType.Attribute) {  
                    MemoryAttribute attribute = (MemoryAttribute) data;  
                    requestParams.put(attribute.getName(), attribute.getValue());
                }
            }
        }
        return requestParams;
    }

 private static final Logger logger = LoggerFactory.getLogger(HttpRequestHandler.class);
 private final DispatcherServlet servlet;
 private final ServletContext servletContext;
}

4.初始化servlet并启动netty server

package com.magic;

import javax.servlet.ServletException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.mock.web.MockServletConfig;
import org.springframework.web.context.support.XmlWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

import com.magic.common.config.PropConfig;
import com.magic.netty.server.NettyHttpServer;

public class MagicWebServer {
 
 private static Logger logger = LoggerFactory.getLogger(MagicWebServer.class);

 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  Integer port = 6001;
  DispatcherServlet servlet = getDispatcherServlet(ctx);
  NettyHttpServer server = new NettyHttpServer(port,servlet);
  server.start();
  
 }
 
 public static DispatcherServlet getDispatcherServlet(ApplicationContext ctx){

     XmlWebApplicationContext mvcContext = new XmlWebApplicationContext();
  mvcContext.setConfigLocation("classpath:spring-servlet.xml");
  mvcContext.setParent(ctx);
  MockServletConfig servletConfig = new MockServletConfig(mvcContext.getServletContext(), "dispatcherServlet");
  DispatcherServlet dispatcherServlet = new DispatcherServlet(mvcContext);
  try {
   dispatcherServlet.init(servletConfig);
  } catch (ServletException e) {
   e.printStackTrace();
  }
  return dispatcherServlet;
 }
}

5.写一个controller，并测试一波http://127.0.0.1:6001/user/login

package com.magic.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.alibaba.fastjson.JSONObject;

@Controller
@RequestMapping(value="/user",produces = "text/json;charset=utf-8")
public class UserController extends BaseController{

 @RequestMapping("/login")
 @ResponseBody
 public String login(String username,String pwd){
  JSONObject resultJson = new JSONObject();
  Map<String, String> loginResult = new HashMap<String, String>();
  loginResult.put("username", username);
  loginResult.put("age", "20");
  loginResult.put("sex", "boy");
  
  resultJson.put("code", 200);
  resultJson.put("msg", "登录成功");
  resultJson.put("result", loginResult);
  
  return JSONObject.toJSONString(resultJson);
 }
}

Mark一下，说明在coding的时候遇到的问题

  • 代码中的applicationContext.xml和spring-servlet.xml的按照springMVC的正常配置就行

  • 如果返回到client端的代码有中文乱码，那么在requestMapping里面添加produces = “text/json;charset=utf-8”。

欢迎加入我的知识星球，一起探讨架构，交流源码。加入方式，长按下方二维码噢：

c2649073e4682fbdd6b6d62984f10375.png

已在知识星球更新源码解析如下：

08e01fa8c86ef1e610a6b11b416a3cb7.png

ed2be42404a5a3d3030cb2fe760392db.png

9bdf3b115aadc73b21bb73db0c45ed27.png

4919b8891c209fa26ff04b4829fe8af0.png

最近更新《芋道 SpringBoot 2.X 入门》系列，已经 101 余篇，覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例，以及超 6W 行代码的电商微服务项目。

获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。

文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）
Java基基
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring-netty:springmvc netty集成
04-27
spring-netty spring netty集成的websocket聊天demo 需要建表并配置数据库信息，聊天用户登录表 本项目为聊天测试项目，tomcat启动后访问 会看到聊天页面，发送{"loginid":"你的ID","username":"姓名"}可模拟登录。 打开多个窗口并登录，然后发送消息即可看到多人聊天效果。 netty的介绍可见我的CSDN
基于Netty实现SpringMVC
hanxiaozhang的博客
05-03 1205
前言： Netty是一个非常优秀的异步事件驱动的网络通信框架，它本身就支持HTTP协议栈的开发。由于Netty是对Java NIO的封装，因此基于Netty开发的HTTP协议栈也是异步非阻塞的。并且Netty相对传统的Web容器（例如Tomcat、Jetty）会更加轻量、小巧、定制化开发也很灵活。 SpringMVC是一个轻量级的Web框架，它可以把用户使用浏览器产生的HTTP请求解析成视图，再响应给浏览器。实现该过程的最重要的一个组件是DispatcherServle...
netty 处理http请求
weixin_43931625的博客
05-28 2024
netty 处理http请求
由netty去看http springMVC 执行流程（一）
q568213372的博客
03-24 1130
        最近在想过用netty结合springmvc,所以有过一些对spring的想法.     在用spring时，程序是由Applicationcontext加载。但springmvc的话需要一个WebApplicationContext.因为javaWeb的http是基于请求响应的设计模式。基于socket的TCP/IP超文本协议。socket原理而知道 。http也监听了端口。等待...
netty整合springmvc
weixin_33994444的博客
10-14 346
2019独角兽企业重金招聘Python工程师标准>>> ...
Netty 实现http请求 并响应
AP0906424的博客
11-02 5080
什么是Netty? Netty 是一个利用Java 的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的API 的客户端/服务器 框架。 Netty 与 Tomcat Netty与tomcat 最大的区别在于通信协议。Tomcat 是基于Http 协议的，它的实质是一个基于Http协议的web 容器。 但是Netty 不一样，它能通过编程自定义各种协议，因为netty能够通过codec 自己来编码/解码 字节流。完成类似redis访问的功能。 这就是netty 和tomcat 最大的不同 N
Netty使用篇：Http协议编解码
热门推荐
七叔的博客
11-20 2万+
Netty：Http协议编解码
SpringMVC项目同时启动Netty服务，并解决Netty服务中Dao层依赖注入为null问题
vbniepwq的博客
04-09 906
前言： 项目为SpringMVC架构，在此基础上新增加了Netty服务用来接收客户端发来的消息，在Netty的handler业务处理类内需要将消息存入数据库。 流程： 先看一下包的结构图 按照此包结构图奉上精心修改过的伪代码，基本上可以拿走就直接使用的 图片蓝色背景的都为netty（ats）相关服务新增加的文件 1.netty服务端，实现了Runnable接口，为的是可以在重写的run()方法内启动服务端（没整合之前是在下边写了一个main函数启动的，当然也没有实现Runnable接口）；因为在初始化时候
Netty实现http请求处理
afggg_的博客
03-29 772
Netty实现http请求处理
netty_springMvc:基于netty ,http默认跳转controller层,webSocket 走专门通道
05-14
netty_springMvc 基于netty ,http默认跳转controller层,webSocket 走专门通道 工程目标是支持eureka调用,使微服务通过http协议发送websocket给浏览器
netty整合SpringMVC实现下载
06-01
netty4.1整合SrpingMVC实现文件下载功能
Netty-SpringMVC:SpringMVC文件配置化
06-28
Netty-SpringMVC 是一个netty、SpingMVC集成是例子。这种框架主要应用于SOA的架构中充当服务提供者， 用传统的springMVC+web容器也可以做。这套框架中netty就扮演了容器的角色，Netty采用了NIO的方式， 在IO密集型...
Java Netty HTTP服务实现过程解析
08-18
主要介绍了Java Netty HTTP服务实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring boot整合netty的实现方法
08-25
主要介绍了spring boot整合netty的实现方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Netty + ZooKeeper 实现简单的服务注册与发现
08-25
服务注册和发现一直是分布式的核心组件。本文介绍了借助 ZooKeeper 做注册中心，如何实现一个简单的服务注册和发现。,需要的朋友可以参考下
Laravel 6 - 第十一章 中间件
逆旅岁月的博客
04-20 912
使用中间件可以轻松地过滤、修改进入应用程序的请求。
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 337
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1441
c++中string的模拟实现，面试必会知识点
Netty 可以创建Http请求服务器吗
05-22
是的，Netty可以创建HTTP请求服务器。Netty是一个网络编程框架，可以处理各种协议，包括HTTP协议。使用Netty创建HTTP服务器非常简单，你只需要编写一个HTTP请求处理器并将其注册到Netty服务器的ChannelPipeline中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值