當前位置：首頁 > 编程语言 > java >内容正文

java

Java学习笔记13-1——SpringMVC

發布時間：2023/12/10 java 32 豆豆

生活随笔收集整理的這篇文章主要介紹了 Java学习笔记13-1——SpringMVC 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

文章目錄

1.什么是MVC
- 回顧Servlet
2.什么是SpringMVC
- 概述
- 中心控制器
- SpringMVC執行原理
3.第一個SpringMVC 程序
- 使用XML配置實現
- 使用注解實現
4.控制器和RestFul風格
- 控制器Controller
- - 實現Controller接口
  - 使用注解@Controller
  - RequestMapping
- RestFul 風格
- 擴展：小黃鴨調試法
5.結果跳轉方式
- ModelAndView
- ServletAPI
- SpringMVC
6.數據處理
- 處理提交數據
- - 參數名一致
  - 參數名不一致
  - 提交的是一個對象
- 數據顯示到前端
- - 第一種 : 通過ModelAndView
  - 第二種 : 通過ModelMap
  - 第三種 : 通過Model
  - 對比
7.亂碼問題
8.JSON交互處理
- 什么是JSON？
- JSON解析工具Jackson的使用
- JSON亂碼問題
- 輸出JSON集合
- 輸出時間對象
- - 抽取為工具類
- JSON解析工具FastJson的使用
9.AJAX
- 簡介
- 偽造Ajax
- jQuery.ajax
10.攔截器
11.文件上傳和下載

1.什么是MVC

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

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

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

Controller（控制器）：接收用戶請求，委托給模型進行處理（狀態改變），處理完畢后把返回的模型數據返回給視圖，由視圖負責展示。也就是說控制器做了個調度員的工作。

最典型的MVC就是JSP + Servlet + Java Bean的模式

職責分析：

Controller：控制器

取得表單數據
調用業務邏輯
轉向指定的頁面

Model：模型

業務邏輯
保存數據的狀態

View：視圖

顯示頁面

回顧Servlet

1、新建一個Maven工程當做父工程，導入依賴

<dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.1.9.RELEASE</version></dependency><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><dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId><version>1.2</version></dependency> </dependencies>

2、編寫一個Servlet類，用來處理用戶的請求

//實現Servlet接口 public class HelloServlet extends HttpServlet {@Overrideprotected 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/hello.jsp").forward(req,resp);}@Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {doGet(req,resp);} }

3、編寫Hello.jsp，在WEB-INF目錄下新建一個jsp的文件夾，新建hello.jsp

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

4、在web.xml中注冊Servlet

5、配置Tomcat，并啟動測試
localhost:8080/user?method=add
localhost:8080/user?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

概述

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無縫集成(使用SpringIoC和AOP)，使用約定優于配置。能夠進行簡單的junit測試。支持Restful風格。異常處理，本地化，國際化，數據驗證，類型轉換，攔截器等等，所以我們要學習。

最重要的一點還是用的人多，使用的公司多。

中心控制器

Spring的web框架圍繞DispatcherServlet設計。DispatcherServlet的作用是將請求分發到不同的處理器。

DispatcherServlet一級一級繼承，最終繼承的是Servlet，所以DispatcherServlet本質也是在處理一些響應和請求。如下圖所示，這樣多加一層的架構好處是不用針對單個Servlet一個個去配置，現在可以統一配置并順帶管理。

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

SpringMVC的原理如下圖所示：

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

SpringMVC執行原理

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

簡要分析執行流程

1、DispatcherServlet表示前置控制器，是整個SpringMVC的控制中心。用戶發出請求，

DispatcherServlet接收請求并攔截請求。
我們假設請求的url為 : http://localhost:8080/SpringMVC/hello
如上url拆分成三部分：
http://localhost:8080 ------> 服務器域名
SpringMVC ------> 部署在服務器上的web站點
hello ------> 表示控制器
通過分析，如上url表示為：請求位于服務器localhost:8080上的SpringMVC站點的hello控制器。

