《無悔華夏攻略》名臣彩蛋盤點（2）

阿新 • • 發佈：2022-03-30

1.MVC是什麼

MVC是模型(Model)、檢視(View)、控制器(Controller)的簡寫，是一種軟體設計規範。
是將業務邏輯、資料、顯示分離的方法來組織程式碼。
MVC主要作用是降低了檢視與業務邏輯間的雙向偶合。
MVC不是一種設計模式，MVC是一種架構模式。當然不同的MVC存在差異。

Model（模型）：資料模型，提供要展示的資料，因此包含資料和行為，可以認為是領域模型或JavaBean元件（包含資料和行為），不過現在一般都分離開來：Value Object（資料Dao）和服務層（行為Service）。也就是模型提供了模型資料查詢和模型資料的狀態更新等功能，包括資料和業務。

View（檢視）：負責進行模型的展示，一般就是我們見到的使用者介面，客戶想看到的東西。

Controller（控制器）：接收使用者請求，委託給模型進行處理（狀態改變），處理完畢後把返回的模型資料返回給檢視，由檢視負責展示。也就是說控制器做了個排程員的工作。

最典型的MVC就是JSP + servlet + javabean的模式。

1.1 Model1時代

在web早期的開發中，通常採用的都是Model1。
Model1中，主要分為兩層，檢視層和模型層。

Model1優點：架構簡單，比較適合小型專案開發；
Model1缺點：JSP職責不單一，職責過重，不便於維護；

1.2 Model2時代

Model2把一個專案分成三部分，包括檢視、控制、模型。

使用者發請求

Servlet接收請求資料，並呼叫對應的業務邏輯方法
業務處理完畢，返回更新後的資料給servlet
servlet轉向到JSP，由JSP來渲染頁面
響應給前端更新後的頁面

職責分析：

Controller：控制器

取得表單資料
呼叫業務邏輯
轉向指定的頁面

Model：模型

業務邏輯
儲存資料的狀態

View：檢視

顯示頁面

Model2這樣不僅提高了程式碼的複用率與專案的擴充套件性，且大大降低了專案的維護成本。Model1模式的實現比較簡單，適用於快速開發小規模專案，Model1中JSP頁面身兼View和Controller兩種角色，將控制邏輯和表現邏輯混雜在一起，從而導致程式碼的重用性非常低，增加了應用的擴充套件性和維護的難度。Model2消除了Model1的缺點。

1.3 回顧Servlet

新建一個普通Maven工程當做父工程！匯入依賴！

<dependencies>
    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <!--spring-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
    <!--servlet-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <!--jsp-->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
    </dependency>
    <!--jstl-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

建立一個子模組(Module)，新增web app【右擊子模組-->Add Framework Support】的支援！

匯入servlet 和 jsp 的 jar 依賴

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
</dependency>

編寫一個Servlet類，用來處理使用者的請求

// 實現Servlet介面
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 獲取請求引數
        String method = req.getParameter("method");
        if (method.equals("add"))
            req.getSession().setAttribute("msg","執行了add方法");
        if (method.equals("delete"))
            req.getSession().setAttribute("msg","執行了delete方法");
        // 業務邏輯
        // 檢視跳轉
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

編寫test.jsp，在WEB-INF目錄下新建一個jsp的資料夾，新建test.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
 ${msg}
</body>
</html>

在web.xml中註冊Servlet

<?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">

    <!--註冊servlet-->
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.tian.controller.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

</web-app>

配置Tomcat，並啟動測試

localhost:8080/hello?method=add
localhost:8080/hello?method=delete

測試結果

MVC框架要做哪些事情

將url對映到java類或java類的方法 .
封裝使用者提交的資料 .
處理請求--呼叫相關的業務處理--封裝響應資料 .
將響應的資料進行渲染. jsp / html 等表示層資料 .

說明：

常見的伺服器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；常見前端MVC框架：vue、angularjs、react、backbone；由MVC演化出了另外一些模式如：MVP、MVVM 等等....

2.SpringMVC是什麼

2.1 概述

Spring MVC是Spring Framework的一部分，是基於Java實現MVC的輕量級Web框架。

檢視官方文件：https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web

我們為什麼要學習SpringMVC呢?

Spring MVC的特點：

輕量級，簡單易學
高效 , 基於請求響應的MVC框架
與Spring相容性好，無縫結合
約定大於配置
功能強大：RESTful、資料驗證、格式化、本地化、主題等
簡潔靈活

Spring的web框架圍繞DispatcherServlet [ 排程Servlet ] 設計。

DispatcherServlet的作用是將請求分發到不同的處理器。從Spring 2.5開始，使用Java 5或者以上版本的使用者可以採用基於註解形式進行開發，十分簡潔；

正因為SpringMVC好 , 簡單 , 便捷 , 易學 , 天生和Spring無縫整合(使用Spring IoC和Aop) , 使用約定優於配置 . 能夠進行簡單的junit測試 . 支援Restful風格 .異常處理 , 本地化 , 國際化 , 資料驗證 , 型別轉換 , 攔截器等等......所以我們要學習 .

最重要的一點還是用的人多 , 使用的公司多 .

2.2 中心控制器

Spring的web框架圍繞DispatcherServlet【前端控制器】設計。 DispatcherServlet的作用是將請求分發到不同的處理器。從Spring 2.5開始，使用Java 5或者以上版本的使用者可以採用基於註解的controller宣告方式。

Spring MVC框架像許多其他MVC框架一樣, 以請求為驅動 , 圍繞一箇中心Servlet分派請求及提供其他功能，DispatcherServlet是一個實際的Servlet (它繼承自HttpServlet 基類)。

SpringMVC的原理如下圖所示：

當發起請求時被前置的控制器攔截到請求，根據請求引數生成代理請求，找到請求對應的實際控制器，控制器處理請求，建立資料模型，訪問資料庫，將模型響應給中心控制器，控制器使用模型與檢視渲染檢視結果，將結果返回給中心控制器，再將結果返回給請求者。

2.3 SpringMVC執行原理

圖為SpringMVC的一個較完整的流程圖，實線表示SpringMVC框架提供的技術，不需要開發者實現，虛線表示需要開發者實現。

簡要分析執行流程

