springmvc學習筆記（全）

SpringMVC簡介

什麼是MVC

MVC是一種軟體架構的思想，將軟體按照模型、檢視、控制器來劃分

• M: Model：模型層，指工程中的JavaBean，作用是處理資料。JavaBean分為兩類：
  • 實體類Bean：專門儲存業務資料的，如 Student、User 等
  • 業務處理Bean：指Service或Dao物件，專門用於處理業務邏輯和資料訪問。
• V: View：檢視層，指工程中的html或jsp等頁面，作用是與使用者進行互動，展示資料
• C: Controller：控制層，指工程中的servlet，作用是接收請求和響應瀏覽器

MVC的工作流程：
使用者通過檢視層傳送請求到伺服器，在伺服器中請求被控制層接收Controller，Controller呼叫相應的Model層處理請求，處理完畢將結果返回到Controller，Controller再根據請求處理的結果找到相應的View檢視，渲染資料後最終響應給瀏覽器

什麼是SpringMVC

SpringMVC是Spring的一個後續產品，是Spring的一個子專案

SpringMVC 是 Spring 為表述層開發提供的一整套完備的解決方案。在表述層框架歷經 Strust、WebWork、Strust2 等諸多產品的歷代更迭之後，目前業界普遍選擇了 SpringMVC 作為 Java EE 專案表述層開發的首選方案。

注：三層架構分為表述層（或表示層）、業務邏輯層、資料訪問層，表述層表示前臺頁面和後臺servlet

SpringMVC的特點

• Spring 家族原生產品，與 IOC 容器等基礎設施無縫對接
• 基於原生的Servlet，通過功能強大的前端控制器DispatcherServlet，對請求和響應進行統一處理
• 表述層各細分領域需要解決的問題全方位覆蓋，提供全面解決方案
• 程式碼清新簡潔，大幅度提升開發效率
• 內部元件化程度高，可插拔式元件即插即用，想要什麼功能配置相應元件即可
• 效能卓著，尤其適合現代大型、超大型網際網路專案要求

HelloWorld

Maven

打包方式: <packaging>war</packaging>

新增依賴:

<dependencies>
        <!-- SpringMVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!-- 日誌 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- ServletAPI -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- Spring5和Thymeleaf整合包 -->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.12.RELEASE</version>
        </dependency>
    </dependencies>

scope（依賴範圍）：provided(已被提供)，表示伺服器已經提供該依賴，所以此依賴不會被打包

配置web.xml

註冊SpringMVC的前端控制器DispatcherServlet

預設配置方式

此配置作用下，SpringMVC的配置檔案預設位於WEB-INF下，預設名稱為<servlet-name>，例如，以下配置所對應SpringMVC的配置檔案位於WEB-INF下，檔名為springMVC-servlet.xml

<!-- 配置SpringMVC的前端控制器，對瀏覽器傳送的請求統一進行處理 -->
<servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <!--
        設定springMVC的核心控制器所能處理的請求的請求路徑
        /所匹配的請求可以是/login或.html或.js或.css方式的請求路徑
        但是/不能匹配.jsp請求路徑的請求
    -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

擴充套件配置方式（推薦）

可通過init-param標籤設定SpringMVC配置檔案的位置和名稱，通過load-on-startup標籤設定SpringMVC前端控制器DispatcherServlet的初始化時間

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 配置SpringMVC的前端控制器，對瀏覽器傳送的請求統一進行處理 -->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 通過初始化引數指定SpringMVC配置檔案的位置和名稱 -->
        <init-param>
            <!-- contextConfigLocation為固定值 -->
            <param-name>contextConfigLocation</param-name>
            <!-- 使用classpath:表示從類路徑查詢配置檔案，例如maven工程中的src/main/resources -->
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <!--
             作為框架的核心元件，在啟動過程中有大量的初始化操作要做
            而這些操作放在第一次請求時才執行會嚴重影響訪問速度
            因此需要通過此標籤將啟動控制DispatcherServlet的初始化時間提前到伺服器啟動時
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <!--
            設定springMVC的核心控制器所能處理的請求的請求路徑
            /所匹配的請求可以是/login或.html或.js或.css方式的請求路徑
            但是/不能匹配.jsp請求路徑的請求
        -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

