SpringBoot web開發(fā)源碼深入分析

更新時間：2022年10月09日 16:34:04 作者：Decade0712

Web開發(fā)的核心內(nèi)容主要包括內(nèi)嵌的Servlet容器和SpringMVCSpringBoot使用起來非常簡潔，大部分配置都有SpringBoot自動裝配，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)吧

一、MVC自動配置

1、默認支持的功能

Spring Boot為Spring MVC提供了自動配置，默認支持以下功能

ContentNegotiatingViewResolver和BeanNameViewResolver視圖解析器
支持靜態(tài)資源，包括webjars
轉(zhuǎn)換器的自動注冊、自定義轉(zhuǎn)換器GenericConverter與格式化
支持http消息轉(zhuǎn)換（請求與響應(yīng)）
MessageCodesResolver錯誤消息
首頁映射
圖標(biāo)自定義
自動使用ConfigurableWebBindingInitializer，博主百度了一下，它的主要作用就是初始化WebDataBinder，將請求的參數(shù)轉(zhuǎn)化為對應(yīng)的JavaBean，并且會結(jié)合類型、格式轉(zhuǎn)換等API一起使用

2、靜態(tài)資源與首頁相關(guān)源碼解析

SpringBoot啟動時會默認加載 xxxAutoConfiguration 類（自動配置類），SpringMVC功能的自動配置類為 WebMvcAutoConfiguration

@AutoConfiguration(
    after = {DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class}
)
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})
@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})
@AutoConfigureOrder(-2147483638)
public class WebMvcAutoConfiguration {
	...
}

然后我們可以看到他有一個靜態(tài)內(nèi)部類WebMvcAutoConfigurationAdapter，可以看到這是一個配置類

@Configuration(
    proxyBeanMethods = false
)
@Import({WebMvcAutoConfiguration.EnableWebMvcConfiguration.class})
// 將配置文件的相關(guān)屬性和括號中的兩個類進行了綁定，然后注冊到容器中。WebMvcProperties和spring.mvc開頭的配置、WebProperties和spring.web開頭的配置
@EnableConfigurationProperties({WebMvcProperties.class, WebProperties.class})
@Order(0)
public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer, ServletContextAware {
	...
}

然后我們發(fā)現(xiàn)，這個配置類只有一個有參構(gòu)造器，在這種情況下，我們默認有參構(gòu)造器所有參數(shù)的值都會從容器中獲取

// 這里的WebProperties 和WebMvcProperties都在上面和配置進行綁定過了，如果我們沒有配置該配置項，那就去類中取默認配置的值
// ListableBeanFactory beanFactory Spring的beanFactory
// 其他的可以自己去了解下，博主這里沒有特地去搜了
public WebMvcAutoConfigurationAdapter(WebProperties webProperties, WebMvcProperties mvcProperties, ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider, ObjectProvider<WebMvcAutoConfiguration.ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider, ObjectProvider<DispatcherServletPath> dispatcherServletPath, ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
	this.resourceProperties = webProperties.getResources();
	this.mvcProperties = mvcProperties;
	this.beanFactory = beanFactory;
	this.messageConvertersProvider = messageConvertersProvider;
	this.resourceHandlerRegistrationCustomizer = (WebMvcAutoConfiguration.ResourceHandlerRegistrationCustomizer)resourceHandlerRegistrationCustomizerProvider.getIfAvailable();
	this.dispatcherServletPath = dispatcherServletPath;
	this.servletRegistrations = servletRegistrations;
	this.mvcProperties.checkConfiguration();
}

那么我們的靜態(tài)資源映射以及webjars都是在哪里進行配置的呢，我們往下看找到一個方法

public void addResourceHandlers(ResourceHandlerRegistry registry) {
	// 判斷這個isAddMappings屬性是否為false，默認值是true，如果我們在yaml文件或者properties中改為false，那么就會進這個條件語句，后面的靜態(tài)資源路徑以及webjars都不會生效了
    if (!this.resourceProperties.isAddMappings()) {
        logger.debug("Default resource handling disabled");
    } else {
    	// webjars的規(guī)則
        this.addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
        // 默認靜態(tài)資源地址的處理規(guī)則
        this.addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
            registration.addResourceLocations(this.resourceProperties.getStaticLocations());
            if (this.servletContext != null) {
                ServletContextResource resource = new ServletContextResource(this.servletContext, "/");
                registration.addResourceLocations(new Resource[]{resource});
            }
        });
    }
}

那我們歡迎頁是在哪里配置的呢？

