Java SpringMVC Netty
首先，必须要了解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代码

  1. package com.fcant.netty.server;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.web.servlet.DispatcherServlet;
  7. import io.netty.bootstrap.ServerBootstrap;
  8. import io.netty.channel.ChannelFuture;
  9. import io.netty.channel.ChannelOption;
  10. import io.netty.channel.EventLoopGroup;
  11. import io.netty.channel.nio.NioEventLoopGroup;
  12. import io.netty.channel.socket.nio.NioServerSocketChannel;
  14. import com.fcant.netty.HttpServerInitializer;
  16. public class NettyHttpServer {
  18.     private int port;
  19.     private static Logger log = LoggerFactory.getLogger(NettyHttpServer.class);
  20.     private DispatcherServlet servlet;
  22.     public NettyHttpServer(Integer port) {
  23.         this.port = port;
  24.     }
  25.     public NettyHttpServer(Integer port, DispatcherServlet servlet) {
  26.         this.port = port;
  27.         this.servlet = servlet;
  28.     }
  30.     public void start(){
  31.         EventLoopGroup bossGroup = new NioEventLoopGroup();
  32.         EventLoopGroup workerGroup = new NioEventLoopGroup();
  33.         try {
  34.             ServerBootstrap b = new ServerBootstrap();
  35.             b.group(bossGroup, workerGroup)
  36.                 .channel(NioServerSocketChannel.class)
  37.                 .childHandler(new HttpServerInitializer(servlet))
  38.                 .option(ChannelOption.SO_BACKLOG, 128)
  39.                 .childOption(ChannelOption.SO_KEEPALIVE, true);
  41.             System.out.println("NettyHttpServer Run successfully");
  42.             // 绑定端口，开始接收进来的连接
  43.             ChannelFuture f = b.bind(port).sync();
  44.             // 等待服务器 socket 关闭 。在这个例子中，这不会发生，但你可以优雅地关闭你的服务器。
  45.             f.channel().closeFuture().sync();
  46.         } catch (Exception e) {
  47.             log.error("NettySever start fail",e);
  48.         } finally {
  49.             workerGroup.shutdownGracefully();
  50.             bossGroup.shutdownGracefully();
  51.         }
  52.     }
  53. }