2、HandlerMapping為處理器映射。DispatcherServlet調用HandlerMapping,HandlerMapping根據請求url查找Handler。
3、HandlerExecution表示具體的Handler,其主要作用是根據url查找控制器，如上url被查找控制器為：hello。
4、HandlerExecution將解析后的信息傳遞給DispatcherServlet,如解析控制器映射等。
5、HandlerAdapter表示處理器適配器，其按照特定的規則去執行Handler。
6、Handler讓具體的Controller執行。
7、Controller將具體的執行信息返回給HandlerAdapter,如ModelAndView。
8、HandlerAdapter將視圖邏輯名或模型傳遞給DispatcherServlet。
9、DispatcherServlet調用視圖解析器(ViewResolver)來解析HandlerAdapter傳遞的邏輯視圖名。
10、視圖解析器將解析的邏輯視圖名傳給DispatcherServlet。
11、DispatcherServlet根據視圖解析器解析的視圖結果，調用具體的視圖。
12、最終視圖呈現給用戶。

3.第一個SpringMVC 程序

使用XML配置實現

1、新建一個子Moudle，springmvc-02-hello，添加web的支持

2、確定導入了SpringMVC 的依賴

3、配置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"><servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><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><servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>/</url-pattern></servlet-mapping></web-app>

4、編寫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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/><bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/jsp/"/><property name="suffix" value=".jsp"/></bean><bean id="/hello" class="com.cheng.controller.HelloController"/></beans>

5、編寫我們要操作業務Controller，要么實現Controller接口，要么增加注解；需要返回一個ModelAndView，裝數據，封視圖

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中。Modelmv.addObject("msg","HelloSpringMVC!");//封裝要跳轉的視圖，放在ModelAndView中mv.setViewName("hello"); // 最終會被拼接成/WEB-INF/jsp/hello.jspreturn mv;} }

6、將自己的類交給SpringIOC容器，注冊bean

<bean id="/hello" class="com.cheng.controller.HelloController"/>

7、寫要跳轉的jsp頁面，顯示ModelandView存放的數據，以及我們的正常頁面

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

8、配置Tomcat，啟動測試

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

查看控制臺輸出，看一下是不是缺少了什么jar包。
如果jar包存在，顯示無法輸出，就在IDEA的項目發布中，添加lib依賴！
重啟Tomcat 即可解決

我們來看個注解版實現，這才是SpringMVC的精髓。

使用注解實現

1、新建一個Moudle，springmvc-03-annotation 。添加web支持

2、由于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>

3、在pom.xml文件引入相關的依賴：主要有Spring框架核心庫、Spring MVC、servlet , JSTL等。我們在父依賴中已經引入了！

4、配置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-name>SpringMVC</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><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><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錯。