DispatcherServlet表示前置控制器，是整個SpringMVC的控制中心。使用者發出請求，DispatcherServlet接收請求並攔截請求。
- 我們假設請求的url為 : http://localhost:8080/SpringMVC/hello
- 如上url拆分成三部分：
- http://localhost:8080 伺服器域名
- SpringMVC 部署在伺服器上的web站點
- hello 表示控制器
- 通過分析，如上url表示為：請求位於伺服器localhost:8080上的SpringMVC站點的hello控制器。
HandlerMapping為處理器對映。DispatcherServlet呼叫HandlerMapping,HandlerMapping根據請求url查詢Handler。
HandlerExecution表示具體的Handler,其主要作用是根據url查詢控制器，如上url被查詢控制器為：hello。
HandlerExecution將解析後的資訊傳遞給DispatcherServlet,如解析控制器對映等。
HandlerAdapter表示處理器介面卡，其按照特定的規則去執行Handler。
Handler讓具體的Controller執行。
Controller將具體的執行資訊返回給HandlerAdapter,如ModelAndView。
HandlerAdapter將檢視邏輯名或模型傳遞給DispatcherServlet。
DispatcherServlet呼叫檢視解析器(ViewResolver)來解析HandlerAdapter傳遞的邏輯檢視名。
檢視解析器將解析的邏輯檢視名傳給DispatcherServlet。
DispatcherServlet根據檢視解析器解析的檢視結果，呼叫具體的檢視。
最終檢視呈現給使用者。

3.HelloSpringMVC(配置版)

