SpringBoot請求處理之常用引數註解介紹與原始碼分析

2022-10-10 14:01:30

1、註解

@PathVariable：將請求url中的預留位置引數與控制器方法入參繫結起來（Rest風格請求）

@RequestHeader：獲取請求頭中的引數，通過指定引數 value 的值來獲取請求頭中指定的引數值

@ModelAttribute：兩種用法

用在引數上，會將使用者端傳遞過來的引數按名稱注入到指定物件中，並且會將這個物件自動加入ModelMap中，便於View層使用
用在方法上，被@ModelAttribute註釋的方法會在此controller的每個方法執行前被執行，如果有返回值，則自動將該返回值加入到ModelMap中，類似於Junit的@Before

@RequestParam：獲取url中的請求引數並對映到控制器方法的入參

@MatrixVariable：獲取矩陣變數

矩陣變數：路徑片段中可以可以包含鍵值對，用分號進行分割，也就是說我們的請求路徑可以表示為/test/pathVaribales;name=decade;age=24
注意，矩陣變數預設是關閉的，需要在自定義的設定類中實現WebMvcConfigurer介面，並重寫configurePathMatch()方法，將UrlPathHelper物件的removeSemicolonContent屬性設定為false，或者或者直接使用@Configuration+@Bean的方式，建立一個新的bean放到容器中

package com.decade.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.PathMatchConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.util.UrlPathHelper;
@Configuration(proxyBeanMethods = false)
public class MyMvcConfig implements WebMvcConfigurer {
    // 方式一：實現WebMvcConfigure介面，重寫指定方法
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        UrlPathHelper urlPathHelper = new UrlPathHelper();
        // 設定為false，矩陣變數生效，請求路徑分號後面的內容才不會被移除
        urlPathHelper.setRemoveSemicolonContent(false);
        configurer.setUrlPathHelper(urlPathHelper);
    }
    // 方式二：直接使用@Configuration+@Bean的方式，建立一個新的WebMvcConfigure放到容器中，因為介面有預設實現，所以我們只需要重寫指定方法
    @Bean
    public WebMvcConfigurer createWebMvcConfigure() {
        return new WebMvcConfigurer() {
            @Override
            public void configurePathMatch(PathMatchConfigurer configurer) {
                UrlPathHelper urlPathHelper = new UrlPathHelper();
                // 設定為false，矩陣變數生效，請求路徑分號後面的內容才不會被移除
                urlPathHelper.setRemoveSemicolonContent(false);
                configurer.setUrlPathHelper(urlPathHelper);
            }
        };
    }
}

@CookieValue：獲取cookie中的引數
@RequestBody：獲取請求體中的引數，通過指定引數 value 的值來獲取請求頭中指定的引數值（POST請求）
@RequestAttrible：獲取request域屬性，也就是獲取當前這次請求中的屬性