注意web.xml版本問題，要最新版!4.0
注冊DispatcherServlet
關聯SpringMVC的配置文件
啟動級別為1
映射路徑為 / 【不要用/*，會404】

5、添加SpringMVC配置文件

在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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/mvchttps://www.springframework.org/schema/mvc/spring-mvc.xsd"><context:component-scan base-package="com.cheng.controller"/><mvc:default-servlet-handler /><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/目錄下，這樣可以保證視圖安全，因為這個目錄下的文件，客戶端不能直接訪問。

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

6、創建Controller

編寫一個Java控制類

import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.RequestMapping;@Controller @RequestMapping("/h1") public class HelloController {//類上注冊了@RequestMapping方法就自動下移，實際地址：項目名/h1/hello@RequestMapping("/hello")public String sayHello(Model model){//向模型中添加屬性msg與值，可以在JSP頁面中取出并渲染model.addAttribute("msg","hello,SpringMVCAnnotation!");//web-inf/jsp/hello.jspreturn "hello";} }

@Controller是為了讓Spring IOC容器初始化時自動掃描到；
@RequestMapping是為了映射請求路徑，這里因為類與方法上都有映射所以訪問時應該是/h1/hello（一般規約是直接在方法上寫@RequestMapping("/h1/hello")，不建議在類上寫）；
方法中聲明Model類型的參數是為了把Action中的數據帶到視圖中；
方法返回的結果是視圖的名稱hello，加上配置文件中的前后綴變成WEB-INF/jsp/hello.jsp

7、創建視圖層

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

在WEB-INF/ jsp目錄中創建hello.jsp ，視圖可以直接取出并展示從Controller帶回的信息；

可以通過EL表示取出Model中存放的值，或者對象；

8、配置Tomcat運行

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

處理器映射器、處理器適配器、視圖解析器

通常，我們只需要手動配置視圖解析器，而處理器映射器和處理器適配器只需要開啟注解驅動即可，而省去了大段的xml配置

再來回顧下原理吧~

4.控制器和RestFul風格

控制器Controller

控制器復雜提供訪問應用程序的行為，通常通過接口定義或注解定義兩種方法實現。
控制器負責解析用戶的請求并將其轉換為一個模型。
在Spring MVC中一個控制器類可以包含多個方法
在Spring MVC中，對于Controller的配置方式有很多種

實現Controller接口

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

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

測試：

1、新建一個Moudle，springmvc-04-controller。將剛才的03 拷貝一份, 我們進行操作！

2、刪掉HelloController。mvc的配置文件只留下視圖解析器！
3、編寫一個Controller類，ControllerTest

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 ControllerTest implements Controller {public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {//返回一個模型視圖對象ModelAndView mv = new ModelAndView();mv.addObject("msg","Test1Controller");mv.setViewName("hello");return mv;} }

4、編寫完畢后，去Spring配置文件中注冊請求的bean；name對應請求路徑，class對應處理請求的類

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

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

6、配置Tomcat運行測試

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

使用注解@Controller

@Controller注解類型用于聲明Spring類的實例是一個控制器（在講IOC時還提到了另外3個注解）；

Spring可以使用掃描機制來找到應用程序中所有基于注解的控制器類，為了保證Spring能找到你的控制器，需要在配置文件中聲明組件掃描。

<context:component-scan base-package="com.cheng.controller"/>

增加一個ControllerTest2類，使用注解實現；

import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.RequestMapping;//@Controller注解的類會自動添加到Spring上下文中 @Controller public class ControllerTest2{//映射訪問路徑@RequestMapping("/t2")public String index(Model model){//Spring MVC會自動實例化一個Model對象用于向視圖中傳值model.addAttribute("msg", "ControllerTest2");//返回視圖位置return "hello";} }

運行tomcat測試

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

注解方式是平時使用的最多的方式！

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 , 需要先指定類的路徑再指定方法的路徑；

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操作資源 ：可以通過不同的請求方式來實現不同的效果！如下：請求地址一樣，但是功能可以不同！

? http://127.0.0.1/item/1 查詢,GET

? http://127.0.0.1/item 新增,POST

? http://127.0.0.1/item 更新,PUT

? http://127.0.0.1/item/1 刪除,DELETE

學習測試

1、在新建一個類 RestFulController

@Controller public class RestFulController { }

2、在Spring MVC中可以使用 @PathVariable 注解，讓方法參數的值對應綁定到一個URI模板變量上。

@Controller public class RestFulController {//映射訪問路徑@RequestMapping("/commit/{p1}/{p2}")public String index(@PathVariable int p1, @PathVariable int p2, Model model){int result = p1+p2;//Spring MVC會自動實例化一個Model對象用于向視圖中傳值model.addAttribute("msg", "結果："+result);//返回視圖位置return "hello"; } }

3、測試

4、思考：使用路徑變量的好處？

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

5、我們來修改下對應的參數類型，再次測試

//映射訪問路徑 @RequestMapping("/commit/{p1}/{p2}") public String index(@PathVariable int p1, @PathVariable String p2, Model model){String result = p1+p2;//Spring MVC會自動實例化一個Model對象用于向視圖中傳值model.addAttribute("msg", "結果："+result);//返回視圖位置return "hello"; }

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

所有的地址欄請求默認都會是 HTTP GET 類型的。

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

@GetMapping @PostMapping @PutMapping @DeleteMapping @PatchMapping

@GetMapping 是一個組合注解，平時使用的會比較多！

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

擴展：小黃鴨調試法

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

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

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

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

5.結果跳轉方式

ModelAndView

設置ModelAndView對象 , 根據view的名稱 , 和視圖解析器跳到指定的頁面 .

頁面 : {視圖解析器前綴} + viewName +{視圖解析器后綴}

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"id="internalResourceViewResolver"><property name="prefix" value="/WEB-INF/jsp/" /><property name="suffix" value=".jsp" /> </bean> public class ControllerTest implements Controller {public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {//返回一個模型視圖對象ModelAndView mv = new ModelAndView();mv.addObject("msg","Test1Controller");mv.setViewName("hello");return mv;} }

ServletAPI

通過設置ServletAPI , 不需要視圖解析器（去把視圖解析器注釋掉）

1、通過HttpServletResponse進行輸出

2、通過HttpServletResponse實現重定向

3、通過HttpServletRequest實現請求轉發

@Controller public class ResultGo {@RequestMapping("/r/t1")public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {rsp.getWriter().println("Hello,Spring by servlet API");}@RequestMapping("/r/t2")public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {rsp.sendRedirect("/index.jsp"); // 重定向}@RequestMapping("/r/t3")public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {//轉發req.setAttribute("msg","/r/t3");req.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(req,rsp); // 請求轉發} }

SpringMVC

1、無視圖解析器情況下通過SpringMVC來實現轉發和重定向。

測試前，需要將視圖解析器注釋掉

默認為請求轉發forward（也可以加上）
重定向redirect需特別加

@Controller public class ResultSpringmvc {@RequestMapping("/rs/t1")public String test1(){//轉發一此時在index.jsp，但URI為http://localhost:8080/rs/t1return "/index.jsp";}@RequestMapping("/rs/t2")public String test2(){//轉發二此時在index.jsp，但URI為http://localhost:8080/rs/t2return "forward:/index.jsp";}@RequestMapping("/rs/t3")public String test3(){//重定向此時URI為http://localhost:8080/index.jspreturn "redirect:/index.jsp";} }

2、有視圖解析器情況下通過SpringMVC來實現轉發和重定向。

首先配置好視圖解析器

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

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

默認為forward轉發（不可以加上）
因為有視圖解析器的存在，如果加上（即forward:/hello.jsp）會被解析成為/WEB-INF/jsp/forward:/hello.jsp.jsp
redirect轉發需特別加

@Controller public class ResultSpringmvc2 {@RequestMapping("/rs2/t1")public String test1(){//轉發return "hello";}@RequestMapping("/rs2/t2")public String test2(){//重定向return "redirect:/index.jsp";/*return "redirect:t1";// t1為另一個請求。或者可以寫成return "redirect:t1.do";*/} }