2、初始化netty的channel管道

  1. package com.fcant.netty;
  3. import org.springframework.web.servlet.DispatcherServlet;
  5. import io.netty.channel.ChannelInitializer;
  6. import io.netty.channel.ChannelPipeline;
  7. import io.netty.channel.socket.SocketChannel;
  8. import io.netty.handler.codec.http.HttpContentCompressor;
  9. import io.netty.handler.codec.http.HttpObjectAggregator;
  10. import io.netty.handler.codec.http.HttpRequestDecoder;
  11. import io.netty.handler.codec.http.HttpResponseEncoder;
  12. import io.netty.handler.stream.ChunkedWriteHandler;
  16. public class HttpServerInitializer extends ChannelInitializer<SocketChannel> {
  18.     private DispatcherServlet servlet;
  20.     public HttpServerInitializer(DispatcherServlet servlet) {
  21.         this.servlet = servlet;
  22.     }
  23.     public HttpServerInitializer() {
  25.     }
  27.     @Override
  28.     protected void initChannel(SocketChannel ch) throws Exception {
  29.         ChannelPipeline pipeline = ch.pipeline();
  30.         pipeline.addLast("decoder", new HttpRequestDecoder());
  31.         pipeline.addLast("encoder", new HttpResponseEncoder());
  32.         pipeline.addLast("aggregator", new HttpObjectAggregator(2147483647));
  33.         pipeline.addLast("chunkedWriter", new ChunkedWriteHandler());
  34.         pipeline.addLast("deflater", new HttpContentCompressor());
  35.         pipeline.addLast("handler", new HttpRequestHandler(servlet));
  36.     }
  37. }

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

  2. package com.fcant.netty;
  4. import java.io.UnsupportedEncodingException;
  5. import java.net.URLDecoder;
  6. import java.util.HashMap;
  7. import java.util.Iterator;
  8. import java.util.List;
  9. import java.util.Map;
  10. import java.util.Map.Entry;
  12. import javax.servlet.ServletContext;
  14. import io.netty.buffer.ByteBuf;
  15. import io.netty.buffer.Unpooled;
  16. import io.netty.channel.ChannelFuture;
  17. import io.netty.channel.ChannelFutureListener;
  18. import io.netty.channel.ChannelHandlerContext;
  19. import io.netty.channel.SimpleChannelInboundHandler;
  20. import io.netty.handler.codec.http.*;
  21. import io.netty.handler.codec.http.multipart.DefaultHttpDataFactory;
  22. import io.netty.handler.codec.http.multipart.HttpPostRequestDecoder;
  23. import io.netty.handler.codec.http.multipart.InterfaceHttpData;
  24. import io.netty.handler.codec.http.multipart.InterfaceHttpData.HttpDataType;
  25. import io.netty.handler.codec.http.multipart.MemoryAttribute;
  26. import io.netty.util.CharsetUtil;
  28. import org.apache.commons.lang3.StringUtils;
  29. import org.slf4j.Logger;
  30. import org.slf4j.LoggerFactory;
  31. import org.springframework.mock.web.MockHttpServletRequest;
  32. import org.springframework.mock.web.MockHttpServletResponse;
  33. import org.springframework.web.servlet.DispatcherServlet;
  34. import org.springframework.web.util.UriComponents;
  35. import org.springframework.web.util.UriComponentsBuilder;
  36. import org.springframework.web.util.UriUtils;
  38. public class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
  40.     private static final Logger logger = LoggerFactory.getLogger(HttpRequestHandler.class);
  41.     private final DispatcherServlet servlet;
  42.     private final ServletContext servletContext;
  44.     public HttpRequestHandler(DispatcherServlet servlet) {
  45.         this.servlet = servlet;
  46.         this.servletContext = servlet.getServletConfig().getServletContext();
  47.     }
  49.     @Override
  50.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable e) throws Exception {
  51.         logger.error(e.getMessage(),e);
  52.         ctx.close();
  53.     }
  55.     protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest fullHttpRequest) throws Exception {
  56.         boolean flag = HttpMethod.POST.equals(fullHttpRequest.getMethod())
  57.             || HttpMethod.GET.equals(fullHttpRequest.getMethod());
  59.         Map<String, String>  parammap = getRequestParams(ctx,fullHttpRequest);
  60.         if(flag && ctx.channel().isActive()){
  61.             //HTTP请求、GET/POST
  62.             MockHttpServletResponse servletResponse = new MockHttpServletResponse();
  63.             MockHttpServletRequest servletRequest =new MockHttpServletRequest(servletContext);
  64.             // headers
  65.             for (String name : fullHttpRequest.headers().names()) {
  66.                 for (String value : fullHttpRequest.headers().getAll(name)) {
  67.                     servletRequest.addHeader(name, value);
  68.                 }
  69.             }
  70.             String uri = fullHttpRequest.getUri();
  71.             uri = new String(uri.getBytes("ISO8859-1"), "UTF-8");
  72.             uri = URLDecoder.decode(uri, "UTF-8");
  73.             UriComponents uriComponents = UriComponentsBuilder.fromUriString(uri).build();
  74.             String path = uriComponents.getPath();
  75.             path = URLDecoder.decode(path, "UTF-8");
  76.             servletRequest.setRequestURI(path);
  77.             servletRequest.setServletPath(path);
  78.             servletRequest.setMethod(fullHttpRequest.getMethod().name());
  80.             if (uriComponents.getScheme() != null) {
  81.                 servletRequest.setScheme(uriComponents.getScheme());
  82.             }
  83.             if (uriComponents.getHost() != null) {
  84.                 servletRequest.setServerName(uriComponents.getHost());
  85.             }
  86.             if (uriComponents.getPort() != -1) {
  87.                 servletRequest.setServerPort(uriComponents.getPort());
  88.             }
  90.             ByteBuf content = fullHttpRequest.content();
  91.             content.readerIndex(0);
  92.             byte[] data = new byte[content.readableBytes()];
  93.             content.readBytes(data);
  94.             servletRequest.setContent(data);
  96.             try {
  97.                 if (uriComponents.getQuery() != null) {
  98.                     String query = UriUtils.decode(uriComponents.getQuery(),"UTF-8");
  99.                     servletRequest.setQueryString(query);
  100.                 }
  101.                 if(parammap!=null&&parammap.size()>0){
  102.                     for (String key : parammap.keySet()) {
  103.                         servletRequest.addParameter(UriUtils.decode(key,"UTF-8"), UriUtils.decode(parammap.get(key) == null ? "": parammap.get(key), "UTF-8"));
  104.                     }
  105.                 }
  107.             } catch (UnsupportedEncodingException ex) {
  108.                 ex.printStackTrace();
  109.             }
  110.             this.servlet.service(servletRequest,servletResponse);
  112.             HttpResponseStatus status = HttpResponseStatus.valueOf(servletResponse.getStatus());
  113.             String result = servletResponse.getContentAsString();
  114.             result = StringUtils.isEmpty(result)?"":result;
  115.             FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status,Unpooled.copiedBuffer(result,CharsetUtil.UTF_8));
  116.             response.headers().set("Content-Type", "text/json;charset=UTF-8");
  117.             response.headers().set("Access-Control-Allow-Origin", "*");
  118.             response.headers().set("Access-Control-Allow-Headers", "Content-Type,Content-Length, Authorization, Accept,X-Requested-With,X-File-Name");
  119.             response.headers().set("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
  120.             response.headers().set("Content-Length", Integer.valueOf(response.content().readableBytes()));
  121.             response.headers().set("Connection", "keep-alive");
  122.             ChannelFuture writeFuture = ctx.writeAndFlush(response);
  123.             writeFuture.addListener(ChannelFutureListener.CLOSE);
  124.         }
  125.     }
  127.     /**
  128.      * 获取post请求、get请求的参数保存到map中
  129.      */
  130.     private Map<String, String> getRequestParams(ChannelHandlerContext ctx, HttpRequest req){
  131.         Map<String, String>requestParams=new HashMap<String, String>();
  132.         // 处理get请求  
  133.         if (req.getMethod() == HttpMethod.GET) {
  134.             QueryStringDecoder decoder = new QueryStringDecoder(req.getUri());  
  135.             Map<String, List<String>> parame = decoder.parameters();  
  136.             Iterator<Entry<String, List<String>>> iterator = parame.entrySet().iterator();
  137.             while(iterator.hasNext()){
  138.                 Entry<String, List<String>> next = iterator.next();
  139.                 requestParams.put(next.getKey(), next.getValue().get(0));
  140.             }
  141.         }
  142.         // 处理POST请求  
  143.         if (req.getMethod() == HttpMethod.POST) {
  144.             HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(  
  145.                 new DefaultHttpDataFactory(false), req);  
  146.             List<InterfaceHttpData> postData = decoder.getBodyHttpDatas(); //
  147.             for(InterfaceHttpData data:postData){
  148.                 if (data.getHttpDataType() == HttpDataType.Attribute) {  
  149.                     MemoryAttribute attribute = (MemoryAttribute) data;  
  150.                     requestParams.put(attribute.getName(), attribute.getValue());
  151.                 }
  152.             }
  153.         }
  154.         return requestParams;
  155.     }
  157. }