package com.decade.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Controller
public class ParameterTestController {
    @RequestMapping(value = "/testPathVariable/{userId}/split/{userName}")
    @ResponseBody
    public Map<String, Object> testPathVariable(@PathVariable("userId") String userId,
        @PathVariable("userName") String userName, @PathVariable Map<String, String> variables) {
        final Map<String, Object> map = new HashMap<>();
        // @PathVariable("userId")可以獲取請求路徑中指定變數，並繫結到對應入參
        map.put("userId", userId);
        map.put("userName", userName);
        // @PathVariable搭配Map<String, String>可以獲取路徑變數中的所有預留位置引數
        map.put("variables", variables);
        return map;
    }
    @RequestMapping(value = "/testRequestHeader")
    @ResponseBody
    public Map<String, Object> testRequestHeader(@RequestHeader("User-Agent") String userAgent,
        @RequestHeader Map<String, String> headerVariables) {
        final Map<String, Object> map = new HashMap<>();
        // @RequestHeader("User-Agent")可以獲取請求頭中指定引數
        map.put("userAgent", userAgent);
        // @RequestHeader搭配Map<String, String>可以獲取請求頭中的所有引數
        map.put("headerVariables", headerVariables);
        return map;
    }
    @RequestMapping(value = "/testRequestParam")
    @ResponseBody
    public Map<String, Object> testRequestParam(@RequestParam("userId") String userId,
        @RequestParam List<String> interest, @RequestParam Map<String, String> variables) {
        final Map<String, Object> map = new HashMap<>();
        // @RequestParam("userId")可以獲取請求URL中指定引數並繫結到控制器方法入參
        map.put("userId", userId);
        // 同一個引數如果傳入了多個值，那也可以獲取之後統一放入list列表
        map.put("interest", interest);
        // @RequestParam搭配Map<String, String>可以獲取請求頭中的所有引數
        map.put("variables", variables);
        return map;
    }
    @RequestMapping(value = "/testCookieValue")
    @ResponseBody
    public Map<String, Object> testCookieValue(@CookieValue("_ga") String ga, @CookieValue("_ga") Cookie cookie) {
        final Map<String, Object> map = new HashMap<>();
        // @CookieValue("_ga")可以獲取指定cookie的value
        map.put("_ga", ga);
        // @CookieValue Cookie可以獲取指定cookie的所有資訊，包括name和value等
        map.put("cookie", cookie);
        return map;
    }
    @PostMapping(value = "/testRequestBody")
    @ResponseBody
    public Map<String, Object> testRequestBody(@RequestBody String content) {
        final Map<String, Object> map = new HashMap<>();
        // 獲取post請求表單中的所有引數
        map.put("content", content);
        return map;
    }
    @GetMapping(value = "/testRequestAttribute")
    public String goToSuccess(HttpServletRequest request) {
        // 向請求域中設定值
        request.setAttribute("msg", "test");
        request.setAttribute("code", 200);
        // 將請求轉發到/success
        return "forward:/success";
    }
    @GetMapping(value = "/success")
    @ResponseBody
    public Map<String, Object> test(@RequestAttribute("msg") String msg,
        @RequestAttribute("code") int code, HttpServletRequest request) {
        Map<String, Object> map = new HashMap<>();
        // 利用註解獲取request請求域中的值
        map.put("msgFromAnnotation", msg);
        map.put("codeFromAnnotation", code);
        // 從HttpServletRequest物件中獲取
        map.put("msgFromRequest", request.getAttribute("msg"));
        return map;
    }
    // 矩陣變數的請求方式：http://localhost:8080/car/queryInfo;hobby=game;hobby=music;age=24
    // 注意，矩陣變數必須放在預留位置引數的後邊，使用分號進行分割
    @GetMapping(value = "/car/{path}")
    @ResponseBody
    public Map<String, Object> testMatrixVariable(@MatrixVariable("hobby") List<String> hobby,
        @MatrixVariable("age") int age, @PathVariable("path") String path) {
        Map<String, Object> map = new HashMap<>();
        map.put("age", age);
        map.put("hobby", hobby);
        map.put("path", path);
        return map;
    }
    // 如果請求路徑為http://localhost:8080/car/1;age=39/2;age=23，那麼就要使用pathVar來區分變數名相同的矩陣變數
    @GetMapping(value = "/car/{bossId}/{staffId}")
    @ResponseBody
    public Map<String, Object> testMatrixVariable(@MatrixVariable(value = "age", pathVar = "bossId") int bossAge,
        @MatrixVariable(value = "age", pathVar = "staffId") int staffAge) {
        Map<String, Object> map = new HashMap<>();
        map.put("bossAge", bossAge);
        map.put("staffAge", staffAge);
        return map;
    }
}

然後我們寫一個html頁面測試一下各個註解

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>主頁</title>
</head>
<body>
Hello World!
<a href="/testPathVariable/001/split/decade" rel="external nofollow" >測試@PathVariable註解</a>
<br>
<a href="/testRequestHeader" rel="external nofollow" >測試RequestHeader註解</a>
<br>
<a href="/testRequestParam?userId=001&interest=games&interest=music" rel="external nofollow" >測試@RequestParam註解</a>
<br>
<a href="/testCookieValue" rel="external nofollow" >測試@CookieValue註解</a>
<br>
<a href="/testRequestAttribute" rel="external nofollow" >測試@RequestAttribute註解</a>
<br>
<a href="/car/queryInfo;hobby=game;hobby=music;age=24" rel="external nofollow" >測試@MatrixVariable註解</a>
<br>
<a href="/car/1;age=39/2;age=23" rel="external nofollow" >測試@MatrixVariable註解2</a>
<br>
<form action="/testRequestBody" method="post">
    <input name="name" type="hidden" value="decade">
    <input name="age" type="hidden" value="24">
    <input type="submit" value="測試@RequestBody註解">
</form>
</body>
</html>

2、註解生效相關原始碼分析

學習完註解之後，我們不禁疑問，這些註解是怎麼將請求中的引數繫結到控制器方法的入參上的呢

那麼接下來，我們就來看一下相關原始碼

首先，我們的目光肯定還是聚焦到DiapatcherServlet這個類，我們還是找到doDispatch()這個方法

在使用getHandler()方法獲取到handler之後，它會去獲取HandlerAdapter

