2. 程式人生 > >曹工雜談：Spring boot應用，自己動手用Netty替換底層Tomcat容器

曹工雜談：Spring boot應用，自己動手用Netty替換底層Tomcat容器

阿新 • • 發佈：2019-12-10

前言

問：標題說的什麼意思？

答：簡單說，一個spring boot應用（我這裡，版本升到2.1.7.Release了，沒什麼問題），預設使用了tomcat作為底層容器來接收和處理連線。 我這裡，在依賴中排除了tomcat，使用Netty作為了替代品。優勢在於，啟動飛快，執行緒數量完全可控（多少個netty的boss、worker執行緒，多少個業務執行緒），如果能優化得好，效率會很高（我這個還有很多優化空間，見文末總結）

流程圖如下（中間的三個handler是自定義的）：

這個東西，年初我就弄出來了，然後用在了某個我負責的微服務裡，之前一直想寫，但是一直沒把demo程式碼從微服務裡抽出來，然後就一直拖著。前一陣吧，把程式碼抽出來了，然後又覺得要優化下，不然有些低階問題怎麼辦？

前一陣抽了程式碼出來，然後想著優化下，結果忙起來搞忘了，而且優化無底洞啊，所以先不優化了，略微補了些註釋，就發上來了，希望大家看到後，多多批評指正。

先附上程式碼地址：https://gitee.com/ckl111/Netty_Spring_MVC_Sample/

啟動後，訪問：http://localhost:8081/test.do即可。

實現大體思路

  1. 排除掉tomcat依賴
  2. 解決掉報錯，保證spring mvc的上下文正常啟動
  3. 啟動netty容器，最後一個handler負責將servlet request交給dispatcherServlet處理

具體實現

解決dispatcherServlet不能正常工作的問題

問題1：缺少servletContext報錯

經過追蹤發現，這個servletContext來源於：org.springframework.web.context.support.GenericWebApplicationContext中的servletContext欄位

解決辦法：

在META-INF/spring.factories中，定義了一個listener，來參與spring boot啟動時的生命週期：

org.springframework.boot.SpringApplicationRunListener=com.ceiec.router.config.MyListener

在我的自定義listener中，實現org.springframework.boot.SpringApplicationRunListener

，然後重寫如下方法：

package com.ceiec.router.config;

import com.ceiec.router.config.servletconfig.MyServletContext;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringApplicationRunListener;
import org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MapPropertySource;
import org.springframework.core.env.MutablePropertySources;
import org.springframework.core.env.PropertySource;

import javax.servlet.ServletContext;
import java.util.Map;

@Data
@Slf4j
public class MyListener implements SpringApplicationRunListener {


    public MyListener(SpringApplication application, String[] args) {
        super();
    }
    ...
    
    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        // 這裡手動new一個servletContext，然後設定給spring上下文
        ServletContext servletContext = new MyServletContext();
        ServletWebServerApplicationContext applicationContext = (ServletWebServerApplicationContext) context;
        applicationContext.setServletContext(servletContext);
    }
  
  ...

}

自定義實現了com.ceiec.router.config.servletconfig.MyServletContext，這個很簡單，繼承spring test包中的org.springframework.mock.web.MockServletContext即可。

package com.ceiec.router.config.servletconfig;

import org.springframework.mock.web.MockServletContext;

import javax.servlet.Filter;
import javax.servlet.FilterRegistration;
import javax.servlet.Servlet;
import javax.servlet.ServletRegistration;

public class MyServletContext extends MockServletContext{

    @Override
    public ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet) {
        return null;
    }

    @Override
    public FilterRegistration.Dynamic addFilter(String filterName, Filter filter){
        return null;
    }
}

問題2：

暫時沒有。之前的版本本來有一個問題，升到spring boot 2.1.7後，好像不需要了，先不管。

問題3：

怎麼保證少了tomcat後，dispatcherServlet還能用？準確地說，dispatcherServlet這個東西和tomcat是兩回事，以前寫struts 2的時候，也沒dispatcherServlet這個類，不是嗎？

所以，在spring boot啟動時，並不強依賴底層容器，dispatcherServlet 這個bean會自動裝配，裝配程式碼在