注：<url-pattern>標籤中使用/和/*的區別：

/所匹配的請求可以是.html或.js或.css方式的請求路徑，但是/不能匹配.jsp請求路徑的請求，

避免在訪問jsp頁面時，請求被DispatcherServlet處理而找不到相應的頁面。

/*則能夠匹配所有請求，例如在使用過濾器時，若需要對所有請求進行過濾，就需要使用/*的寫法

建立springMVC的配置檔案

spring配置檔案

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--    配置包掃描-->
    <context:component-scan base-package="com.birdy"></context:component-scan>

    <!-- 配置Thymeleaf檢視解析器 -->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">

                        <!-- 檢視字首 -->
                        <property name="prefix" value="/WEB-INF/templates/"/>

                        <!-- 檢視字尾 -->
                        <property name="suffix" value=".html"/>
                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8" />
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

</beans>

頁面

前端頁面檔案放置在路徑src/main/webapp/WEB-INF/templates/下

<!--index.html-->
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>首頁</title>
</head>
<body>
<h1>hello world!</h1>
</body>
</html>

建立請求控制器

由於前端控制器對瀏覽器傳送的請求進行了統一的處理，但是不同的請求可能需要不同的處理過程，因此需要建立單獨處理請求的類，即請求控制器

請求控制器中處理請求的方法成為控制器方法

因為SpringMVC的控制器由一個POJO（普通的Java類）擔任，因此需要通過@Controller註解將其標識為一個控制層元件，交給Spring的IoC容器管理，此時SpringMVC才能夠識別控制器的存在

@Controller
public class HelloController {

    @RequestMapping("/")
    public String index(){
        //控制前將前端傳過來的路徑對映到指定檔案
        
        return "index"; //將請求轉發到index.html檔案
    }
}

注：之所以 return "index";就可以對映到index.html檔案，是因為在springMVC.xml配置了檢視解析器處理請求的規則，即自動新增了字首檔案路徑和字尾檔案型別

總結

瀏覽器傳送請求，若請求地址符合前端控制器的url-pattern，該請求就會被前端控制器DispatcherServlet處理。前端控制器會讀取SpringMVC的核心配置檔案，通過掃描元件找到控制器，將請求地址和控制器中@RequestMapping註解的value屬性值進行匹配，若匹配成功，該註解所標識的控制器方法就是處理請求的方法。處理請求的方法需要返回一個字串型別的檢視名稱，該檢視名稱會被檢視解析器解析，加上字首和字尾組成檢視的路徑，通過Thymeleaf對檢視進行渲染，最終轉發到檢視所對應頁面

@RequestMapping註解

作用：顧名思義，@RequestMapping`註解的作用就是將請求和處理請求的控制器方法關聯起來，建立對映關係。SpringMVC 接收到指定的請求，就會來找到在對映關係中對應的控制器方法來處理這個請求。

位置

• @RequestMapping標識一個類：設定請求路徑的初始資訊，作為類裡所有控制器方法對映路徑的的公共字首部分
• @RequestMapping標識一個方法：設定對映請求請求路徑的具體資訊

@Controller
@RequestMapping("/test")
public class RequestMappingController {

	//此時對映的請求路徑為：/test/testRequestMapping
    @RequestMapping("/testRequestMapping")
    public String testRequestMapping(){
        return "success";
    }
}

屬性

value

value屬性通過請求的請求地址匹配請求對映，@RequestMapping註解的value屬性是一個字串型別的陣列，表示該請求對映能夠匹配多個請求地址所對應的請求，必填。

<a th:href="@{/testRequestMapping}">測試@RequestMapping的value屬性-->/testRequestMapping</a><br>
<a th:href="@{/test}">測試@RequestMapping的value屬性-->/test</a><br>

@RequestMapping( value = {"/testRequestMapping", "/test"})
public String testRequestMapping(){
    return "success";
}

method

• @RequestMapping註解的method屬性通過定義請求方式（get或post）匹配請求對映
• method屬性是一個RequestMethod型別的陣列，表示該請求對映能夠匹配多種請求方式的請求

若一個請求的請求地址滿足value屬性，但是請求方式不滿足method屬性，則瀏覽器報錯405：Request method 'xxx' not supported

<a th:href="@{/test}">測試@RequestMapping的value屬性-->/test</a><br>
<form th:action="@{/test}" method="post">
    <input type="submit">
</form>

@RequestMapping(
        value = {"/testRequestMapping", "/test"},
        method = {RequestMethod.GET, RequestMethod.POST}
)
public String testRequestMapping(){
    return "success";
}

注：

對於處理指定請求方式的控制器方法，SpringMVC中提供了@RequestMapping的派生註解

• 處理get請求的對映-->@GetMapping
• 處理post請求的對映-->@PostMapping
• 處理put請求的對映-->@PutMapping
• 處理delete請求的對映-->@DeleteMapping

常用的請求方式有get，post，put，delete，但是目前瀏覽器只支援get和post，若在form表單提交時，為method設定了其他請求方式的字串（put或delete），則按照預設的請求方式get處理。

若要傳送put和delete請求，則需要通過spring提供的過濾器HiddenHttpMethodFilter，在RESTful部分會講到

params（瞭解）

@RequestMapping註解的params屬性通過請求的請求引數匹配請求對映，@RequestMapping註解的params屬性是一個字串型別的陣列，可以通過四種表示式設定請求引數和請求對映的匹配關係

"param"：要求請求對映所匹配的請求必須攜帶param請求引數
"!param"：要求請求對映所匹配的請求必須不能攜帶param請求引數
"param=value"：要求請求對映所匹配的請求必須攜帶param請求引數且param=value
"param!=value"：要求請求對映所匹配的請求必須攜帶param請求引數但是param!=value

示例：

<a th:href="@{/test(username='admin',password=123456)">測試@RequestMapping的params屬性-->/test</a><br>

@RequestMapping(
        value = {"/testRequestMapping", "/test"}
        ,method = {RequestMethod.GET, RequestMethod.POST}
        ,params = {"username","password!=123456"}	//表示請求必須攜帶username屬性，值任意；必須攜													帶password屬性，且值必須為123456
)
public String testRequestMapping(){
    return "success";
}

注：

• thymeleaf使用@{}填寫路徑，且自帶tomcat中設定的預設文字路徑
• 使用()填寫請求引數

headers（瞭解）

@RequestMapping註解的headers屬性通過請求的請求頭資訊匹配請求對映。@RequestMapping註解的headers屬性是一個字串型別的陣列，可以通過四種表示式設定請求頭資訊和請求對映的匹配關係

"header"：要求請求對映所匹配的請求必須攜帶header請求頭資訊
"!header"：要求請求對映所匹配的請求必須不能攜帶header請求頭資訊
"header=value"：要求請求對映所匹配的請求必須攜帶header請求頭資訊且header=value
"header!=value"：要求請求對映所匹配的請求必須攜帶header請求頭資訊且header!=value

若當前請求滿足@RequestMapping註解的value和method屬性，但是不滿足headers屬性，此時頁面顯示404錯誤，即資源未找到

SpringMVC支援ant風格的路徑

？：表示任意的單個字元

*：表示任意的0個或多個字元

**：表示任意的一層或多層目錄

注意：在使用**時，只能使用/**/xxx的方式

路徑中的佔位符（重點）

原始方式：/deleteUser?id=1

rest方式：/deleteUser/1

SpringMVC路徑中的佔位符常用於RESTful風格中，當請求路徑中將某些資料通過路徑的方式傳輸到伺服器中，就可以在@RequestMapping註解的value屬性中通過佔位符{xxx}表示傳輸的資料，然後通過@PathVariable註解，將佔位符所表示的資料賦值給控制器方法的形參