4、初始化servlet并启动netty server

  1. package com.fcant;
  3. import javax.servlet.ServletException;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.context.ApplicationContext;
  8. import org.springframework.context.support.ClassPathXmlApplicationContext;
  9. import org.springframework.mock.web.MockServletConfig;
  10. import org.springframework.web.context.support.XmlWebApplicationContext;
  11. import org.springframework.web.servlet.DispatcherServlet;
  13. import com.fcant.common.config.PropConfig;
  14. import com.fcant.netty.server.NettyHttpServer;
  16. public class MagicWebServer {
  18.     private static Logger logger = LoggerFactory.getLogger(MagicWebServer.class);
  20.     public static void main(String[] args) {
  21.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  22.         Integer port = 6001;
  23.         DispatcherServlet servlet = getDispatcherServlet(ctx);
  24.         NettyHttpServer server = new NettyHttpServer(port,servlet);
  25.         server.start();
  27.     }
  29.     public static DispatcherServlet getDispatcherServlet(ApplicationContext ctx){
  31.         XmlWebApplicationContext mvcContext = new XmlWebApplicationContext();
  32.         mvcContext.setConfigLocation("classpath:spring-servlet.xml");
  33.         mvcContext.setParent(ctx);
  34.         MockServletConfig servletConfig = new MockServletConfig(mvcContext.getServletContext(), "dispatcherServlet");
  35.         DispatcherServlet dispatcherServlet = new DispatcherServlet(mvcContext);
  36.         try {
  37.             dispatcherServlet.init(servletConfig);
  38.         } catch (ServletException e) {
  39.             e.printStackTrace();
  40.         }
  41.         return dispatcherServlet;
  42.     }
  43. }

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

  1. package com.fcant.controller;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. import org.springframework.stereotype.Controller;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.ResponseBody;
  10. import com.alibaba.fastjson.JSONObject;
  12. @Controller
  13. @RequestMapping(value="/user",produces = "text/json;charset=utf-8")
  14. public class UserController extends BaseController{
  16.     @RequestMapping("/login")
  17.     @ResponseBody
  18.     public String login(String username,String pwd){
  19.         JSONObject resultJson = new JSONObject();
  20.         Map<String, String> loginResult = new HashMap<String, String>();
  21.         loginResult.put("username", username);
  22.         loginResult.put("age", "20");
  23.         loginResult.put("sex", "boy");
  25.         resultJson.put("code", 200);
  26.         resultJson.put("msg", "登录成功");
  27.         resultJson.put("result", loginResult);
  29.         return JSONObject.toJSONString(resultJson);
  30.     }
  31. }

在coding的时候遇到的问题

  • 代码中的applicationContext.xml和spring-servlet.xml的按照SpringMVC的正常配置就行
  • 如果返回到client端的代码有中文乱码，那么在requestMapping里面添加produces = "text/json;charset=utf-8"。