新建一個Moudle ，新增web的支援！
確定匯入了SpringMVC 的依賴！
配置web.xml ，註冊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">
 
    <!--配置DispatcherServlet：這個是SpringMVC的核心；【前端控制器】-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--繫結一個一個springmvc的配置檔案:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--啟動級別-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>
 
    <!--/ 匹配所有的請求；（不包括.jsp）-->
    <!--/* 匹配所有的請求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
 
</web-app>

編寫SpringMVC 的配置檔案！名稱：springmvc-servlet.xml : [servletname]-servlet.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"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
 
</beans>

配置處理器對映器

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

配置處理器介面卡

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

配置檢視解析器

<!--檢視解析器:DispatcherServlet給他的ModelAndView-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
    <!--字首-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--字尾-->
    <property name="suffix" value=".jsp"/>
</bean>

編寫我們要操作的業務Controller ，要麼實現Controller介面，要麼增加註解；需要返回一個ModelAndView，封裝裝資料，檢視；

package com.kuang.controller;
 
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
//注意：這裡我們先匯入Controller介面
public class HelloController implements Controller {
 
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和檢視
        ModelAndView mv = new ModelAndView();
 
        //封裝物件，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封裝要跳轉的檢視，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

將自己寫好的類交給SpringIOC容器託管，註冊bean。

<!--Handler-->
<bean id="/hello" class="com.kuang.controller.HelloController"/>

寫要跳轉的jsp頁面，顯示ModelandView存放的資料，以及我們的正常頁面；

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>title</title>
</head>
<body>
    ${msg}
</body>
</html>

配置Tomcat 啟動測試！

可能遇到的問題：訪問出現404，排查步驟：

檢視控制檯輸出，看一下是不是缺少了什麼jar包。
如果jar包存在，顯示無法輸出，就在IDEA的專案釋出中，新增lib依賴！（與classes同級目錄）

重啟Tomcat 即可解決！

小結：看這個估計大部分同學都能理解其中的原理了，但是我們實際開發才不會這麼寫，不然就瘋了，還學這個玩意幹嘛！我們來看個註解版實現，這才是SpringMVC的精髓，到底有多麼簡單，看這個圖就知道了。

4.使用註解開發SpringMVC(註解版)

第一步:新建一個Moudle , 新增web支援！

第二步:由於Maven可能存在資源過濾的問題，我們將配置完善！

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

第三步:在pom.xml檔案引入相關的依賴

主要有Spring框架核心庫、Spring MVC、servlet , JSTL等。我們在父依賴中已經引入了！

第四步:配置web.xml

注意點：

注意web.xml版本問題，要最新版！
註冊DispatcherServlet
關聯SpringMVC的配置檔案
啟動級別為1
對映路徑為 / 【不要用/*，會404】

<?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">
 
    <!--註冊DispatcherServlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通過初始化引數指定SpringMVC配置檔案的位置，進行關聯-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 啟動順序，數字越小，啟動越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
 
    <!--所有請求都會被springmvc攔截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
 
</web-app>

/ 和 /* 的區別：

< url-pattern > / </ url-pattern > 不會匹配到.jsp， 只針對我們編寫的請求；
即：.jsp 不會進入spring的 DispatcherServlet類 。

< url-pattern > /* </ url-pattern > 會匹配 *.jsp，
會出現返回 jsp檢視 時再次進入spring的DispatcherServlet 類，導致找不到對應的controller所以報404錯。

第五步:新增Spring MVC配置檔案

讓IOC的註解生效
靜態資源過濾：HTML . JS . CSS . 圖片，視訊 .....
MVC的註解驅動
配置檢視解析器

在resource目錄下新增springmvc-servlet.xml配置檔案，配置的形式與Spring容器配置基本類似，為了支援基於註解的IOC，設定了自動掃描包的功能，具體配置資訊如下：

<?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">
 
    <!-- 自動掃描包，讓指定包下的註解生效,由IOC容器統一管理 -->
    <context:component-scan base-package="com.tian.controller"/>
    <!-- 讓Spring MVC不處理靜態資源 過濾掉一些靜態資源，如.css  .js  .html .mp3-->
    <mvc:default-servlet-handler />
    <!--
    支援mvc註解驅動
        在spring中一般採用@RequestMapping註解來完成對映關係
        要想使@RequestMapping註解生效
        必須向上下文中註冊DefaultAnnotationHandlerMapping
        和一個AnnotationMethodHandlerAdapter例項
        這兩個例項分別在類級別和方法級別處理。
        而annotation-driven配置幫助我們自動完成上述兩個例項的注入。
     -->
    <mvc:annotation-driven />
 
    <!--配置檢視解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 字首 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 字尾 -->
        <property name="suffix" value=".jsp" />
    </bean>
 
</beans>

在檢視解析器中我們把所有的檢視都存放在/WEB-INF/目錄下，這樣可以保證檢視安全，因為這個目錄下的檔案，客戶端不能直接訪問。

第六步:建立Controller

編寫一個Java控制類： HelloController , 注意編碼規範

@Controller
@RequestMapping("/HelloController")
public class HelloController {

    //真實訪問地址 : 專案名/HelloController/hello
    @RequestMapping("/hello")//請求路徑
    public String sayHello(Model model) {
        //向模型中新增屬性msg與值，可以在JSP頁面中取出並渲染
        model.addAttribute("msg", "hello,SpringMVC！");
        //會被檢視解析器處理，web-inf/jsp/hello.jsp
        return "hello";
    }
}

@Controller是為了讓Spring IOC容器初始化時自動掃描到；
@RequestMapping是為了對映請求路徑，這裡因為類與方法上都有對映所以訪問時應該是/HelloController/hello；
方法中宣告Model型別的引數是為了把Action中的資料帶到檢視中；
方法返回的結果是檢視的名稱hello，加上配置檔案中的前後綴變成WEB-INF/jsp/hello.jsp。

第七步:建立檢視層

在WEB-INF/ jsp目錄中建立hello.jsp ，檢視可以直接取出並展示從Controller帶回的資訊；

可以通過EL表示式取出Model中存放的值，或者物件；

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>SpringMVC</title>
</head>
<body>
    ${msg}
</body>
</html>

第八步:配置Tomcat執行

配置Tomcat ，開啟伺服器，訪問對應的請求路徑！

OK，執行成功！

小結：

實現步驟其實非常的簡單：

新建一個web專案
匯入相關jar包
編寫web.xml , 註冊DispatcherServlet
編寫springmvc配置檔案
接下來就是去建立對應的控制類 , controller
最後完善前端檢視和controller之間的對應
測試執行除錯.

使用springMVC必須配置的三大件：

處理器對映器、處理器介面卡、檢視解析器

通常，我們只需要手動配置檢視解析器，而處理器對映器和處理器介面卡只需要開啟註解驅動即可，而省去了大段的xml配置

<!--
    支援mvc註解驅動
        在spring中一般採用@RequestMapping註解來完成對映關係
        要想使@RequestMapping註解生效
        必須向上下文中註冊DefaultAnnotationHandlerMapping
        和一個AnnotationMethodHandlerAdapter例項
        這兩個例項分別在類級別和方法級別處理。
        而annotation-driven配置幫助我們自動完成上述兩個例項的注入。
     -->
<mvc:annotation-driven />

5.Controller(控制器)

Controller

控制器負責提供訪問應用程式的行為，通常通過介面定義或註解定義兩種方法實現。
控制器負責解析使用者的請求並將其轉換為一個模型。
在Spring MVC中一個控制器類可以包含多個方法
在Spring MVC中，對於Controller的配置方式有很多種

有哪些方式可以實現：

實現Controller介面

Controller是一個介面，在org.springframework.web.servlet.mvc包下，介面中只有一個方法；

//實現該介面的類獲得控制器功能
public interface Controller {
    //處理請求且返回一個模型與檢視物件
    ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}

測試

新建一個Moudle！
- mvc的配置檔案只留下檢視解析器！
編寫一個Controller類，ControllerTest1

//定義控制器
//注意點：不要導錯包，實現Controller介面，重寫方法；
public class ControllerTest1 implements Controller {
 
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一個模型檢視物件
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","controllertest");
        mv.setViewName("test");
        return mv;
    }
}

編寫完畢後，去Spring配置檔案中註冊請求的bean；name對應請求路徑，class對應處理請求的類

<bean name="/test1" class="com.tian.controller.ControllerTest"/>

編寫前端test.jsp，注意在WEB-INF/jsp目錄下編寫，對應我們的檢視解析器

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Kuangshen</title>
</head>
<body>
    ${msg}
</body>
</html>

配置Tomcat執行測試，OK！

說明：

實現Controller介面定義控制器是較老的辦法;
缺點是：一個控制器中只有一個方法，如果要多個方法則需要定義多個Controller；定義的方式比較麻煩;

使用註解@Controller

@Controller註解型別用於宣告Spring類的例項是一個控制器（在講IOC時還提到了另外3個註解）；

@Component	元件
@Controller	
@Service	
@Repository	daoceng

Spring可以使用掃描機制來找到應用程式中所有基於註解的控制器類，為了保證Spring能找到你的控制器，需要在配置檔案中宣告元件掃描。

<!-- 自動掃描指定的包，下面所有註解類交給IOC容器管理 -->
<context:component-scan base-package="com.kuang.controller"/>

新增一個TestController1類，使用註解實現

//標有@Controller註解的類會自動新增到Spring上下文中
//代表這個類會被Spring按管
//標註這個註解的類中的所有方法，如果返回值是String，並且有具體頁面可以跳轉，那麼就會被檢視解析器解析;
@Controller
public class TestController1 {
    //對映訪問路徑
    @RequestMapping("/test2")
    public String controllerTest(Model model){
        //Spring MVC會自動例項化一個Model物件用於向檢視中傳值
        model.addAttribute("msg","controllertest1");
        //返回檢視位置
        return "test";
    }
}

執行tomcat測試

可以發現，我們的兩個請求都可以指向一個檢視，但是頁面結果的結果是不一樣的，從這裡可以看出檢視是被複用的，而控制器與檢視之間是弱偶合關係。

註解方式是平時使用的最多的方式！除了這兩種之外還有其他的方式，大家想要自己研究的話，可以參考部落格：https://blog.csdn.net/qq_38225558/article/details/83271233

RequestMapping

@RequestMapping

@RequestMapping註解用於對映url到控制器類或一個特定的處理程式方法。可用於類或方法上。用於類上，表示類中的所有響應請求的方法都是以該地址作為父路徑。
只註解在方法上面

@Controller
public class TestController {
    @RequestMapping("/h1")
    public String test(){
        return "test";
    }
}

訪問路徑：http://localhost:8080 / 專案名 / h1

同時註解在類與方法

@Controller
@RequestMapping("/admin")
public class TestController {
    @RequestMapping("/h1")
    public String test(){
        return "test";
    }
}

訪問路徑：http://localhost:8080 / 專案名/ admin /h1 , 需要先指定類的路徑再指定方法的路徑；

6.RestFul風格(簡潔，高效，安全)

6.1 RestFul簡介

概念

Restful就是一個資源定位及資源操作的風格。不是標準也不是協議，只是一種風格。基於這個風格設計的軟體可以更簡潔，更有層次，更易於實現快取等機制。

功能

資源：網際網路所有的事物都可以被抽象為資源
資源操作：使用POST、DELETE、PUT、GET，使用不同方法對資源進行操作。
分別對應新增、刪除、修改、查詢。

傳統方式操作資源 ：通過不同的引數來實現不同的效果！方法單一，post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查詢,GET
http://127.0.0.1/item/saveItem.action 新增,POST
http://127.0.0.1/item/updateItem.action 更新,POST
http://127.0.0.1/item/deleteItem.action?id=1 刪除,GET或POST

使用RESTful操作資源 ：可以通過不同的請求方式來實現不同的效果！如下：請求地址一樣，但是功能可以不同！

6.2 RestFul風格學習測試

新建一個類RestFulController

@Controller
public class RestFulController {
}

在Spring MVC中可以使用 @PathVariable 註解，讓方法引數的值對應繫結到一個URI模板變數上.

@Controller
public class RestFulController {

    //原來的url:  http://localhost:8080/add?a=1&b=2
    //RestFul風格url:  http://localhost:8080/add/1/2

    //對映訪問路徑
    @RequestMapping("/add/{a}/{b}")
    public String RestFulTest(int a, int b, Model model){
        int result=a+b;
        //Spring MVC會自動例項化一個Model物件用於向檢視中傳值
        model.addAttribute("msg", "結果："+result);
        //返回檢視位置
        return "test";
    }
}

測試結果

使用路徑變數的好處

使路徑變得更加簡潔；
獲得引數更加方便，框架會自動進行型別轉換。
通過路徑變數的型別可以約束訪問引數，如果型別不一樣，則訪問不到對應的請求方法，如這裡訪問是的路徑是/add/10/a，則路徑與方法不匹配，而不會是引數轉換失敗。

我們來修改下對應的引數型別，再次測試

//對映訪問路徑
@RequestMapping("/add/{a}/{b}")
public String RestFulTest(@PathVariable int a, @PathVariable String b, Model model){
    String result=a+b;
    //Spring MVC會自動例項化一個Model物件用於向檢視中傳值
    model.addAttribute("msg", "結果："+result);
    //返回檢視位置
    return "test";
}

使用method屬性來指定請求型別

用於約束請求的型別，可以收窄請求範圍。指定請求謂詞的型別如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等。

測試

RestFulController類中新增一個方法

//對映訪問路徑,必須是POST請求
@RequestMapping(value = "/hello",method = RequestMethod.POST)
public String RestFulTest2(Model model){
    model.addAttribute("msg", "hello restful!");
    return "test";
}

我們使用瀏覽器位址列進行訪問預設是Get請求，會報錯405：

將post請求方式改為get就可以了

@RequestMapping(value = "/hello",method = RequestMethod.GET)
    public String RestFulTest2(Model model){
        model.addAttribute("msg", "hello restful!");
        return "test";
    }
}

小結：

Spring MVC 的 @RequestMapping 註解能夠處理 HTTP 請求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的位址列請求預設都會是 HTTP GET 型別的。

方法級別的註解變體有如下幾個：組合註解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

6.3 @GetMapping

@GetMapping是一個組合註解

//對映訪問路徑
//@RequestMapping("/add/{a}/{b}")
@GetMapping("/add/{a}/{b}")
public String RestFulTest(@PathVariable int a, @PathVariable int b, Model model){
    int result=a+b;
    //Spring MVC會自動例項化一個Model物件用於向檢視中傳值
    model.addAttribute("msg", "結果："+result);
    //返回檢視位置
    return "test";
}

它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一個快捷方式。

平時使用的會比較多！

6.4 小黃鴨除錯法

場景一：我們都有過向別人（甚至可能向完全不會程式設計的人）提問及解釋程式設計問題的經歷，但是很多時候就在我們解釋的過程中自己卻想到了問題的解決方案，然後對方卻一臉茫然。

場景二：你的同行跑來問你一個問題，但是當他自己把問題說完，或說到一半的時候就想出答案走了，留下一臉茫然的你。

其實上面兩種場景現象就是所謂的小黃鴨除錯法（Rubber Duck Debuging），又稱橡皮鴨除錯法，它是我們軟體工程中最常使用除錯方法之一。

此概念據說來自《程式設計師修煉之道》書中的一個故事，傳說程式大師隨身攜帶一隻小黃鴨，在除錯程式碼的時候會在桌上放上這隻小黃鴨，然後詳細地向鴨子解釋每行程式碼，然後很快就將問題定位修復了。

7.SpringMVC：結果跳轉方式(轉發、重定向)

7.1 ModelAndView

設定ModelAndView物件 , 根據view的名稱 , 和檢視解析器跳到指定的頁面 .

頁面 : {檢視解析器字首} + viewName +{檢視解析器字尾}

<!--配置檢視解析器-->
<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--字首-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--字尾-->
    <property name="suffix" value=".jsp"/>
</bean>

對應的controller類

public class TestController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一個模型檢視物件
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","controllertest!");
        mv.setViewName("test");
        return mv;
    }
}

7.2 ServletAPI

通過ServletAPI , 不需要檢視解析器 .

通過HttpServletResponse進行輸出
通過HttpServletResponse實現重定向
通過HttpServletRequest實現轉發

@Controller
public class ServletController {

    @RequestMapping("/t1")
    public void test1(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.getWriter().println("SpringMVC by ServletAPI!");
    }

    @RequestMapping("/t2")
    public void test2(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // 重定向
        response.sendRedirect(request.getContextPath()+"/index.jsp");
    }

    @RequestMapping("/t3")
    public void test3(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 轉發
        request.setAttribute("msg","t3");
        request.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(request,response);
    }
}

7.3 SpringMVC

通過SpringMVC來實現轉發和重定向 - 無需檢視解析器；

測試前，需要將檢視解析器註釋掉

@Controller
public class SpringMVCController {
    @RequestMapping("/mvc/t1")
    public String test1(){
        // 轉發
        return "/index.jsp";
    }

    @RequestMapping("/mvc/t2")
    public String test2(){
        // 轉發2
        return "forward:/index.jsp";
    }

    @RequestMapping("/mvc/t3")
    public String test3(){
        // 重定向
        return "redirect:/index.jsp";
    }
}

通過SpringMVC來實現轉發和重定向 - 有檢視解析器；

重定向 , 不需要檢視解析器 , 本質就是重新請求一個新地方嘛 , 所以注意路徑問題.

可以重定向到另外一個請求實現 .

@Controller
public class SpringMVCController2 {
    @RequestMapping("/mvc2/t1")
    public String test1(){
        //轉發
        return "test";
    }
 
    @RequestMapping("/mvc2/t2")
    public String test2(){
        //重定向
        return "redirect:/index.jsp";
        //return "redirect:hello.do"; //hello.do為另一個請求/
    }
}

8.資料處理

8.1 處理前端提交的資料

1、提交的引數名稱和處理方法的引數名一致

url： http://localhost:8080/hello?name=test

處理方法：

@RequestMapping("/hello")
public String hello(String name){
    System.out.println(name);
    return "hello";
}

前臺顯示：test

2.提交的引數名稱和處理方法的引數名不一致

url：http://localhost:8080/hello?username=test

處理方法：

//@RequestParam("username") : username提交的域的名稱.
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
    System.out.println(name);
    return "hello";
}

前臺顯示：test

3.提交的是一個物件

要求提交的表單域和物件的屬性名一致 , 引數使用物件即可。

實體類

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;
}

url : http://localhost:8080/user?name=test&id=1&age=15

處理方法

@RequestMapping("/user")
public String user(User user){
    System.out.println(user);
    return "hello";
}

後臺輸出 : User { id=1, name='kuangshen', age=15 }

8.2 資料顯示到前端

第一種 : 通過ModelAndView

前面一直都是如此 . 就不過多解釋。

public class ControllerTest implements Controller {

    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一個模型檢視物件
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest");
        mv.setViewName("test");
        return mv;
    }
}

第二種 : 通過ModelMap

ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
    //封裝要顯示到檢視中的資料
    //相當於req.setAttribute("name",name);
    model.addAttribute("name",name);
    System.out.println(name);
    return "hello";
}

第三種 : 通過Model

Model

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
    //封裝要顯示到檢視中的資料
    //相當於req.setAttribute("msg",name);
    model.addAttribute("msg",name);
    System.out.println(name);
    return "test";
}

對比

對於新手而言簡單來說使用區別就是：

Model 只有寥寥幾個方法只適合用於儲存資料，簡化了新手對於Model物件的操作和理解；
 
ModelMap 繼承了 LinkedMap ，除了實現了自身的一些方法，同樣的繼承了 LinkedMap 的方法和特性；
 
ModelAndView 可以在儲存資料的同時，可以進行設定返回的邏輯檢視，進行控制展示層的跳轉。

當然以後開發考慮的更多的是效能和優化，就不能單單僅限於此的瞭解。

請使用80%的時間打好紮實的基礎，剩下18%的時間研究框架，2%的時間去學點英文，框架的官方文件永遠是最好的教程。

9.亂碼問題

測試步驟：

1.編寫一個表單提交頁面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%--jsp頁面獲取專案名稱 ${pageContext.request.contextPath}--%>
<form action="${pageContext.request.contextPath}/encode" method="post">
    <input type="text" name="name"/>
    <input type="submit"/>
</form>
</body>
</html>

2.編寫對應的處理類

@Controller
public class EncodingTest {
    @RequestMapping("/encode")
    public String test(Model model, String name) {
        model.addAttribute("msg", name); //獲取表單提交的值
        return "test"; //跳轉到test頁面顯示輸入的值
    }
}

3.輸入中文測試

不得不說，亂碼問題是在我們開發中十分常見的問題，也是讓我們程式猿比較頭大的問題！

以前亂碼問題通過過濾器解決 , 而SpringMVC給我們提供了一個過濾器 , 可以在web.xml中配置 .

修改了xml檔案需要重啟伺服器！

<!--配置SpringMVC的亂碼過濾-->
<filter>
    <filter-name>encoding</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>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

有些極端情況下.這個過濾器對get的支援不好 .

處理方法 :

修改tomcat配置檔案：設定編碼！

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

自定義過濾器【】

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
 
/**
 * 解決get和post請求 全部亂碼的過濾器
 */