<a th:href="@{/testRest/1/admin}">測試路徑中的佔位符-->/testRest</a><br>

@RequestMapping("/testRest/{id}/{username}")
public String testRest(@PathVariable("id") String id,
                       @PathVariable("username") String username){
    System.out.println("id:"+id+",username:"+username);
    return "success";
}
//最終輸出的內容為-->id:1,username:admin

SpringMVC獲取請求引數

通過ServletAPI獲取

將HttpServletRequest作為控制器方法的形參，此時HttpServletRequest型別的引數就是封裝了當前請求報文的物件

<a th:href="@{/servlet(username='admin',password=123)}">測試servlet傳參</a>

@RequestMapping("/servlet")
	public String testParam(HttpServletRequest request){
		String username = request.getParameter("username");
		String password = request.getParameter("password");
		System.out.println("username:"+username+",password:"+password);
		return "target";
	}
//列印結果：username:admin,password:123

通過SpringMVC控制器方法的形參獲取請求引數

在特定情況下才會使用原始Servlet傳參，SpringMVC自帶形參匹配功能方便傳參，在控制器方法的形參位置，設定和請求引數同名的形參，當瀏覽器傳送請求，匹配到請求對映時，在DispatcherServlet中就會將請求引數賦值給相應的形參，推薦使用。

 <a th:href="@{/default(username='birdy',password=123)}">測試SringMVC形參方式</a>

@RequestMapping("/default")
	public String testDefault(String username, Integer password){
		System.out.println("username:"+username+",password:"+password);
		return "target";
	}
//列印結果：username:birdy,password:123

@RequestParam

@RequestParam: 將請求引數和控制器方法的形參建立對映關係

@RequestParam註解一共有三個屬性：

• value：指定為形參賦值的請求引數的引數名

• required：設定是否必須傳輸此請求引數，預設值為true

  • 值為true時，則當前請求必須傳輸value所指定的引數名，若沒有傳輸該請求引數，且沒有設定defaultValue屬性，則頁面報錯

    400：Required String parameter 'xxx' is not present；
    

  • 值為false，則當前請求不是必須傳輸value所指定的請求引數。若沒有傳，則註解所標識的形參的值為null

• defaultValue：不管required屬性值為true或false，當value所指定的請求引數沒有傳輸或傳輸的值為空""時，則使用預設值為形參賦值

@RequestMapping("/default")
	public String testDefault(
        @RequestParam(value = "username", required = false) String username,
		@RequestParam(value = "password", required = false) String password
    )
    {
		System.out.println("username:"+username+",password:"+password);
		return "target";
	}
//列印結果：username:birdy,password:123

@RequestHeader

@RequestHeader是將請求頭資訊和控制器方法的形參建立對映關係

@RequestHeader註解一共有三個屬性：value、required、defaultValue，用法同@RequestParam

@RequestMapping("/header")
public String testHeader(@RequestHeader(value = "Host") String host,
                         @RequestHeader(value = "Accept-Encoding") String code){
    System.out.println(host+"**"+code);
    return "target";
}

@CookieValue

@CookieValue是將cookie資料和控制器方法的形參建立對映關係

@CookieValue註解一共有三個屬性：value、required、defaultValue，用法同@RequestParam

session依賴於cookie，cookie在第一次請求時由伺服器建立，通過響應頭返回給瀏覽器並儲存在瀏覽器中，cookie預設在瀏覽器關閉後自動清除

解決獲取請求引數的亂碼問題

解決獲取請求引數的亂碼問題，可以使用SpringMVC提供的編碼過濾器CharacterEncodingFilter，需要在web.xml中進行註冊

<!--配置springMVC的編碼過濾器-->
<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

注：SpringMVC中處理編碼的過濾器一定要配置到其他過濾器之前，否則無效

域物件共享資料

servlet四種域物件

當前頁面 （pagecontext）

• 生命週期：當對JSP的請求時開始，當響應結束時銷燬。
• 作用範圍：整個JSP頁面，是四大作用域中最小的一個，即超過這個頁面就不能夠使用了。(所以使用pageContext物件向其它頁面傳遞引數是不可能的.)
• 常用功能：
  • 獲取其它八大隱式物件，可以認為是一個入口物件。
  • 獲取其所有域中的資料
  • 跳轉到其他資源，其身上提供了forward和include方法，簡化重定向和轉發的操作。

一次請求（requset）

	設定的物件在一次請求中有效，一次請求簡單的理解為使用者點選一次超連結，當使用者第二次點選的時候瀏覽器又傳送一個新的請求給伺服器，所以在一次點選後，後臺不管跳轉多少個servlet，jsp都算是一次請求，而後臺在所跳轉的任何介面都能訪問設定的物件（如登入介面向其他管理介面傳送登入的使用者資訊等）

• 生命週期：在service 方法呼叫前由伺服器建立，傳入service方法。整個請求結束，request生命結束。
• 作用範圍：整個請求鏈（請求轉發也存在）。
• 常用功能： 在整個請求鏈中共享資料。例如在Servlet 中處理好的資料交給Jsp顯示，此時引數就可以放置在Request域中帶過去

一次會話（session）

• 生命週期：在第一次呼叫 request.getSession() 方法時，伺服器會檢查是否已經有對應的session,如果沒有就在記憶體 中建立一個session並返回。當一段時間內session沒有被使用（預設為30分鐘），則伺服器會銷燬該session。如果伺服器非正常關閉（強行關閉），沒有到期的session也會跟著銷燬。如果呼叫session提供的invalidate（），可以立即銷燬session。

  注意：伺服器正常關閉，再啟動，Session物件會進行鈍化和活化操作。同時如果伺服器鈍化的時間在session 預設銷燬時間之內，則活化後session還是存在的。否則Session不存在。如果JavaBean 資料在session鈍化時，沒有實現Serializable 則當Session活化時，會消失。

• 作用範圍：一次會話，直到瀏覽器關閉或預設30分鐘沒有操作session銷燬。

• 常用功能：儲存使用者登入資訊。