我們發(fā)現(xiàn)，在這個WebMvcAutoConfiguration下面還有一個靜態(tài)內(nèi)部類EnableWebMvcConfiguration，它也是一個配置類

這里面有一個方法welcomePageHandlerMapping()

HandlerMapping（處理映射器）：根據(jù)URL找到對應(yīng)的處理器

@Bean
public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext, FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
    WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(new TemplateAvailabilityProviders(applicationContext), applicationContext, this.getWelcomePage(), this.mvcProperties.getStaticPathPattern());
    welcomePageHandlerMapping.setInterceptors(this.getInterceptors(mvcConversionService, mvcResourceUrlProvider));
    welcomePageHandlerMapping.setCorsConfigurations(this.getCorsConfigurations());
    return welcomePageHandlerMapping;
}

點進WelcomePageHandlerMapping的構(gòu)造方法可以看到，它的邏輯大體上為，如果welcomePage不等于null，而且staticPathPattern是默認的/**，就會去我們的靜態(tài)資源文件夾找index.html，否則就去找有沒有能處理/index接口的映射器

這里的staticPathPattern和spring.mvc.static-path-pattern是綁定在一起的

WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders, ApplicationContext applicationContext, Resource welcomePage, String staticPathPattern) {
    if (welcomePage != null && "/**".equals(staticPathPattern)) {
        logger.info("Adding welcome page: " + welcomePage);
        this.setRootViewName("forward:index.html");
    } else if (this.welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
        logger.info("Adding welcome page template: index");
        this.setRootViewName("index");
    }
}

3、Rest映射及源碼分析

Rest風(fēng)格支持：使用HTTP請求方式動詞來表示對資源的操作

具體的可以看我之前的【SpringMVC】Restful風(fēng)格及中文亂碼問題

原來獲取用戶信息–/getUSer、刪除用戶–/deleteUser、修改用戶–editUser、保存用戶/saveUser
使用REST風(fēng)格獲取用戶信息–GET、刪除用戶–DELETE、修改用戶–PUT、保存用戶POST

核心源碼部分：WebMvcAutoConfiguration類下的hiddenHttpMethodFilter()方法

核心配置：如果要從頁面發(fā)起PUT、DELETE請求，需要在yaml文件中將spring.mvc.hiddenmethod.filter.enabled設(shè)置為true，如果是客戶端工具如postman發(fā)起，則無需開啟

@Bean
@ConditionalOnMissingBean({HiddenHttpMethodFilter.class})
@ConditionalOnProperty(
    prefix = "spring.mvc.hiddenmethod.filter",
    name = {"enabled"}
)
public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
    return new OrderedHiddenHttpMethodFilter();
}

我們點開OrderedHiddenHttpMethodFilter可以看到它繼承了HiddenHttpMethodFilter這個類

我們接著跟進去發(fā)現(xiàn)里面有一個doFilterInternal()方法，請求進來都會被這個方法攔截

package org.springframework.web.filter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import org.springframework.http.HttpMethod;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
public class HiddenHttpMethodFilter extends OncePerRequestFilter {
    private static final List<String> ALLOWED_METHODS;
    public static final String DEFAULT_METHOD_PARAM = "_method";
    private String methodParam = "_method";
    public HiddenHttpMethodFilter() {
    }
    public void setMethodParam(String methodParam) {
        Assert.hasText(methodParam, "'methodParam' must not be empty");
        this.methodParam = methodParam;
    }
	// 它會對請求方法進行判斷
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        HttpServletRequest requestToUse = request;
        // 如果是表單是post請求且請求正常，那么它會判斷請求參數(shù)里面是否存在_method這個參數(shù)
        if ("POST".equals(request.getMethod()) && request.getAttribute("javax.servlet.error.exception") == null) {
            String paramValue = request.getParameter(this.methodParam);
            // 判斷_method參數(shù)是否為空
            if (StringUtils.hasLength(paramValue)) {
            	// 將參數(shù)轉(zhuǎn)成大寫
                String method = paramValue.toUpperCase(Locale.ENGLISH);
                // 判斷_method參數(shù)是否是PUT、DELETE、PATCH其中的一個，如果滿足就使用requesWrapper重寫了HttpServletRequest的getMethod方法，返回的是傳入的值
                if (ALLOWED_METHODS.contains(method)) {
                    requestToUse = new HiddenHttpMethodFilter.HttpMethodRequestWrapper(request, method);
                }
            }
        }
		// 這里過濾器放行時的request是處理后得到的HttpMethodRequestWrapper
        filterChain.doFilter((ServletRequest)requestToUse, response);
    }
    static {
        ALLOWED_METHODS = Collections.unmodifiableList(Arrays.asList(HttpMethod.PUT.name(), HttpMethod.DELETE.name(), HttpMethod.PATCH.name()));
    }
	// HttpServletRequestWrapper類還是實現(xiàn)了HttpServletRequest接口
    private static class HttpMethodRequestWrapper extends HttpServletRequestWrapper {
        private final String method;
        public HttpMethodRequestWrapper(HttpServletRequest request, String method) {
            super(request);
            this.method = method;
        }
        public String getMethod() {
            return this.method;
        }
    }
}

我們可以寫一個html頁面還有一個控制器測試一下

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
Hello World!
<form action="/test/user" method="get">
    <input type="submit" value="REST-GET">
</form>
<form action="/test/user" method="post">
    <input type="submit" value="REST-POST">
</form>
<form action="/test/user" method="post">
    <input name="_method" type="hidden" value="PUT">
    <input type="submit" value="REST-PUT">
</form>
<form action="/test/user" method="post">
    <input name="_method" type="hidden" value="DELETE">
    <input type="submit" value="REST-DELETE">
</form>
</body>
</html>

package com.decade.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
@RequestMapping(value = "/test")
public class TestController {
    @RequestMapping(value = "/user", method = RequestMethod.GET)
    @ResponseBody
    public String queryUser() {
        return "get查詢用戶的信息";
    }
    @RequestMapping(value = "/user", method = RequestMethod.POST)
    @ResponseBody
    public String editUser() {
        return "post保存用戶的信息";
    }
    @RequestMapping(value = "/user", method = RequestMethod.DELETE)
    @ResponseBody
    public String deleteUser() {
        return "delete刪除用戶的信息";
    }
    @RequestMapping(value = "/user", method = RequestMethod.PUT)
    @ResponseBody
    public String saveUser() {
        return "put編輯用戶的信息";
    }
}

驗證的時候遇到一個問題，那就是如果引入了spring-boot-starter-security這個依賴

那么調(diào)用POST、PUT和DELETE接口時就會出錯

博主查了一下，這是因為Spring Boot 與 SpringSecurity整合后，為了防御csrf攻擊，只有GET|OPTIONS|HEAD|TRACE|CONNECTION可以通過

其他方法請求時，需要有token

我將SpringSecurity的依賴注掉之后，驗證就通過了

拓展：如果我們要修改HiddenHttpMethodFilter里過濾方法中判斷的參數(shù)名稱，我們可以自己寫一個配置類，例如我們想將它由_method改為_m，那可以這么寫

package com.decade.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.HiddenHttpMethodFilter;
@Configuration(proxyBeanMethods = false)
public class MyMvcConfig {
    @Bean
    public HiddenHttpMethodFilter createHiddenHttpMethodFilter() {
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        // 利用setMethodParam設(shè)置自己想要的參數(shù)名
        hiddenHttpMethodFilter.setMethodParam("_m");
        return hiddenHttpMethodFilter;
    }
}

4、請求映射原理

1）接下來我們研究一下，Spring Boot是怎么將一個個請求匹配到對應(yīng)的處理器（即controller）的

根據(jù)我們之前SpringMVC的學(xué)習(xí) 我們可以知道所有的請求都會被DispatcherServlet攔截，我們一直跟下去可以發(fā)現(xiàn)，DispatcherServlet實際上也是繼承了HttpServlet

我們著重分析一下DispatcherServlet中的doDispatch()方法，我們發(fā)現(xiàn)有一個getHandler()方法

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    try {
        try {
            ModelAndView mv = null;
            Object dispatchException = null;
            try {
            	// 檢查是否是文件上傳請求
                processedRequest = this.checkMultipart(request);
                multipartRequestParsed = processedRequest != request;
                // 決定是哪個handler處理當(dāng)前請求，HandlerMapping（處理映射器）：根據(jù)URL找到對應(yīng)的處理器
                mappedHandler = this.getHandler(processedRequest);
                if (mappedHandler == null) {
                    this.noHandlerFound(processedRequest, response);
                    return;
                }

我們嘗試發(fā)起一個請求，使用debug模式可以發(fā)現(xiàn)，這個getHandler()方法就是對容器中的handlerMapping進行一個遍歷，查看哪個處理映射器能處理這個請求

我們可以看到這里有WelcomePageHandlerMapping（與首頁相關(guān)的）等映射器