org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration.DispatcherServletConfiguration

    @Configuration
    @Conditional(DefaultDispatcherServletCondition.class)
    @ConditionalOnClass(ServletRegistration.class)
    @EnableConfigurationProperties({ HttpProperties.class, WebMvcProperties.class })
    protected static class DispatcherServletConfiguration {

        private final HttpProperties httpProperties;

        private final WebMvcProperties webMvcProperties;

        //這裡自動裝配DispatcherServlet
        @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
        public DispatcherServlet dispatcherServlet() {
            DispatcherServlet dispatcherServlet = new DispatcherServlet();
            dispatcherServlet.setDispatchOptionsRequest(
                                this.webMvcProperties.isDispatchOptionsRequest());
            dispatcherServlet.setDispatchTraceRequest(
              this.webMvcProperties.isDispatchTraceRequest());
            return dispatcherServlet;
        }

問題4：

自動裝配DispatcherServlet後，處理請求時報錯：

解決方式是，啟動完成後，給dispatcherServlet設定這個field的值，同時，初始化我們的servlet（這裡提一句，還記得servlet的生命週期嗎，就是那個東西）：

import org.springframework.mock.web.MockServletConfig;
/**
 * 從spring上下文獲取 DispatcherServlet，設定其欄位config為mockServletConfig
 */
DispatcherServlet dispatcherServlet = applicationContext.getBean(DispatcherServlet.class);
MockServletConfig myServletConfig = new MockServletConfig();
MyReflectionUtils.setFieldValue(dispatcherServlet,"config",myServletConfig);

/**
 * 初始化servlet
 */
try {
  dispatcherServlet.init();
} catch (ServletException e) {
  log.error("e:{}",e);
}

netty處理過程

大致流程

這裡，我們再將總共流程圖貼一下：

中間的三個handler，是我們自定義的。每個handler具體做的事情，寫得比較清楚了。具體看下面的com.ceiec.router.netty.DispatcherServletChannelInitializer:

    public class DispatcherServletChannelInitializer extends ChannelInitializer<SocketChannel> {

    //可以使用單獨的執行緒池，來處理業務請求
    private static DefaultEventLoopGroup eventExecutors = new DefaultEventLoopGroup(4,new NamedThreadFactory("business_servlet"));

    @Override
    public void initChannel(SocketChannel channel) throws Exception {
        ChannelPipeline pipeline = channel.pipeline();

        // 對通訊資料進行編解碼
        pipeline.addLast(new HttpServerCodec());

        // 把多個HTTP請求中的資料組裝成一個
        pipeline.addLast(new HttpObjectAggregator(65536));

        // 用於處理大的資料流
        pipeline.addLast(new ChunkedWriteHandler());

        /**
         * 生成servlet使用的request
         */
        pipeline.addLast("GenerateServletRequestHandler", new GenerateServletRequestHandler());

        /**
         * 過濾器處理器，模擬servlet中的 filter 鏈
         */
        FilterNettyHandler filterNettyHandler = SpringContextUtils.getApplicationContext().getBean(FilterNettyHandler.class);
        pipeline.addLast("FilterNettyHandler", filterNettyHandler);

        /**
         * 真正的業務handler，轉交給：spring mvc的dispatcherServlet 處理
         */
        DispatcherServletHandler dispatcherServletHandler = SpringContextUtils.getApplicationContext().getBean(DispatcherServletHandler.class);
        //pipeline.addLast("dispatcherServletHandler", dispatcherServletHandler);
        // 使用下面的過載方法，第一個引數為執行緒池，則這裡會非同步執行我們的業務邏輯，正常也應該這樣，避免長時間阻塞io執行緒
        pipeline.addLast(eventExecutors,"handler", new ServletNettyHandler(dispatcherServlet));
    }


}

原始netty的http請求，轉成servlet http請求

其中，GenerateServletRequestHandler完成這部分工作，傳遞給下一個handler的，就是MockHttpServletRequest型別：

 @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, FullHttpRequest fullHttpRequest) throws Exception {
        if (!fullHttpRequest.decoderResult().isSuccess()) {
            sendError(channelHandlerContext, BAD_REQUEST);
            return;
        }

        // 設定請求的會話id
        String token = UUID.randomUUID().toString().replace("-", "");
        MDC.put(SESSION_KEY, token);

        String remoteIP = getRemoteIP(fullHttpRequest, channelHandlerContext);
        MockHttpServletRequest servletRequest = createServletRequest(fullHttpRequest);
        String s = fullHttpRequest.content().toString(CharsetUtil.UTF_8);

        log.info("{},request:{},param:{}", remoteIP, fullHttpRequest.uri(), s);
        try {
            channelHandlerContext.fireChannelRead(servletRequest);
        } finally {
            // 刪除SessionId
            MDC.remove(SESSION_KEY);
        }

    }