ServletContext（整個專案）

• 生命週期：當伺服器啟動時該域物件，當伺服器關閉或Web應用被移除時，ServletContext物件跟著銷燬。

• 作用範圍：整個Web應用。相當於web應用的全域性變數（如統計網站的訪問率等）

• 常用功能：在不同Servlet 之間轉發，讀取資原始檔。

request域物件共享資料

使用原生ServletAPI

@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
    request.setAttribute("ServletRequestScope", "hello,servletAPI");
    return "success";
}

<!--thymleaf: 從request域中獲取共享資料 -->
<p th:text="${ServletRequestScope}"></p>

ModelAndView

@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
    /**
     * ModelAndView有Model和View的功能
     * Model主要用於向請求域共享資料
     * View主要用於設定檢視，實現頁面跳轉
     */
    ModelAndView mav = new ModelAndView();
    //向請求域共享資料
    mav.addObject("ModelAndViewRequestScope", "hello,ModelAndView");
    //設定檢視，實現頁面跳轉
    mav.setViewName("success");
    return mav;
}

Model

@RequestMapping("/testModel")
public String testModel(Model model){
    model.addAttribute("ModelRequestScope", "hello,Model");
    return "success";
}

Map

@RequestMapping("/testMap")
public String testMap(Map<String, Object> map){
    map.put("testScope", "hello,Map");
    return "success";
}

ModelMap

@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap){
    modelMap.addAttribute("testScope", "hello,ModelMap");
    return "success";
}

Model、ModelMap、Map的關係

Model、ModelMap、Map型別的引數其實本質上都是 BindingAwareModelMap型別的

public interface Model{}
public class ModelMap extends LinkedHashMap<String, Object> {}
public class ExtendedModelMap extends ModelMap implements Model {}
public class BindingAwareModelMap extends ExtendedModelMap {}

session

@RequestMapping("/testSession")
public String testSession(HttpSession session){   
    session.setAttribute("testSessionScope", "hello,session");    
    return "success";
}

<!--thymleaf: 從session域中獲取共享資料 -->
<p th:text="${sesson.testSessionScope}"></p>

ServletContext(Application)域

@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
	ServletContext application = session.getServletContext();
    application.setAttribute("testApplicationScope", "hello,application");
    return "success";
}

<!--thymleaf: 從servlet域中獲取共享資料 -->
<p th:text="${application.testApplicationScope}"></p>

SpringMVC的檢視

SpringMVC中的檢視是View介面，檢視的作用渲染資料，將模型Model中的資料展示給使用者

SpringMVC檢視的種類很多，預設有轉發檢視和重定向檢視

當工程引入jstl的依賴，轉發檢視會自動轉換為JstlView

若使用的檢視技術為Thymeleaf，在SpringMVC的配置檔案中配置了Thymeleaf的檢視解析器，由此檢視解析器解析之後所得到的是ThymeleafView

ThymeleafView

當控制器方法中所設定的檢視名稱沒有任何字首時，此時的檢視名稱會被SpringMVC配置檔案中所配置的檢視解析器解析，檢視名稱拼接檢視字首和檢視字尾所得到的最終路徑，會通過轉發的方式實現跳轉

@RequestMapping("/testHello")
public String testHello(){
    return "hello";
}

轉發檢視

SpringMVC中預設的轉發檢視是InternalResourceView

SpringMVC中建立轉發檢視的情況：

當控制器方法中所設定的檢視名稱以forward:為字首時，建立InternalResourceView檢視，此時的檢視名稱不會被SpringMVC配置檔案中所配置的檢視解析器解析，而是會將字首forward:去掉，剩餘部分作為最終路徑通過轉發的方式實現跳轉。

例如：

forward:/
forward:/employee

@RequestMapping("/testForward")
public String testForward(){
    return "forward:/testHello";
}

檢視控制器view-controller

重定向檢視

SpringMVC中預設的重定向檢視是RedirectView

當控制器方法中所設定的檢視名稱以redirect:為字首時，建立RedirectView檢視，此時的檢視名稱不會被SpringMVC配置檔案中所配置的檢視解析器解析，而是會將字首redirect:去掉，剩餘部分作為最終路徑通過重定向的方式實現跳轉

@RequestMapping("/testRedirect")
public String testRedirect(){
    return "redirect:/testHello";
}

檢視控制器view-controller

當控制器方法中，僅僅用來實現頁面跳轉，即只需要設定檢視名稱時，可以將處理器方法使用view-controller標籤進行表示，在spring配置檔案中新增

<!--
	path：設定處理的請求地址
	view-name：設定請求地址所對應的檢視名稱
-->
<mvc:view-controller path="/" view-name="index"></mvc:view-controller>
<!--開啟mvc註解驅動-->
<mvc:annotation-driven />

此時就可以刪除控制器方法

  @RequestMapping("/")
    public String index(HttpServletRequest request){
        return "index";
    }

注：

• 當SpringMVC中設定任何一個view-controller時，其他控制器中的請求對映將全部失效，此時需要在SpringMVC的核心配置檔案中設定開啟mvc註解驅動的標籤：<mvc:annotation-driven />

Restful

RESTful簡介

REST：Representational State Transfer，表現層資源狀態轉移。

a>資源

資源是一種看待伺服器的方式，即，將伺服器看作是由很多離散的資源組成。每個資源是伺服器上一個可命名的抽象概念。因為資源是一個抽象的概念，所以它不僅僅能代表伺服器檔案系統中的一個檔案、資料庫中的一張表等等具體的東西，可以將資源設計的要多抽象有多抽象，只要想象力允許而且客戶端應用開發者能夠理解。與物件導向設計類似，資源是以名詞為核心來組織的，首先關注的是名詞。一個資源可以由一個或多個URI來標識。URI既是資源的名稱，也是資源在Web上的地址。對某個資源感興趣的客戶端應用，可以通過資源的URI與其進行互動。

b>資源的表述