6.數據處理

處理提交數據

參數名一致

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

提交數據 : http://localhost:8080/hello?name=cheng

后臺輸出 : cheng

參數名不一致

提交的域名稱和處理方法的

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

提交數據 : http://localhost:8080/hello?username=cheng
后臺輸出 : cheng

提交的是一個對象

要求提交的表單域和對象的屬性名一致 , 參數使用對象即可

public class User {private int id;private String name;private int age;//構造//get/set//toString() } @RequestMapping("/u") public String user(User user){System.out.println(user);return "hello"; }

提交數據 : http://localhost:8080/u/user?name=zxc&id=1&age=5
后臺輸出 : User { id=1, name=‘zxc’, age=15 }

說明：如果使用對象的話，前端傳遞的參數名和對象名必須一致，否則就是null。

數據顯示到前端

第一種 : 通過ModelAndView

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

第二種 : 通過ModelMap

ModelMap

@Controller public class DataDisplay {@RequestMapping("/dis")public String hello(@RequestParam("username") String name, ModelMap model){//封裝要顯示到視圖中的數據//相當于req.setAttribute("name",name);model.addAttribute("msg",name);System.out.println(name);return "hello";} }

http://localhost:8080/dis?username=qwe

第三種 : 通過Model

Model

@RequestMapping("/dis2")public String hello(@RequestParam("username") String name, Model model){//封裝要顯示到視圖中的數據//相當于req.setAttribute("name",name);model.addAttribute("msg",name);System.out.println(name);return "hello";}

http://localhost:8080/dis2?username=qwe

對比

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

Model 只有寥寥幾個方法只適合用于儲存數據，簡化了新手對于Model對象的操作和理解；ModelMap 繼承了 LinkedMap ，除了實現了自身的一些方法，同樣的繼承 LinkedMap 的方法和特性；ModelAndView 可以在儲存數據的同時，可以進行設置返回的邏輯視圖，進行控制展示層的跳轉。當然更多的以后開發考慮的更多的是性能和優化，就不能單單僅限于此的了解。

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

7.亂碼問題

測試步驟：

1、我們可以在首頁編寫一個提交的表單

2、后臺編寫對應的處理類

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

3、輸入中文測試，發現亂碼

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

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

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

修改了xml文件需要重啟服務器。

注意/是過濾所有請求，/*包括jsp頁面也會過濾，因為亂碼是顯示問題，所以jsp也要加入到過濾當中。

但是我們發現，有些極端情況下，這個過濾器對get方法并不能解決亂碼問題。

處理方法 :

1、修改tomcat配置文件：設置編碼！

2、使用通用編碼過濾器類，見我另一篇文章

3、查看是不是客戶端顯示編碼有問題。（如瀏覽器中右鍵-編碼-選擇Unicode(UTF-8)）

8.JSON交互處理

什么是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"}'

代碼測試

1、新建一個module ，springmvc-05-json ，添加web的支持

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

<!DOCTYPE html> <html lang="en"> <head><meta charset="UTF-8"><title>JSON_test</title> </head> <body><script type="text/javascript">//編寫一個js的對象var user = {name:"張三",age:3,sex:"男"};//將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>

3、在IDEA中使用瀏覽器打開，查看控制臺輸出！

JSON解析工具Jackson的使用

Jackson應該是目前比較好的json解析工具了
當然工具不止這一個，比如還有阿里巴巴的 fastjson 等等。

1、導入它的jar包。

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

2、將上一項目的web.xml的內容和springmvc-servlet.xml文件拷過來。springmvc-servlet.xml內容稍作修改

3、編寫一個User的實體類

4、編寫我們的測試Controller。這里我們需要兩個新東西，一個是 @ResponseBody，一個是ObjectMapper對象，我們看下具體的用法

@Controller public class UserController {@RequestMapping("/json")@ResponseBodypublic String json1() throws JsonProcessingException {//創建一個jackson的對象映射器，用來解析數據ObjectMapper mapper = new ObjectMapper();//創建一個對象User user = new User("長江123", 3, "男");//將我們的對象解析成為json格式String str = mapper.writeValueAsString(user);//由于@ResponseBody注解，這里會將str轉成json格式返回；十分方便return str;} }

配置Tomcat ，啟動測試，發現出現亂碼

我們需要設置一下他的編碼格式為utf-8，以及它返回的類型。

通過@RequestMaping的produces屬性來實現，修改下代碼

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

亂碼問題解決

JSON亂碼問題

亂碼統一解決

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

我們可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter轉換配置！

<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(value = "/json")public String json1() throws JsonProcessingException {//創建一個jackson的對象映射器，用來解析數據ObjectMapper mapper = new ObjectMapper();//創建一個對象User user = new User("長江123", 3, "男");//將我們的對象解析成為json格式String str = mapper.writeValueAsString(user);//由于@ResponseBody注解，這里會將str轉成json格式返回；十分方便return str;} }

輸出JSON集合

增加一個新的方法

@RequestMapping("/json2") public String json2() throws JsonProcessingException {//創建一個jackson的對象映射器，用來解析數據ObjectMapper mapper = new ObjectMapper();//創建一個對象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);//將我們的對象解析成為json格式String str = mapper.writeValueAsString(list);return str; }

輸出時間對象

增加一個新的方法

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

默認日期格式會變成一個數字，是1970年1月1日到當前日期的毫秒數

Jackson 默認是會把時間轉成timestamps形式

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

@RequestMapping("/json4") 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; }

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

抽取為工具類

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

package com.cheng.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("/json4") public String json4() throws JsonProcessingException {Date date = new Date();String json = JsonUtils.getJson(date);return json; }

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 對象

JSON Object實現了Map接口, 猜想 JSONObject底層操作是由Map實現的。
JSONObject對應json對象，通過各種形式的get()方法可以獲取json對象中的數據，也可利用諸如size()，isEmpty()等方法獲取"鍵：值"對的個數和判斷是否為空。其本質是通過實現Map接口并調用接口中的方法完成的。

JSONArray 代表 json 對象數組

內部是有List接口中的方法來完成操作的。

JSON代表 JSONObject和JSONArray的轉化

JSON類源碼分析與使用
仔細觀察這些方法，主要是實現json對象，json對象數組，javabean對象，json字符串之間的相互轉化。

代碼測試，我們新建一個FastJsonDemo 類

package com.cheng.controller;import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import com.cheng.pojo.User;import java.util.ArrayList; import java.util.List;public class FastJsonDemo {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);} }

輸出：

*******Java對象轉 JSON字符串******* JSON.toJSONString(list)==>[{"age":3,"name":"1號","sex":"男"},{"age":3,"name":"2號","sex":"男"},{"age":3,"name":"3號","sex":"男"},{"age":3,"name":"4號","sex":"男"}] JSON.toJSONString(user1)==>{"age":3,"name":"1號","sex":"男"}****** JSON字符串轉 Java對象******* JSON.parseObject(str2,User.class)==>User{name='1號', age=3, sex='男'}****** Java對象轉 JSON對象 ****** (JSONObject) JSON.toJSON(user2)==>2號****** JSON對象轉 Java對象 ****** JSON.toJavaObject(jsonObject1, User.class)==>User{name='2號', age=3, sex='男'}Process finished with exit code 0

這種工具類，我們只需要掌握使用就好了，在使用的時候在根據具體的業務去找對應的實現。和以前的commons-io那種工具包一樣，拿來用就好了。

Json在我們數據傳輸中十分重要，一定要學會使用！

9.AJAX

簡介

AJAX = Asynchronous JavaScript and XML（異步的 JavaScript 和 XML）。
AJAX 是一種在無需重新加載整個網頁的情況下，能夠更新部分網頁的技術。
Ajax 不是一種新的編程語言，而是一種用于創建更好更快以及交互性更強的Web應用程序的技術。
在 2005 年，Google 通過其 Google Suggest 使 AJAX 變得流行起來。Google
Suggest能夠自動幫你完成搜索單詞。
Google Suggest 使用 AJAX 創造出動態性極強的 web 界面：當您在谷歌的搜索框輸入關鍵字時，JavaScript會把這些字符發送到服務器，然后服務器會返回一個搜索建議的列表。就和國內百度的搜索框一樣!
傳統的網頁(即不用ajax技術的網頁)，想要更新內容或者提交一個表單，都需要重新加載整個網頁。
使用ajax技術的網頁，通過在后臺服務器進行少量的數據交換，就可以實現異步局部更新。
使用Ajax，用戶可以創建接近本地桌面應用的直接、高可用、更豐富、更動態的Web用戶界面。

偽造Ajax

我們可以使用前端的一個標簽來偽造一個ajax的樣子。iframe標簽

1、新建一個module ：springmvc-06-ajax ，導入web支持

2、編寫一個 ajax-frame.html 使用 iframe 測試，感受下效果

<!DOCTYPE html> <html> <head lang="en"><meta charset="UTF-8"><title>ajax-demo</title> </head> <body><script type="text/javascript">window.onload = function(){var myDate = new Date();document.getElementById('currentTime').innerText = myDate.getTime();};function LoadPage(){var targetUrl = document.getElementById('url').value;console.log(targetUrl);document.getElementById("iframePosition").src = targetUrl;}</script><div><p>請輸入要加載的地址：<span id="currentTime"></span></p><p><input id="url" type="text" value="https://www.baidu.com/"/><input type="button" value="提交" onclick="LoadPage()"></p> </div><div><h3>加載頁面位置：</h3><iframe id="iframePosition" style="width: 100%;height: 500px;"></iframe> </div></body> </html>

3、使用IDEA開瀏覽器測試一下！

利用AJAX可以做：

注冊時，輸入用戶名自動檢測用戶是否已經存在。
登陸時，提示用戶名密碼錯誤
刪除數據行時，將行ID發送到后臺，后臺在數據庫中刪除，數據庫刪除成功后，在頁面DOM中將數據行也刪除。
…

jQuery.ajax

純JS原生實現Ajax我們不去講解這里，直接使用jquery提供的，方便學習和使用，避免重復造輪子，有興趣的同學可以去了解下JS原生XMLHttpRequest ！

Ajax的核心是XMLHttpRequest對象(XHR)。XHR為向服務器發送請求和解析服務器響應提供了接口。能夠以異步方式從服務器獲取新數據。

jQuery 提供多個與 AJAX 有關的方法。

通過 jQuery AJAX 方法，您能夠使用 HTTP Get 和 HTTP Post 從遠程服務器上請求文本、HTML、XML 或 JSON – 同時您能夠把這些外部數據直接載入網頁的被選元素中。

jQuery 不是生產者，而是大自然搬運工。

jQuery Ajax本質就是 XMLHttpRequest，對他進行了封裝，方便調用！

jQuery.ajax(...)部分參數：url：請求地址type：請求方式，GET、POST（1.9.0之后用method）headers：請求頭data：要發送的數據contentType：即將發送信息至服務器的內容編碼類型(默認: "application/x-www-form-urlencoded; charset=UTF-8")async：是否異步timeout：設置請求超時時間（毫秒）beforeSend：發送請求前執行的函數(全局)complete：完成之后執行的回調函數(全局)success：成功之后執行的回調函數(全局)error：失敗之后執行的回調函數(全局)accepts：通過請求頭發送給服務器，告訴服務器當前客戶端可接受的數據類型dataType：將服務器端返回的數據轉換成指定類型"xml": 將服務器端返回的內容轉換成xml格式"text": 將服務器端返回的內容轉換成普通文本格式"html": 將服務器端返回的內容轉換成普通文本格式，在插入DOM中時，如果包含JavaScript標簽，則會嘗試去執行。"script": 嘗試將返回值當作JavaScript去執行，然后再將服務器端返回的內容轉換成普通文本格式"json": 將服務器端返回的內容轉換成相應的JavaScript對象"jsonp": JSONP 格式使用 JSONP 形式調用函數時，如 "myurl?callback=?" jQuery 將自動替換 ? 為正確的函數名，以執行回調函數

我們來個簡單的測試，使用最原始的HttpServletResponse處理。最簡單 , 最通用

10.攔截器

11.文件上傳和下載

總結

以上是生活随笔為你收集整理的Java学习笔记13-1——SpringMVC的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： angular-过滤器
下一篇： Java学习笔记5-1——多线程