模擬servlet filter chain對請求進行處理

這裡說下，為什麼要使用spring來管理它，且型別為prototype，因為：每次請求進來，都會去呼叫

com.ceiec.router.netty.DispatcherServletChannelInitializer#initChannel，在那裡面是如下的從spring上下文獲取的方式來拿到FilterNettyHandler的。

@Override
    public void initChannel(SocketChannel channel) throws Exception {
        ChannelPipeline pipeline = channel.pipeline();
        ... 
        /**
         * 過濾器處理器，模擬servlet中的 filter 鏈
         */
        FilterNettyHandler filterNettyHandler = SpringContextUtils.getApplicationContext().getBean(FilterNettyHandler.class);
        pipeline.addLast("FilterNettyHandler", filterNettyHandler);
    }
package com.ceiec.router.netty.handler;

import com.ceiec.router.netty.DispatcherServletChannelInitializer;
import com.ceiec.router.netty.filter.ApplicationFilterChain;
import com.ceiec.router.netty.filter.ApplicationFilterFactory;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Scope;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.stereotype.Component;

/**
 * desc: 模擬servlet的filter鏈
 * netty handler鏈的初始化在{@link DispatcherServletChannelInitializer#initChannel(io.netty.channel.socket.SocketChannel)}
 * @author: ckl
 * creat_date: 2019/12/10 0010
 * creat_time: 10:14
 **/
@Slf4j
@Component
@Scope(scopeName = "prototype")
public class FilterNettyHandler extends SimpleChannelInboundHandler<MockHttpServletRequest> {


    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MockHttpServletRequest httpServletRequest) throws Exception {
        MockHttpServletResponse httpServletResponse = new MockHttpServletResponse();
        ApplicationFilterChain filterChain = ApplicationFilterFactory.createFilterChain(ctx,httpServletRequest);
        if (filterChain == null) {
            return;
        }

        filterChain.doFilter(httpServletRequest, httpServletResponse);
    }
}

handler最後一棒：將請求交給dispatcherServlet處理

package com.ceiec.router.netty.handler;

import com.ceiec.router.netty.DispatcherServletChannelInitializer;
import com.ceiec.router.netty.filter.RequestResponseWrapper;
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.DefaultHttpResponse;
import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.stream.ChunkedStream;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.DispatcherServlet;

import java.io.ByteArrayInputStream;
import java.io.InputStream;

import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;

/**
 *
 * desc:
 * 請求交給，Spring的dispatcherServlet處理
 * netty handler鏈的初始化在{@link DispatcherServletChannelInitializer#initChannel(io.netty.channel.socket.SocketChannel)}
 * @author: caokunliang
 * creat_date: 2019/8/21 0021
 * creat_time: 15:46
 **/
@Slf4j
@Component
@Scope(scopeName = "prototype")
public class DispatcherServletHandler extends SimpleChannelInboundHandler<RequestResponseWrapper> {

    @Autowired
    private DispatcherServlet dispatcherServlet;


    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, RequestResponseWrapper requestResponseWrapper) throws Exception {
        MockHttpServletRequest servletRequest = (MockHttpServletRequest) requestResponseWrapper.getServletRequest();
        MockHttpServletResponse servletResponse = (MockHttpServletResponse) requestResponseWrapper.getServletResponse();
        //這裡呼叫dispatcherServlet的service，最終會呼叫controller的方法，響應流會寫入到servletResponse中
        dispatcherServlet.service(servletRequest, servletResponse);

        HttpResponseStatus status = HttpResponseStatus.valueOf(servletResponse.getStatus());
        HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status);

        for (String name : servletResponse.getHeaderNames()) {
            response.headers().add(name, servletResponse.getHeader(name));
        }

        response.headers().add("Content-Type","application/json;charset=UTF-8");

        // Write the initial line and the header.
        channelHandlerContext.write(response);

        InputStream contentStream = new ByteArrayInputStream(servletResponse.getContentAsByteArray());

        ChunkedStream stream = new ChunkedStream(contentStream);
        ChannelFuture writeFuture = channelHandlerContext.writeAndFlush(stream);
        writeFuture.addListener(ChannelFutureListener.CLOSE);
    }


}

總結

大概就上面這些東西了，整體來說，有很多需要優化的東西。但我本身對netty的使用，只能算相對勉強，很多細節性的東西沒考慮。