資源的表述是一段對於資源在某個特定時刻的狀態的描述。可以在客戶端-伺服器端之間轉移（交換）。資源的表述可以有多種格式，例如HTML/XML/JSON/純文字/圖片/視訊/音訊等等。資源的表述格式可以通過協商機制來確定。請求-響應方向的表述通常使用不同的格式。

c>狀態轉移

狀態轉移說的是：在客戶端和伺服器端之間轉移（transfer）代表資源狀態的表述。通過轉移和操作資源的表述，來間接實現操作資源的目的。

實現

具體說，就是 HTTP 協議裡面，四個表示操作方式的動詞：GET、POST、PUT、DELETE。

它們分別對應四種基本操作：GET 用來獲取資源，POST 用來新建資源，PUT 用來更新資源，DELETE 用來刪除資源。

REST 風格提倡 URL 地址使用統一的風格設計，從前到後各個單詞使用斜槓分開，不使用問號鍵值對方式攜帶請求引數，而是將要傳送給伺服器的資料作為 URL 地址的一部分，以保證整體風格的一致性。

操作	傳統方式	REST風格
查詢操作	getUserById?id=1	user/1-->get請求方式
儲存操作	saveUser	user-->post請求方式
刪除操作	deleteUser?id=1	user/1-->delete請求方式
更新操作	updateUser	user-->put請求方式

過濾器HiddenHttpMethodFilter

由於瀏覽器只支援傳送get和post方式的請求，那麼該如何傳送put和delete請求呢？

SpringMVC 提供了 HiddenHttpMethodFilter 幫助我們將 POST 請求轉換為 DELETE 或 PUT 請求

HiddenHttpMethodFilter處理put和delete請求的需要滿足條件：

• 當前請求的請求方式必須為post
• 當前請求必須傳輸請求引數_method

滿足以上條件，HiddenHttpMethodFilter過濾器就會將當前請求的請求方式轉換為請求引數_method的值，因此請求引數_method的值才是最終的請求方式

在web.xml中註冊HiddenHttpMethodFilter

<filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

注：目前為止，SpringMVC中提供了兩個過濾器：CharacterEncodingFilter和HiddenHttpMethodFilter

在web.xml中註冊時，必須先註冊CharacterEncodingFilter，再註冊HiddenHttpMethodFilter

原因：CharacterEncodingFilter 中通過 request.setCharacterEncoding(encoding) 方法設定字符集的，要求前面不能有任何獲取請求引數的操作。而 HiddenHttpMethodFilter 恰恰有一個後去請求引數_method當作真實請求方式的操作

RESTful案例

準備工作

和傳統 CRUD 一樣，實現對員工資訊的增刪改查。

搭建環境

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--配置編碼過濾器-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--配置處理請求方式put和delete的HiddenHttpMethodFilter-->
    <filter>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--配置SpringMVC的前端控制器DispatcherServlet-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

spring配置檔案springMVC.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--掃描元件-->
    <context:component-scan base-package="com.birdy.rest"></context:component-scan>

    <!--配置Thymeleaf檢視解析器-->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">

                        <!-- 檢視字首 -->
                        <property name="prefix" value="/WEB-INF/templates/"/>

                        <!-- 檢視字尾 -->
                        <property name="suffix" value=".html"/>
                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8" />
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

    <!--配置檢視控制器-->
    <mvc:view-controller path="/" view-name="index"></mvc:view-controller>
    <mvc:view-controller path="/toAdd" view-name="employee_add"></mvc:view-controller>

    <!--開放對靜態資源的訪問-->
    <mvc:default-servlet-handler />

    <!--開啟mvc註解驅動-->
    <mvc:annotation-driven />

</beans>

實體類

package com.birdy.mvc.bean;

public class Employee {

   private Integer id;
   private String lastName;

   private String email;
   //1 male, 0 female
   private Integer gender;
   
   public Integer getId() {
      return id;
   }

   public void setId(Integer id) {
      this.id = id;
   }

   public String getLastName() {
      return lastName;
   }

   public void setLastName(String lastName) {
      this.lastName = lastName;
   }

   public String getEmail() {
      return email;
   }

   public void setEmail(String email) {
      this.email = email;
   }

   public Integer getGender() {
      return gender;
   }

   public void setGender(Integer gender) {
      this.gender = gender;
   }

   public Employee(Integer id, String lastName, String email, Integer gender) {
      super();
      this.id = id;
      this.lastName = lastName;
      this.email = email;
      this.gender = gender;
   }

   public Employee() {
   }
}

準備dao模擬資料

package com.birdy.mvc.dao;

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

import com.birdy.mvc.bean.Employee;
import org.springframework.stereotype.Repository;


@Repository
public class EmployeeDao {

   private static Map<Integer, Employee> employees = null;
   
   static{
      employees = new HashMap<Integer, Employee>();

      employees.put(1001, new Employee(1001, "E-AA", "aa@163.com", 1));
      employees.put(1002, new Employee(1002, "E-BB", "bb@163.com", 1));
      employees.put(1003, new Employee(1003, "E-CC", "cc@163.com", 0));
      employees.put(1004, new Employee(1004, "E-DD", "dd@163.com", 0));
      employees.put(1005, new Employee(1005, "E-EE", "ee@163.com", 1));
   }
   
   private static Integer initId = 1006;
   
   public void save(Employee employee){
      if(employee.getId() == null){
         employee.setId(initId++);
      }
      employees.put(employee.getId(), employee);
   }
   
   public Collection<Employee> getAll(){
      return employees.values();
   }
   
   public Employee get(Integer id){
      return employees.get(id);
   }
   
   public void delete(Integer id){
      employees.remove(id);
   }
}

功能清單

功能	URL 地址	請求方式
訪問首頁√	/	GET
查詢全部資料√	/employee	GET
刪除√	/employee/2	DELETE
跳轉到新增資料頁面√	/toAdd	GET
執行儲存√	/employee	POST
跳轉到更新資料頁面√	/employee/2	GET
執行更新√	/employee	PUT

具體功能：訪問首頁