try {
	processedRequest = this.checkMultipart(request);
	multipartRequestParsed = processedRequest != request;
	mappedHandler = this.getHandler(processedRequest);
	if (mappedHandler == null) {
		this.noHandlerFound(processedRequest, response);
		return;
	}
	// 獲取HandlerAdapter 
	HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
	...
	// 執行目標方法
	mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

我們跟進這個getHandlerAdapter()方法，發現他是做了一個遍歷，為當前Handler 找一個介面卡 HandlerAdapter，最後返回RequestMappingHandlerAdapter

找到介面卡之後，我們做了一系列判斷，接著我們會使用mv = ha.handle(processedRequest, response, mappedHandler.getHandler())來執行目標方法，這句程式碼會將我們上面找到的handler、請求request以及響應response都傳入其中

我們繼續深入，發現斷點走到了RequestMappingHandlerAdapter這個類下的handleInternal()方法，然後它又呼叫了invokeHandlerMethod()

這個方法中做了如下幾件重要的事情

設定引數解析器，我們通過觀察可以看到，這裡可用的引數解析器似乎和我們之前學習的引數註解有關，比如RequestParam、PathVariable等

點選this.argumentResolvers並一直深入，我們可以發現它是實現了HandlerMethodArgumentResolver 這個介面，這個介面裡面只有2個方法，也就是說，在這個介面的27個實現類中，我們滿足哪個引數解析器的supportsParameter()方法，它就會呼叫對應的resolveArgument()方法來解析引數

public interface HandlerMethodArgumentResolver {
	// 判斷是否支援此型別引數
    boolean supportsParameter(MethodParameter parameter);
	// 解析引數
    @Nullable
    Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
}

設定返回值處理器

我們的方法能返回多少種型別的返回值，也取決於返回值處理器支援哪些型別

執行目標方法

我們看完上面的引數解析器和返回值處理器後，直接轉到invocableMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);

跟著斷點深入到ServletInvocableHandlerMethod類下的invokeAndHandle()這個方法

發現只要執行Object returnValue = this.invokeForRequest(webRequest, mavContainer, providedArgs);之後，斷點就會跳轉到控制器類的具體方法中，也就是說，這裡才是真正的方法呼叫處

我們來分析一下invokeForRequest()這個方法

@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
   // 確定目標方法的每一個引數的值
   Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);
   if (logger.isTraceEnabled()) {
       logger.trace("Arguments: " + Arrays.toString(args));
   }
   //使用反射呼叫對應方法
   return this.doInvoke(args);
}

最後，我們發現引數的解析是在getMethodArgumentValues()這個方法進行的，它通過一個for迴圈，判斷每一個引數適合用哪個解析器來進行引數解析

protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
   // 獲取所有引數的詳細資訊，包括型別，註解，位置等
   MethodParameter[] parameters = this.getMethodParameters();
   if (ObjectUtils.isEmpty(parameters)) {
       return EMPTY_ARGS;
   } else {
       Object[] args = new Object[parameters.length];
       for(int i = 0; i < parameters.length; ++i) {
           MethodParameter parameter = parameters[i];
           parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
           args[i] = findProvidedArgument(parameter, providedArgs);
           if (args[i] == null) {
   			// 迴圈所有支援的引數解析器，判斷當前引數被哪種解析器支援，並且把當前引數和解析器當作k-v鍵值對放進快取，方便以後直接取
               if (!this.resolvers.supportsParameter(parameter)) {
                   throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
               }
               try {
   				// 進行引數解析
                   args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
               } catch (Exception var10) {
                   if (logger.isDebugEnabled()) {
                       String exMsg = var10.getMessage();
                       if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
                           logger.debug(formatArgumentError(parameter, exMsg));
                       }
                   }
                   throw var10;
               }
           }
       }
       return args;
   }
}

有興趣的可以繼續深入，哈哈~

3、Servlet API

如果入參型別是下列中的某一種

WebRequest、ServletRequest、MultipartRequest、 HttpSession、javax.servlet.http.PushBuilder、Principal、InputStream、Reader、HttpMethod、Locale、TimeZone、ZoneId

對應的引數解析器就是ServletRequestMethodArgumentResolver

4、複雜引數

Map、Model：map、model裡面的資料會被放在request的請求域，類似於request.setAttribute
RedirectAttributes（重定向攜帶資料）
ServletResponse（response）、SessionStatus、UriComponentsBuilder、ServletUriComponentsBuilder、Errors/BindingResult

程式碼樣例：

我們寫一個控制器介面/testModelAndMap，將請求轉發到/testOk這個介面