public class GenericEncodingFilter implements Filter {
 
    @Override
    public void destroy() {
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //處理response的字元編碼
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");
 
        // 轉型為與協議相關物件
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 對request包裝增強
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
}
 
//自定義request物件，HttpServletRequest的包裝類
class MyRequest extends HttpServletRequestWrapper {
 
    private HttpServletRequest request;
    //是否編碼的標記
    private boolean hasEncode;
    //定義一個可以傳入HttpServletRequest物件的建構函式，以便對其進行裝飾
    public MyRequest(HttpServletRequest request) {
        super(request);// super必須寫
        this.request = request;
    }
 
    // 對需要增強方法 進行覆蓋
    @Override
    public Map getParameterMap() {
        // 先獲得請求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post請求
            try {
                // 處理post亂碼
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get請求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 確保get手動編碼邏輯只執行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 處理get亂碼
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }
 
    //取一個值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回引數的第一個值
    }
 
    //取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

一般情況下，SpringMVC預設的亂碼處理就已經能夠很好的解決了！然後在web.xml中配置這個過濾器即可！

亂碼問題，需要平時多注意，在儘可能能設定編碼的地方，都設定為統一編碼 UTF-8！

10.JSON講解

10.1 什麼是JSON？

JSON(JavaScript Object Notation, JS 物件標記) 是一種輕量級的資料交換格式，目前使用特別廣泛。
採用完全獨立於程式語言的文字格式來儲存和表示資料。
簡潔和清晰的層次結構使得 JSON 成為理想的資料交換語言。
易於人閱讀和編寫，同時也易於機器解析和生成，並有效地提升網路傳輸效率。

在 JavaScript 語言中，一切都是物件。因此，任何JavaScript 支援的型別都可以通過 JSON 來表示，例如字串、數字、物件、陣列等。看看他的要求和語法格式：

物件表示為鍵值對，資料由逗號分隔
花括號儲存物件
方括號儲存陣列

JSON 鍵值對是用來儲存 JavaScript 物件的一種方式，和 JavaScript 物件的寫法也大同小異，鍵/值對組合中的鍵名寫在前面並用雙引號 "" 包裹，使用冒號 : 分隔，然後緊接著值：

{"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}

很多人搞不清楚 JSON 和 JavaScript 物件的關係，甚至連誰是誰都不清楚。其實，可以這麼理解：

JSON 是 JavaScript 物件的字串表示法，它使用文字表示一個 JS 物件的資訊，本質是一個字串。

var obj = {a: 'Hello', b: 'World'}; //這是一個物件，注意鍵名也是可以使用引號包裹的
var json = '{"a": "Hello", "b": "World"}'; //這是一個 JSON 字串，本質是一個字串

JSON 和 JavaScript 物件互轉

要實現從JSON字串轉換為JavaScript 物件，使用 JSON.parse() 方法：

var obj = JSON.parse('{"a": "Hello", "b": "World"}'); 
//結果是 {a: 'Hello', b: 'World'}

要實現從JavaScript 物件轉換為JSON字串，使用 JSON.stringify() 方法：

var json = JSON.stringify({a: 'Hello', b: 'World'});
//結果是 '{"a": "Hello", "b": "World"}'

程式碼測試

新建一個module ，新增web的支援

在web目錄下新建一個 json.html ，編寫測試內容

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>JSON</title>
    </head>
    <body>

        <script type="text/javascript">
            //編寫一個js的物件
            var user = {
                name:"test",
                age:3,
                sex:"男"
            };

            console.log(user);

            //將js物件轉換成json字串
            var str = JSON.stringify(user);
            console.log(str);

            //將json字串轉換為js物件
            var user2 = JSON.parse(str);
            console.log(user2.age,user2.name,user2.sex);

        </script>

    </body>
</html>

在IDEA中使用瀏覽器開啟，檢視控制檯輸出！

10.2 Controller返回JSON資料

jackson

Jackson應該是目前比較好的json解析工具了
當然工具不止這一個，比如還有阿里巴巴的 fastjson 等等。
我們這裡使用Jackson，使用它需要匯入它的jar包；

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.10.0</version>
</dependency>

配置SpringMVC需要的配置

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">

    <!--註冊servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通過初始化引數指定SpringMVC配置檔案的位置，進行關聯-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 啟動順序，數字越小，啟動越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--所有請求都會被springmvc攔截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--編碼過濾器-->
    <filter>
        <filter-name>encoding</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>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


</web-app>

springmvc-servlet.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">
    
    <!--自動掃描指定的包，包下所有的註解類交給spring容器管理-->
    <context:component-scan base-package="com.tian.controller"/>

    <!--檢視解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    
</beans>

編寫一個User的實體類，然後去編寫我們的測試Controller；

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

這裡我們需要兩個新東西，一個是@ResponseBody，一個是ObjectMapper物件

@Controller
public class UserController {

    @RequestMapping("/j1")
    @ResponseBody
    public String json1() throws JsonProcessingException {

        //建立一個jackson的物件對映器，用來解析資料
        ObjectMapper mapper = new ObjectMapper();
        //建立一個物件
        User user = new User("test", 20, "男");
        //將我們的物件解析成為json格式
        String str = mapper.writeValueAsString(user);

        //由於@ResponseBody註解，這裡會將str轉成json格式返回【不走檢視解析器】；十分方便

        return str;
    }
}

配置Tomcat ，啟動測試！

發現出現了亂碼問題，我們需要設定一下他的編碼格式為utf-8，以及它返回的型別；
通過@RequestMaping的produces屬性來實現，修改下程式碼

//produces:指定響應體返回型別和編碼
@RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")

【注意：使用json記得處理亂碼問題】

程式碼優化

亂碼統一解決

上一種方法比較麻煩，如果專案中有許多請求則每一個都要新增，可以通過Spring配置統一指定，這樣就不用每次都去處理了！

我們可以在springmvc的配置檔案上新增一段訊息StringHttpMessageConverter轉換配置！

 <!--JSON亂碼問題配置-->
<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

返回json字串統一解決

在類上直接使用 @RestController ，這樣子，裡面所有的方法都只會返回 json 字串了，不用再每一個都新增@ResponseBody ！我們在前後端分離開發中，一般都使用 @RestController ，十分便捷！

@RestController
public class UserController {
    @RequestMapping("/j1")
    public String json1() throws JsonProcessingException {

        //建立一個jackson的物件對映器，用來解析資料
        ObjectMapper mapper = new ObjectMapper();
        //建立一個物件
        User user = new User("test1號", 20, "男");
        //將我們的物件解析成為json格式
        String str = mapper.writeValueAsString(user);

        //由於@ResponseBody註解，這裡會將str轉成json格式返回【不走檢視解析器】；十分方便

        return str;
    }
}

測試集合輸出

@RequestMapping("/j2")
@ResponseBody
public String json2() throws JsonProcessingException {
 
    //建立一個jackson的物件對映器，用來解析資料
    ObjectMapper mapper = new ObjectMapper();
    //建立一個物件
    User user1 = new User("test1號", 3, "男");
    User user2 = new User("test2號", 3, "男");
    User user3 = new User("test3號", 3, "男");
    User user4 = new User("test4號", 3, "男");
    List<User> list = new ArrayList<User>();
    list.add(user1);
    list.add(user2);
    list.add(user3);
    list.add(user4);
 
    //將我們的物件解析成為json格式
    String str = mapper.writeValueAsString(list);
    return str;
}

輸出時間物件

@RequestMapping("/j3")
@ResponseBody
public String json3() throws JsonProcessingException {
 
    ObjectMapper mapper = new ObjectMapper();
 
    //建立時間一個物件，java.util.Date
    Date date = new Date();
    //將我們的物件解析成為json格式
    String str = mapper.writeValueAsString(date);
    return str;
}

執行結果 :

預設日期格式會變成一個數字，是1970年1月1日到當前日期的毫秒數！
Jackson 預設是會把時間轉成timestamps形式

解決方案：取消timestamps形式，自定義時間格式

@RequestMapping("/j4")
@ResponseBody
public String json4() throws JsonProcessingException {
 
    ObjectMapper mapper = new ObjectMapper();
 
    //不使用時間戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    //自定義日期格式物件
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //指定日期格式
    mapper.setDateFormat(sdf);
 
    Date date = new Date();
    String str = mapper.writeValueAsString(date);
 
    return str;
}

執行結果 : 成功的輸出了時間！

時間戳格式化，老手藝不能丟

@RequestMapping("/j5")
@ResponseBody
public String json5() throws JsonProcessingException {

    ObjectMapper mapper = new ObjectMapper();
    Date date = new Date();
    //自定義日期的格式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    // objectMapper,時間解析後的預設格式為: Timestamp, 時間裁
    return mapper.writeValueAsString(sdf.format(date));
}

抽取工具類

如果要經常使用的話，這樣是比較麻煩的，我們可以將這些程式碼封裝到一個工具類中

package com.tian.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {

    public static String getJson(Object object){
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object, String dateFormat) {
        ObjectMapper mapper = new ObjectMapper();
        //不使用時間戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定義日期格式物件
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        //確定日期格式
        mapper.setDateFormat(sdf);

        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

使用工具類，程式碼就更加簡潔了！

@RequestMapping("/j5")
public String json5() throws JsonProcessingException {
    Date date = new Date();
    String json = JsonUtils.getJson(date);
    return json;
}

FastJson

fastjson.jar是阿里開發的一款專門用於Java開發的包，可以方便的實現json物件與JavaBean物件的轉換，實現JavaBean物件與json字串的轉換，實現json物件與json字串的轉換。實現json的轉換方法很多，最後的實現結果都是一樣的。

fastjson 的 pom依賴！

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.60</version>
</dependency>

fastjson 三個主要的類：

【JSONObject 代表 json 物件】
- JSONObject實現了Map介面, 猜想 JSONObject底層操作是由Map實現的。
- JSONObject對應json物件，通過各種形式的get()方法可以獲取json物件中的資料，也可利用諸如size()，isEmpty()等方法獲取"鍵：值"對的個數和判斷是否為空。其本質是通過實現Map介面並呼叫介面中的方法完成的。
【JSONArray 代表 json 物件陣列】
- 內部是有List介面中的方法來完成操作的。
【JSON 代表 JSONObject和JSONArray的轉化】
- JSON類原始碼分析與使用
- 仔細觀察這些方法，主要是實現json物件，json物件陣列，javabean物件，json字串之間的相互轉化。

程式碼測試，我們新建一個FastJsonTest類

package com.tian.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.tian.pojo.User;

import java.util.ArrayList;
import java.util.List;

public class FastJsonTest {
    public static void main(String[] args) {
        //建立一個物件
        User user1 = new User("秦疆1號", 3, "男");
        User user2 = new User("秦疆2號", 3, "男");
        User user3 = new User("秦疆3號", 3, "男");
        User user4 = new User("秦疆4號", 3, "男");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);

        System.out.println("*******Java物件 轉 JSON字串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>"+str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>"+str2);

        System.out.println("\n****** JSON字串 轉 Java物件*******");
        User jp_user1=JSON.parseObject(str2,User.class);
        System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

        System.out.println("\n****** Java物件 轉 JSON物件 ******");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

        System.out.println("\n****** JSON物件 轉 Java物件 ******");
        User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
    }
}

fastjson測試

/*fastjson*/
@RequestMapping("/j6")
@ResponseBody
public String json6(){
    //建立一個物件
    User user1 = new User("test1號", 3, "男");
    User user2 = new User("test2號", 3, "男");
    User user3 = new User("test3號", 3, "男");
    User user4 = new User("test4號", 3, "男");
    List<User> list = new ArrayList<User>();
    list.add(user1);
    list.add(user2);
    list.add(user3);
    list.add(user4);

    //將java物件解析為json字串
    String str = JSON.toJSONString(list);
    return str;
}

這種工具類，我們只需要掌握使用就好了，在使用的時候在根據具體的業務去找對應的實現。

11.攔截器

11.1 interceptor簡介

SpringMVC的處理器攔截器類似於Servlet開發中的過濾器Filter,用於對處理器進行預處理和後處理。開發者可以自己定義一些攔截器來實現特定的功能。

過濾器與攔截器的區別：攔截器是AOP思想的具體應用。

過濾器

servlet規範中的一部分，任何java web工程都可以使用
在url-pattern中配置了/*之後，可以對所有要訪問的資源進行攔截

攔截器

攔截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
攔截器只會攔截訪問的控制器方法，如果訪問的是jsp/html/css/image/js是不會進行攔截的

11.2 自定義攔截器

想要自己定義攔截器，必須實現 HandlerInterceptor 介面。

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("======攔截前======");
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("======攔截後======");
    }

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

在SpringMVC核心配置檔案中配置攔截器

<!--攔截器配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--/** 包括路徑及其子路徑-->
        <!--/admin/* 攔截的是/admin/add等等這種 , /admin/add/user不會被攔截-->
        <!--/admin/** 攔截的是/admin/下的所有-->
        <mvc:mapping path="/**"/>
        <!--bean配置的就是攔截器-->
        <bean class="com.tian.interceptor.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

編寫controller測試

@Controller
public class InterceptorController {
    @RequestMapping("/i1")
    @ResponseBody
    public String test(){
        System.out.println("攔截器方法執行了！");
        return "hello";
    }
}

測試結果

11.3 攔截器驗證使用者是否登入

實現思路

有一個登陸頁面，需要寫一個controller訪問頁面。
登陸頁面有一提交表單的動作。需要在controller中處理。判斷使用者名稱密碼是否正確。如果正確，向session中寫入使用者資訊。返回登陸成功。
攔截使用者請求，判斷使用者是否登陸。如果使用者已經登陸。放行，如果使用者未登陸，跳轉到登陸頁面

程式碼實現

1.index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>$Title$</title>
</head>
<h3><a style="text-decoration: none" href="${pageContext.request.contextPath}/user/goMain">進入首頁</a></h3>
<h3><a style="text-decoration: none" href="${pageContext.request.contextPath}/user/goLogin">進入登陸頁面</a></h3>
</body>
</html>

2.login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/user/login" method="post">
        使用者名稱：<input type="text" name="username"/><br/>
        密碼：<input type="password" name="password"/><br/>
        <input type="submit" value="提交"/>
    </form>
</body>
</html>

3.main.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <h1>首頁</h1>
        ${username}
        <h3><a style="text-decoration: none" href="${pageContext.request.contextPath}/user/logout">登出</a></h3>
    </body>
</html>

4.LoginController

@Controller
@RequestMapping("/user")
public class LoginController {
    @RequestMapping("/goLogin")
    public String goLogin(){
        return "login";
    }

    @RequestMapping("/goMain")
    public String goMain(){
        return "main";
    }

    @RequestMapping("/login")
    public String login(HttpSession session,String username, String password){
        System.out.println("username==>"+username);
        System.out.println("password==>"+password);
        session.setAttribute("username",username);
        return "main";
    }

    @RequestMapping("/logout")
    public String logout(HttpSession session){
        session.removeAttribute("username");
        return "login";
    }
}

5.LoginInterceptor

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 如果是登陸頁面則放行
        if (request.getRequestURI().contains("login")){
            return true;
        }
        //如果session中已經有了使用者資訊也放行
        if (request.getSession().getAttribute("username")!= null){
            return true;
        }

        //如果不是上面兩種情況就轉發到登入頁面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request,response);
        return false;
    }
}

6.攔截器配置

<mvc:interceptor>
    <mvc:mapping path="/user/**"/>
    <bean class="com.tian.interceptor.LoginInterceptor"/>
</mvc:interceptor>

OK，測試登入攔截功能無誤！

12.檔案上傳和下載

準備工作

檔案上傳是專案開發中最常見的功能之一 ,springMVC 可以很好的支援檔案上傳，但是SpringMVC上下文中預設沒有裝配MultipartResolver，因此預設情況下其不能處理檔案上傳工作。如果想使用Spring的檔案上傳功能，則需要在上下文中配置MultipartResolver。

前端表單要求：為了能上傳檔案，必須將表單的method設定為POST，並將enctype設定為multipart/form-data。只有在這樣的情況下，瀏覽器才會把使用者選擇的檔案以二進位制資料傳送給伺服器；

對錶單中的 enctype 屬性做個詳細的說明：

application/x-www=form-urlencoded：預設方式，只處理表單域中的 value 屬性值，採用這種編碼方式的表單會將表單域中的值處理成 URL 編碼方式。
multipart/form-data：這種編碼方式會以二進位制流的方式來處理表單資料，這種編碼方式會把檔案域指定檔案的內容也封裝到請求引數中，不會對字元編碼。
text/plain：除了把空格轉換為 "+" 號外，其他字元都不做編碼處理，這種方式適用直接通過表單傳送郵件。

<form action="" enctype="multipart/form-data" method="post">
   <input type="file" name="file"/>
   <input type="submit">
</form>

一旦設定了enctype為multipart/form-data，瀏覽器即會採用二進位制流的方式來處理表單資料，而對於檔案上傳的處理則涉及在伺服器端解析原始的HTTP響應。在2003年，Apache Software Foundation釋出了開源的Commons FileUpload元件，其很快成為Servlet/JSP程式設計師上傳檔案的最佳選擇。

Servlet3.0規範已經提供方法來處理檔案上傳，但這種上傳需要在Servlet中完成。
而Spring MVC則提供了更簡單的封裝。
Spring MVC為檔案上傳提供了直接的支援，這種支援是用即插即用的MultipartResolver實現的。
Spring MVC使用Apache Commons FileUpload技術實現了一個MultipartResolver實現類：CommonsMultipartResolver。因此，SpringMVC的檔案上傳還需要依賴Apache Commons FileUpload的元件。

12.1 檔案上傳

1.匯入檔案上傳的jar包，commons-fileupload ， Maven會自動幫我們匯入他的依賴包 commons-io包；

<!--檔案上傳-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>
<!--servlet-api匯入高版本的-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>

2.配置bean：multipartResolver

【注意！！！這個bena的id必須為：multipartResolver ，否則上傳檔案會報400的錯誤！】

<!--檔案上傳配置-->
<bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 請求的編碼格式，必須和jSP的pageEncoding屬性一致，以便正確讀取表單的內容，預設為ISO-8859-1 -->
    <property name="defaultEncoding" value="utf-8"/>
    <!-- 上傳檔案大小上限，單位為位元組（10485760=10M） -->
    <property name="maxUploadSize" value="10485760"/>
    <property name="maxInMemorySize" value="40960"/>
</bean>

CommonsMultipartFile 的常用方法：

String getOriginalFilename()：獲取上傳檔案的原名
InputStream getInputStream()：獲取檔案流
void transferTo(File dest)：將上傳檔案儲存到一個目錄檔案中

3.測試

前端頁面：

<form action="${pageContext.request.contextPath}/upload" enctype="multipart/form-data" method="post">
    <input type="file" name="file"/>
    <input type="submit" value="upload">
</form>

controller：第二種其實是對第一種方式的封裝

@Controller
public class FileController {
    //@RequestParam("file") 將name=file控制元件得到的檔案封裝成CommonsMultipartFile物件
    //批量上傳CommonsMultipartFile則為陣列即可
    @RequestMapping("/upload")
    public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {

        //獲取檔名 : file.getOriginalFilename();
        String uploadFileName = file.getOriginalFilename();

        //如果檔名為空，直接回到首頁！
        if ("".equals(uploadFileName)){
            return "redirect:/index.jsp";
        }
        System.out.println("上傳檔名 : "+uploadFileName);

        //上傳路徑儲存設定
        String path = request.getServletContext().getRealPath("/upload");
        //如果路徑不存在，建立一個
        File realPath = new File(path);
        if (!realPath.exists()){
            realPath.mkdir();
        }
        System.out.println("上傳檔案儲存地址："+realPath);

        InputStream is = file.getInputStream(); //檔案輸入流
        OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //檔案輸出流

        //讀取寫出
        int len=0;
        byte[] buffer = new byte[1024];
        while ((len=is.read(buffer))!=-1){
            os.write(buffer,0,len);
            os.flush();
        }
        os.close();
        is.close();
        return "redirect:/index.jsp";
    }

    /*
     * 採用file.Transto 來儲存上傳的檔案,檔名和型別如果相同則會覆蓋原來的檔案
     */
    @RequestMapping("/upload2")
    public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {

        //上傳路徑儲存設定
        String path = request.getServletContext().getRealPath("/upload");
        File realPath = new File(path);
        if (!realPath.exists()){
            realPath.mkdir();
        }
        //上傳檔案地址
        System.out.println("上傳檔案儲存地址："+realPath);

        //通過CommonsMultipartFile的方法直接寫檔案（注意這個時候）
        file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));

        return "redirect:/index.jsp";
    }
}

測試檔案上傳，OK！

12.2 檔案下載

檔案下載步驟：

設定 response 響應頭
讀取檔案 -- InputStream
寫出檔案 -- OutputStream
執行操作
關閉流（先開後關）