配置view-controller

<mvc:view-controller path="/" view-name="index"/>

建立頁面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8" >
    <title>Title</title>
</head>
<body>
<h1>首頁</h1>
<a th:href="@{/employee}">訪問員工資訊</a>
</body>
</html>

查詢所有員工資料

@RequestMapping(value = "/employee", method = RequestMethod.GET)
public String getEmployeeList(Model model){
    Collection<Employee> employeeList = employeeDao.getAll();
    model.addAttribute("employeeList", employeeList);
    return "employee_list";
}

建立employee_list.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Employee Info</title>
    <script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
</head>
<body>

    <table border="1" cellpadding="0" cellspacing="0" style="text-align: center;" id="dataTable">
        <tr>
            <th colspan="5">Employee Info</th>
        </tr>
        <tr>
            <th>id</th>
            <th>lastName</th>
            <th>email</th>
            <th>gender</th>
            <th>options(<a th:href="@{/toAdd}">add</a>)</th>
        </tr>
        <tr th:each="employee : ${employeeList}">
            <td th:text="${employee.id}"></td>
            <td th:text="${employee.lastName}"></td>
            <td th:text="${employee.email}"></td>
            <td th:text="${employee.gender}"></td>
            <td>
                <a class="deleteA" @click="deleteEmployee" th:href="@{'/employee/'+${employee.id}}">delete</a>
                <a th:href="@{'/employee/'+${employee.id}}">update</a>
            </td>
        </tr>
    </table>
</body>
</html>

刪除

a>建立處理delete請求方式的表單

<!-- 作用：通過超連結控制表單的提交，將post請求轉換為delete請求 -->
<form id="delete_form" method="post">
    <!-- HiddenHttpMethodFilter要求：必須傳輸_method請求引數，並且值為最終的請求方式 -->
    <input type="hidden" name="_method" value="delete"/>
</form>

b>刪除超連結繫結點選事件

引入vue.js

<script type="text/javascript" th:src="@{/static/js/vue.js}"></script>

刪除超連結

<a class="deleteA" @click="deleteEmployee" th:href="@{'/employee/'+${employee.id}}">delete</a>

通過vue處理點選事件

<script type="text/javascript">
    var vue = new Vue({
        el:"#dataTable",
        methods:{
            //event表示當前事件
            deleteEmployee:function (event) {
                //通過id獲取表單標籤
                var delete_form = document.getElementById("delete_form");
                //將觸發事件的超連結的href屬性為表單的action屬性賦值
                delete_form.action = event.target.href;
                //提交表單
                delete_form.submit();
                //阻止超連結的預設跳轉行為
                event.preventDefault();
            }
        }
    });
</script>

控制器方法

@RequestMapping(value = "/employee/{id}", method = RequestMethod.DELETE)
public String deleteEmployee(@PathVariable("id") Integer id){
    employeeDao.delete(id);
    return "redirect:/employee";
}

跳轉到新增資料頁面

配置view-controller

<mvc:view-controller path="/toAdd" view-name="employee_add"></mvc:view-controller>

b>建立employee_add.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Add Employee</title>
</head>
<body>

<form th:action="@{/employee}" method="post">
    lastName:<input type="text" name="lastName"><br>
    email:<input type="text" name="email"><br>
    gender:<input type="radio" name="gender" value="1">male
    <input type="radio" name="gender" value="0">female<br>
    <input type="submit" value="add"><br>
</form>

</body>
</html>

具體功能：執行儲存

a>控制器方法

@RequestMapping(value = "/employee", method = RequestMethod.POST)
public String addEmployee(Employee employee){
    employeeDao.save(employee);
    return "redirect:/employee";
}

跳轉到更新資料頁面

a>修改超連結

<a th:href="@{'/employee/'+${employee.id}}">update</a>

b>控制器方法

@RequestMapping(value = "/employee/{id}", method = RequestMethod.GET)
public String getEmployeeById(@PathVariable("id") Integer id, Model model){
    Employee employee = employeeDao.get(id);
    model.addAttribute("employee", employee);
    return "employee_update";
}

c>建立employee_update.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Update Employee</title>
</head>
<body>

<form th:action="@{/employee}" method="post">
    <input type="hidden" name="_method" value="put">
    <input type="hidden" name="id" th:value="${employee.id}">
    lastName:<input type="text" name="lastName" th:value="${employee.lastName}"><br>
    email:<input type="text" name="email" th:value="${employee.email}"><br>
    <!--
        th:field="${employee.gender}"可用於單選框或核取方塊的回顯
        若單選框的value和employee.gender的值一致，則新增checked="checked"屬性
    -->
    gender:<input type="radio" name="gender" value="1" th:field="${employee.gender}">male
    <input type="radio" name="gender" value="0" th:field="${employee.gender}">female<br>
    <input type="submit" value="update"><br>
</form>

</body>
</html>

執行更新

a>控制器方法

@RequestMapping(value = "/employee", method = RequestMethod.PUT)
public String updateEmployee(Employee employee){
    employeeDao.save(employee);
    return "redirect:/employee";
}

HttpMessageConverter

HttpMessageConverter，報文資訊轉換器，將請求報文轉換為Java物件，或將Java物件轉換為響應報文

HttpMessageConverter提供了兩個註解和兩個型別:

• @RequestBody
• @ResponseBody
• RequestEntity
• ResponseEntity

@RequestBody

@RequestBody可以獲取請求體，需要在控制器方法設定一個形參，使用@RequestBody進行標識，當前請求的請求體就會為當前註解所標識的形參賦值

<form th:action="@{/testRequestBody}" method="post">
    使用者名稱：<input type="text" name="username"><br>
    密碼：<input type="password" name="password"><br>
    <input type="submit">
</form>

@RequestMapping("/testRequestBody")
public String testRequestBody(@RequestBody String requestBody){
    System.out.println("requestBody:"+requestBody);
    return "success";
}
//輸出結果：requestBody:username=admin&password=123456

RequestEntity