@GetMapping(value = "/testModelAndMap")
public String testModelAndMap(Model model, Map<String, Object> map,
    HttpServletRequest request, HttpServletResponse response) {
    map.put("name", "decade");
    model.addAttribute("age", 24);
    request.setAttribute("sex", "man");
    Cookie cookie = new Cookie("n1", "v1");
    cookie.setMaxAge(1);
    response.addCookie(cookie);
    // 將請求轉發到/testOk
    return "forward:/testOk";
}
@GetMapping(value = "/testOk")
@ResponseBody
public Map<String, Object> testOk(HttpServletRequest request) {
    Map<String, Object> map = new HashMap<>();
    map.put("name", request.getAttribute("name"));
    map.put("age", request.getAttribute("age"));
    map.put("sex", request.getAttribute("sex"));
    return map;
}

呼叫介面發現，我們在/testModelAndMap介面中放入Map、Model和HttpServletRequest中的引數，在/testOk中也可以取到，這說明這些引數會被放在request的請求域中，本次請求完成時都可以取到

相關原始碼還是DispatcherServlet類下面的doDispatch()

關鍵點就是根據引數型別去找對應的引數解析器和返回值處理器

Map型別：MapMethodProcessor
Model型別：ModelMethodProcessor
HttpServletRequest：ServletRequestMethodArgumentResolver

注意：ModelAndViewContainer中包含要去的頁面地址View，還包含Model資料

大家可以自己debug一下，不在贅述，否則篇幅太長了

5、自定義引數

測試程式碼，先寫2個實體類

package com.decade.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private int age;
    private Date birth;
    private Pet pet;
}
package com.decade.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Pet {
    private String name;
    private int age;
}

然後寫控制器處理方法

@PostMapping(value = "/savePerson")
@ResponseBody
public Person savePerson(Person person) {
    return person;
}

最後寫一個HTML頁面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
Hello World!
<form action="/savePerson" method="post">
    姓名： <input name="name" type="text" value="decade">
    年齡： <input name="age" type="text" value="24">
    生日： <input name="birth" type="text" value="2022/01/01">
    寵物姓名： <input name="pet.name" type="text" value="十年的小狗">
    寵物年齡： <input name="pet.age" type="text" value="1">
    <input type="submit" value="提交儲存">
</form>
</body>
</html>

測試結果如下，我們發現簡單屬性和存在參照關係的屬性都成功繫結了

對應解析類：ServletModelAttributeMethodProcessor和其父類別ModelAttributeMethodProcessor

資料繫結核心程式碼：

ModelAttributeMethodProcessor類下的resolveArgument()方法

this.bindRequestParameters(binder, webRequest);

binder:web資料繫結器，將請求引數的值繫結到指定的JavaBean裡面

WebDataBinder 利用它裡面的 Converters 將請求資料轉成指定的資料型別，再次封裝到JavaBean中

GenericConversionService類：getConverter()---->find()

在將請求引數的值轉化為指定JavaBean的對應屬性時，它會去快取中尋找是否有合適的Converters轉換器，如果沒有就和上面尋找引數解析器一樣，遍歷所有的轉換器，尋找能將request中的型別轉換成目標型別的轉換器

6、型別轉換器Converters

有時候，Spring預設提供的converter滿足不了我們的需求

我們就可以直接使用@Configuration+@Bean的方式，自定義一些類轉換器，建立一個新的WebMvcConfigure放到容器中，因為介面有預設實現，所以我們只需要重寫指定方法

package com.decade.config;
import com.decade.pojo.Pet;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.converter.Converter;
import org.springframework.format.FormatterRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration(proxyBeanMethods = false)
public class MyMvcConfig implements WebMvcConfigurer {
    @Bean
    public WebMvcConfigurer createConvert() {
        return new WebMvcConfigurer() {
            @Override
            public void addFormatters(FormatterRegistry registry) {
                registry.addConverter(new Converter<String, Pet>() {
                    @Override
                    public Pet convert(String source) {
                        final String[] split = source.split(",");
                        final Pet pet = new Pet();
                        pet.setName(split[0]);
                        pet.setAge(Integer.parseInt(split[1]));
                        return pet;
                    }
                });
            }
        };
    }

然後寫一個HTML頁面進行測試

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
Hello World!
<form action="/savePerson" method="post">
    姓名： <input name="name" type="text" value="decade">
    年齡： <input name="age" type="text" value="24">
    生日： <input name="birth" type="text" value="2022/01/01">
    寵物資訊： <input name="pet" type="text" value="十年的小狗,1">
    <input type="submit" value="提交儲存">
</form>
</body>
</html>

到此這篇關於SpringBoot請求處理之常用引數註解介紹與原始碼分析的文章就介紹到這了,更多相關SpringBoot請求處理內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！