比如：

  1. 我這裡，是很粗暴地每次請求後，關閉了連線；
  2. 請求id在從worker執行緒，傳給dispatcherServlet的業務執行緒時，丟失了（主要是直接使用了netty的api，來生成執行緒池，難以控制）；
  3. 我使用了這個技術的微服務，qps不算高，高了之後，會不會有大問題，暫時未知，需要進一步測試，但最近也忙，時間有限。
  4. channel的handler這裡，現在用的prototype的bean，如果換成單例bean，在高併發下會不會有問題呢，待驗證。

雖然問題很多，但是我覺得很難等到我全部完善了再分享，因為我個人能力有限（netty功力不行，哈哈）。我能做的是，先分享，拋磚引玉，後續有時間了我也會慢慢優化。
程式碼地址：https://gitee.com/ckl111/Netty_Spring_MVC_Sample

相關推薦

曹工雜談：Spring boot應用，自己動手用Netty替換底層Tomcat容器

前言 問：標題說的什麼意思？ 答：簡單說，一個spring boot應用（我這裡，版本升到2.1.7.Release了，沒什麼問題），預設使用了tomcat作為底層容器來接收和處理連線。 我這裡，在依賴中排除了tomcat，使用Netty作為了替代品。優勢在於，啟動飛快，執行緒數量完全可控（多少個netty的

曹工雜談：Linux伺服器上，Spring Boot 原地修改 jar 包配置檔案/替換class檔案，免去重複上傳的麻煩

一、前言 相信很多同學有這樣的需求，現在很多公司都有多地的研發中心，經常需要跨地區部署，比如，博主人在成都，但是伺服器是北京的。一般城市間網路都不怎麼好，上傳一個幾十兆的jar包那是真的慢，別說現在微服務架構下，動輒兩位數的fat jar。這裡說的jar，就是spring boot專案打出來的fat jar

曹工雜談：為什麼很少需要改Spring原始碼，因為擴充套件點太多了，說說Spring的後置處理器

前言 最近發了好幾篇，都是覆蓋框架原始碼，但是spring的程式碼，我是從沒覆蓋過，畢竟，如果方便擴充套件，沒誰想去改原始碼，而spring就是不需要改原始碼的那個，真的是“對擴充套件開放，對修改關閉”的典範。 就我說曾經用過的，spring的擴充套件點，就包括了listener、beanFactoryPos

曹工雜談：一道阿里面試題，兩個執行緒交替列印奇偶數

一、前言 這些天忙著寫業務程式碼，曹工說Tomcat系列暫時沒時間寫，先隨便寫點其他的。 逛部落格園的時候，發現一篇園友的阿里面試文章，https://www.cnblogs.com/crossoverJie/p/9404789.html。 裡面提到了：兩個執行緒，交替列印奇偶數這道筆試題。 看了園友

曹工雜談：花了兩天時間，寫了一個netty實現的http客戶端，支援同步轉非同步和連線池（1）--核心邏輯講解

# 背景 先說下寫這個的目的，其實是好奇，dubbo是怎麼實現同步轉非同步的，然後瞭解到，其依賴了請求中攜帶的請求id來完成這個連線複用；然後我又發現，redisson這個redis客戶端，底層也是用的netty，那就比較好奇了：netty是非同步的，上層是同步的，要拿結果的，同時呢，redis協議也不可能

曹工雜談：手把手帶你讀懂 JVM 的 gc 日誌

 一、前言 今天下午本來在划水，突然看到微信聯絡人那一個紅點點，看了下，應該是部落格園的朋友。加了後，這位朋友問了我一個問題：   問我，這兩塊有什麼關係？ 看到這段 gc 日誌，一瞬間腦子還有點懵，嗯，這個可能要翻下書了，周志明的 Java 虛擬機器那本神書裡面有講，我果斷地打

曹工雜談：Java 類載入還會死鎖？這是什麼情況？

一、前言 今天事不是很多，正好在Java交流群裡，看到一個比較有意思的問題，於是花了點時間研究了一下，這裡做個簡單的分享。 先貼一份測試程式碼，大家可以先猜測一下，執行結果會是怎樣的： 2 3 import java.util.concurrent.TimeUnit; 4 5

曹工雜談--使用mybatis的同學，進來看看怎麼在日誌列印完整sql吧，在資料庫可執行那種

前言 今天新年第一天，給大家拜個年，祝大家新的一年裡，技術突突突，頭髮長長長！ 咱們搞技術的，比較直接，那就開始吧。我給大家看看我demo工程的效果（程式碼下邊會給大家的）： 技術棧是mybatis/mybatis plus，spring boot ，日誌是logback。 其實這個痛點吧，我是一直有的，