RequestEntity封裝請求報文的一種型別，需要在控制器方法的形參中設定該型別的形參，當前請求的請求報文就會賦值給該形參，可以通過getHeaders()獲取請求頭資訊，通過getBody()獲取請求體資訊

@RequestMapping("/testRequestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity){
    System.out.println("requestHeader:"+requestEntity.getHeaders());
    System.out.println("requestBody:"+requestEntity.getBody());
    return "success";
}

輸出結果：

requestHeader:[host:"localhost:8080", connection:"keep-alive", content-length:"27", cache-control:"max-age=0", sec-ch-ua:"" Not A;Brand";v="99", "Chromium";v="90", "Google Chrome";v="90"", sec-ch-ua-mobile:"?0", upgrade-insecure-requests:"1", origin:"http://localhost:8080", user-agent:"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.93 Safari/537.36"]

requestBody:username=admin&password=123

@ResponseBody

@ResponseBody註解的作用是將controller的方法返回的物件通過適當的轉換器轉換為指定的格式之後，寫入到response物件的body區，通常用來返回JSON資料或者是XML。需要注意的呢，在使用此註解之後不會再走試圖處理器，而是直接將資料寫入到輸入流中，他的效果等同於通過response物件輸出指定格式的資料。

@RequestMapping("/login")
@ResponseBody
public User login(User user){
    return user;
}
	//User欄位：userName pwd
   // 那麼在前臺接收到的資料為：'{"userName":"xxx","pwd":"xxx"}'

   // 效果等同於如下程式碼：
    @RequestMapping("/login")
    public void login(User user, HttpServletResponse response){
    response.getWriter.write(JSONObject.fromObject(user).toString());
}

@ResponseBody是作用在方法上的，@ResponseBody 表示該方法的返回結果直接寫入 HTTP response body 中，一般在非同步獲取資料時使用

@ResponseBody儘量不要用在get請求中

SpringMVC處理json

@ResponseBody處理json的步驟：

1、匯入jackson的依賴

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.1</version>
</dependency>

2、在SpringMVC的核心配置檔案中開啟mvc的註解驅動，此時在HandlerAdaptor中會自動裝配一個訊息轉換器：MappingJackson2HttpMessageConverter，可以將響應到瀏覽器的Java物件轉換為Json格式的字串

<mvc:annotation-driven />

3、在處理器方法上使用@ResponseBody註解進行標識，將Java物件直接作為控制器方法的返回值返回，就會自動轉換為Json格式的字串

@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser(){
    return new User(1001,"admin","123456",23,"男");
}

瀏覽器的頁面中展示的結果：

{"id":1001,"username":"admin","password":"123456","age":23,"sex":"男"}

處理Ajax

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>ajax</title>
</head>
<body>
   <div id="app">
       <a th:href="@{/testAjax}" @click="testAjax">測試ajax</a>
   </div>
    <script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
    <script type="text/javascript" th:src="@{/static/js/axios.min.js}"></script>
    <script type="text/javascript">
        new Vue({
            el: "#app",
            methods: {
                testAjax(event){
                    axios({
                        method: "post",
                        url: event.target.href,
                        params: {
                            username: "admin",
                            password: "123456"
                        }
                    }).then((res)=>{
                        alert(res.data)
                    })
                    //阻止超連結預設跳轉行為
                    event.preventDefault();
                }
            }
        })
    </script>
</body>
</html>

	@PostMapping("/testAjax")
	@ResponseBody
	public String testAjax(){
		return "hello,ajax";
	}

檔案上傳和下載

檔案下載

使用ResponseEntity實現下載檔案的功能

@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
    //獲取ServletContext物件
    ServletContext servletContext = session.getServletContext();
    //獲取伺服器中檔案的真實路徑
    String realPath = servletContext.getRealPath("/static/img/1.jpg");
    //建立輸入流
    InputStream is = new FileInputStream(realPath);
    //建立位元組陣列
    byte[] bytes = new byte[is.available()];
    //將流讀到位元組陣列中
    is.read(bytes);
    //建立HttpHeaders物件設定響應頭資訊
    MultiValueMap<String, String> headers = new HttpHeaders();
    //設定要下載方式以及下載檔案的名字
    headers.add("Content-Disposition", "attachment;filename=1.jpg");
    //設定響應狀態碼
    HttpStatus statusCode = HttpStatus.OK;
    //建立ResponseEntity物件
    ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes,headers,statusCode);
    //關閉輸入流
    is.close();
    return responseEntity;
}

檔案上傳

檔案上傳要求form表單的請求方式必須為post，並且新增屬性enctype="multipart/form-data"

SpringMVC中將上傳的檔案封裝到MultipartFile物件中，通過此物件可以獲取檔案相關資訊

1、新增依賴：

<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>

2、在SpringMVC的配置檔案中新增配置：

<!--必須通過檔案解析器的解析才能將檔案轉換為MultipartFile物件，且必須配置id屬性-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

3、控制器方法：

@RequestMapping("/testUp")
public String testUp(MultipartFile photo, HttpSession session) throws IOException {
    //獲取上傳的檔案的檔名
    String fileName = photo.getOriginalFilename();
    //處理檔案重名問題
    String hzName = fileName.substring(fileName.lastIndexOf("."));
    fileName = UUID.randomUUID().toString() + hzName;
    //獲取伺服器中photo目錄的路徑
    ServletContext servletContext = session.getServletContext();
    String photoPath = servletContext.getRealPath("photo");
    File file = new File(photoPath);
    if(!file.exists()){
        file.mkdir();
    }
    String finalPath = photoPath + File.separator + fileName;
    //實現上傳功能
    photo.transferTo(new File(finalPath));
    return "success";
}

攔截器

SpringMVC中的攔截器用於攔截控制器方法的執行

攔截器的配置

SpringMVC中的攔截器需要實現HandlerInterceptor

@Component
public class FirstInterceptor implements HandlerInterceptor {
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
		System.out.println("FirstInterceptor-->preHandle");
		return true;
	}

	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
		System.out.println("FirstInterceptor-->postHandle");
	}

	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
		System.out.println("FirstInterceptor-->afterCompletion");
	}
}

SpringMVC的攔截器必須在Spring的配置檔案中進行配置：

攔截所有請求

<mvc:interceptors>
<!--按元件名配置：注意預設情況下容器中的元件自動變駝峰命名-->
    <ref bean="firstInterceptor"></ref>
</mvc:interceptors>

或

<mvc:interceptors>
   <!--按類名配置-->
<bean class="com.birdy.interceptor.FirstInterceptor"></bean>
</mvc:interceptors>

自定義攔截請求

 <mvc:interceptor>
        <!--攔截所有請求-->
        <mvc:mapping path="/**"/>
        <!--配置不攔截的請求-->
        <mvc:exclude-mapping path="/"/>
        <ref bean="firstInterceptor"></ref>
    </mvc:interceptor>

攔截器的三個抽象方法

SpringMVC中的攔截器有三個抽象方法：

• preHandle：控制器方法執行之前執行，其boolean型別的返回值表示是否攔截或放行
  • 返回true為放行，即呼叫控制器方法；
  • 返回false表示攔截，即不呼叫控制器方法
• postHandle：控制器方法執行之後執行postHandle()
• afterComplation：處理完檢視和模型資料，渲染檢視完畢之後執行afterComplation()

多個攔截器的執行順序

若每個攔截器的preHandle()都返回true。此時多個攔截器的執行順序和攔截器在SpringMVC的配置檔案的配置順序有關：

• preHandle()會按照配置的順序執行，而postHandle()和afterComplation()會按照配置的反序執行
• 若某個攔截器的preHandle()返回了false，preHandle()返回false和它之前的攔截器的preHandle()都會執行，postHandle()都不執行，返回false的攔截器之前的攔截器的afterComplation()會執行

異常處理器

基於配置的異常處理

SpringMVC提供了一個處理控制器方法執行過程中所出現的異常的介面：HandlerExceptionResolver

HandlerExceptionResolver介面的實現類有：DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver

SpringMVC提供了自定義的異常處理器SimpleMappingExceptionResolver，使用方式：

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
        	<!--
        		properties的鍵表示處理器方法執行過程中出現的異常
        		properties的值表示若出現指定異常時，設定一個新的檢視名稱，跳轉到指定頁面
        	-->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!--
    	exceptionAttribute屬性設定一個屬性名，將出現的異常資訊在請求域中進行共享
    -->
    <property name="exceptionAttribute" value="ex"></property>
</bean>

基於註解的異常處理

//@ControllerAdvice將當前類標識為異常處理的元件
@ControllerAdvice
public class ExceptionController {

    //@ExceptionHandler用於設定所標識方法處理的異常
    @ExceptionHandler(ArithmeticException.class)
    //ex表示當前請求處理中出現的異常物件
    public String handleArithmeticException(Exception ex, Model model){
        //將將異常資訊放在域裡共享
        model.addAttribute("ex", ex);
        return "error";
    }

}

測試

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>ajax</title>
</head>
<body>
   <a th:href="@{/testEx}">測試異常處理</a>
</body>
</html>

出現異常後跳轉的頁面

<!--error.html-->
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
出現錯誤
<!--/*@thymesVar id="ex" type="request"*/-->
<p th:text="${ex}"></p>
</body>
</html>

註解配置SpringMVC

建立初始化類，代替web.xml

在Servlet3.0環境中，容器會在類路徑中查詢實現javax.servlet.ServletContainerInitializer介面的類，如果找到的話就用它來配置Servlet容器。

Spring提供了這個介面的實現，名為SpringServletContainerInitializer，這個類反過來又會查詢實現WebApplicationInitializer的類並將配置的任務交給它們來完成。

Spring3.2引入了一個便利的WebApplicationInitializer基礎實現，名為AbstractAnnotationConfigDispatcherServletInitializer，當我們的類擴充套件了AbstractAnnotationConfigDispatcherServletInitializer並將其部署到Servlet3.0容器的時候，容器會自動發現它，並用它來配置Servlet上下文

public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {

    /**
     * 指定spring的配置類
     * @return
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    /**
     * 指定SpringMVC的配置類
     * @return
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    /**
     * 指定DispatcherServlet的對映規則，即url-pattern
     * @return
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /**
     * 新增過濾器
     * @return
     */
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        encodingFilter.setForceRequestEncoding(true);
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{encodingFilter, hiddenHttpMethodFilter};
    }
}

Spring配置類

建立SpringConfig配置類，代替spring的配置檔案

@Configuration
public class SpringConfig {
	//ssm整合之後，spring的配置資訊寫在此類中
}

SpringMVC的配置檔案

建立WebConfig配置類，代替SpringMVC的配置檔案

@Configuration
//掃描元件
@ComponentScan("com.atguigu.mvc.controller")
//開啟MVC註解驅動
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    //使用預設的servlet處理靜態資源
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    //配置檔案上傳解析器
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        return new CommonsMultipartResolver();
    }

    //配置攔截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        FirstInterceptor firstInterceptor = new FirstInterceptor();
        registry.addInterceptor(TestInterceptor).addPathPatterns("/**");
    }
    
    //配置檢視控制
   
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }
    
    //配置異常對映
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException", "error");
        //設定異常對映
        exceptionResolver.setExceptionMappings(prop);
        //設定共享異常資訊的鍵
        exceptionResolver.setExceptionAttribute("ex");
        resolvers.add(exceptionResolver);
    }

    //配置生成模板解析器
    @Bean
    public ITemplateResolver templateResolver() {
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        // ServletContextTemplateResolver需要一個ServletContext作為構造引數，可通過WebApplicationContext 的方法獲得
        ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(
                webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("UTF-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }

    //生成模板引擎併為模板引擎注入模板解析器
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }

    //生成檢視解析器並未解析器注入模板引擎
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }

}

攔截器

public class TestInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("TestInterceptor-->preHandle");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}