曹工雜談：分散式事務解決方案之基於本地訊息表實現最終一致性

# 曹工雜談：分散式事務解決方案之基於本地訊息表實現最終一致性 # 前言 為什麼寫這個？其實我這邊的業務場景，嚴格來說，不算是典型的分散式事務，需求是這樣說的：因為我這邊負責的一個服務消費者consumer，是使用者登入的入口；正常情況下，登入時候要走使用者中心，這是個單獨的服務；如果使用者中心掛了，我這

曹工談Spring Boot：Spring boot中怎麼進行外部化配置，一不留神摔一跤；一路debug，原來是我太年輕了

# spring boot中怎麼進行外部化配置，一不留神摔一跤；一路debug，原來是我太年輕了 # 背景 我們公司這邊，目前都是spring boot專案，沒有引入spring cloud config，也就是說，配置檔案，還是放在resources下面的，為了區分多環境，是採用了profile這種方式

spring-boot實戰【07】【轉】：Spring Boot中Web應用的統一異常處理

http integer private fin ima lex clas 友好 ref 我們在做Web應用的時候，請求處理過程中發生錯誤是非常常見的情況。Spring Boot提供了一個默認的映射：/error，當處理中拋出異常之後，會轉到該請求中處理，並且該請求有一個全

將Spring Boot應用程序遷移到Java9：兼容性

sam 最新 ive 就業 ont add home index world 將 Spring Boot 應用程序遷移到 Java 9：兼容性 　　隨著 Java 9 的到來，關於如何遷移應用程序以使用模塊系統有很多的討論。遺憾的是，大多數文章的焦點都集中於簡單的 Hell

SpringBoot進階篇4：Spring Boot EHCache應用

1、SpringBoot Cache       Spring Boot 本身提供了一個基於ConcurrentHashMap 的快取機制，也集成了EhCache2.x、JCache CJSR-107、EhCache3.x、Infinispan ），還有Couchb

SpringBoot | 第九章：Spring boot 資料來源未配置，啟動異常

1、問題 在使Springboot自動生成的專案框架時如果選擇了資料來源，比如選擇了mysql依賴，生成專案之後，在沒有任何的配置時啟動會報一下異常，執行程式後，控制檯輸出錯誤日誌： 2018-12-04 14:00:46.890  WARN 6592 --- [ &n

Java應用開發的顛覆者：Spring Boot

有人說，Spring Boot的出現，讓Java迎來了又一春，它是Java應用開發的顛覆者，徹底改變了Java應用開發的模式。 以往我們做Spring應用開發，要知道配置哪些類來讓Hibernate和Spring一起工作，要知道如何配置view resolver來控制哪個模

Java Maven專案：spring boot + Mybatis連線MySQL，通用mapper的增刪改查，對映實現多表查詢

1. MySQL自帶庫test新增表user、role 角色表role 使用者表user 2. 新增依賴，配置屬性 相關依賴：百度即可，此處略 application.properties spring.application.name=clean-exe

用Spring Boot & Cloud，Angular2快速搭建微服務web應用

接下來我們來看看如何增加許可權控制，即提供使用者認證和鑑權的功能。首先有3個比較重要的架構設計選擇： 使用Spring的OAuth 2.0，還是使用Spring Session。雖然Spring對OAuth 2.0的支援已經很完善了，簡化了大量的配置和開發，但是OAuth

Spring Boot Admin 2.1.2 釋出，Spring Boot 應用的 Admin UI

   Spring Boot Admin 是用來管理 Spring Boot 應用程式的一個簡單的介面。 Spring Boot Admin 2.0.2 已釋出，官方沒有提供本次的更新說明，不過我們從關閉的 issue 中看到該版本的主要更新內容，是 bug 修復和功能增強，包

RabbitMQ入門：在Spring Boot 應用中整合RabbitMQ

在上一篇隨筆中我們認識並安裝了RabbitMQ，接下來我們來看下怎麼在Spring Boot 應用中整合RabbitMQ。 先給出最終目錄結構： 搭建步驟如下： 新建maven工程amqp 修改pom檔案，引入spring-boot-starter-amqp和spring-boot-sta

Spring Boot應用連線資料庫MySQL，並編寫自定義SQL

1、修改pom.xml檔案 在專案的pom.xml檔案上增加如下程式碼，新增依賴檔案。 <dependency> <groupId>mysql</groupI