• SpringMVC

    一、介绍 

    SpringMVC是Spring的一个后续产品，是Spring的一个子项目，SpringMVC 是 Spring 为表述层开发提供的一整套完备的解决方案。在表述层框架历经 Strust、 WebWork、Strust2 等诸多产品的历代更迭之后，目前业界普遍选择了 SpringMVC 作为 Java EE 项目 表述层开发的首选方案

    基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一 处理

    内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可

    二、入门案例

    1、引入依赖

    1. <dependencies>
    3. <dependency>
    4. <groupId>org.springframeworkgroupId>
    5. <artifactId>spring-webmvcartifactId>
    6. <version>5.3.1version>
    7. dependency>
    9. <dependency>
    10. <groupId>ch.qos.logbackgroupId>
    11. <artifactId>logback-classicartifactId>
    12. <version>1.2.3version>
    13. dependency>
    15. <dependency>
    16. <groupId>javax.servletgroupId>
    17. <artifactId>javax.servlet-apiartifactId>
    18. <version>3.1.0version>
    19. <scope>providedscope>
    20. dependency>
    22. <dependency>
    23. <groupId>org.thymeleafgroupId>
    24. <artifactId>thymeleaf-spring5artifactId>
    25. <version>3.0.12.RELEASEversion>
    26. dependency>
    27. dependencies>

    由于 Maven 的传递性，我们不必将所有需要的包全部配置依赖，而是配置最顶端的依赖，其他靠 传递性导入

     2、配置web.xml

    因为SpringMvc本质上还是一个servlet，将servlet封装成了一个DispatcherServlet,而servlet是要配置在web.xml中对请求和响应进行统一处理

    WEB-INF下创建web.xml

    1. "1.0" encoding="UTF-8"?>
    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
    5.          http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    6.          version="3.1">
    8. <servlet>
    9.      <servlet-name>springMVCservlet-name>
    10.      <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    12.      <init-param>
    14.           <param-name>contextConfigLocationparam-name>
    16.           <param-value>classpath:springmvc.xmlparam-value>
    17.      init-param>
    18.      
    19.      <load-on-startup>1load-on-startup>
    20. servlet>
    21. <servlet-mapping>
    23.     <servlet-name>springMVCservlet-name>
    24.     <url-pattern>/url-pattern>
    25. servlet-mapping>
    26.  
    27.  
    28. web-app>

    注

    上面设置springMVC的核心控制器所能处理的请求的请求路径，即DispatcherServlet处理的路径

    / 表示所匹配的请求可以是/login或.html或.js或.css方式的请求路径，不包括.jsp请求，因为jsp本质是一个servlet，需要经过jspServlet翻译成servlet然后响应给浏览器，DispatcherServlet是没法处理.jsp请求的
    /*  匹配所有的请求，包括.jsp，但是.jspDispatcherServlet没法处理jsp，是通过tomcat自己的jspServlet处理，所以这里配置/就可以

    如下tomcat的web.xml

    1.     <servlet>
    2.         <servlet-name>defaultservlet-name>
    3.         <servlet-class>org.apache.catalina.servlets.DefaultServletservlet-class>
    4.         <init-param>
    5.             <param-name>debugparam-name>
    6.             <param-value>0param-value>
    7.         init-param>
    8.         <init-param>
    9.             <param-name>listingsparam-name>
    10.             <param-value>falseparam-value>
    11.         init-param>
    12.         <load-on-startup>1load-on-startup>
    13.     servlet>
    14.  
    15.     <servlet>
    16.         <servlet-name>jspservlet-name>
    17.         <servlet-class>org.apache.jasper.servlet.JspServletservlet-class>
    18.         <init-param>
    19.             <param-name>forkparam-name>
    20.             <param-value>falseparam-value>
    21.         init-param>
    22.         <init-param>
    23.             <param-name>xpoweredByparam-name>
    24.             <param-value>falseparam-value>
    25.         init-param>
    26.         <load-on-startup>3load-on-startup>
    27.     servlet>
    28.  
    29.  
    30.     
    31.     <servlet-mapping>
    32.         <servlet-name>defaultservlet-name>
    33.         <url-pattern>/url-pattern>
    34.     servlet-mapping>
    35.  
    36.     
    37.     <servlet-mapping>
    38.         <servlet-name>jspservlet-name>
    39.         <url-pattern>*.jspurl-pattern>
    40.         <url-pattern>*.jspxurl-pattern>
    41.     servlet-mapping>

    当然如果模板引起用的不是jsp而是thmeleaf，那上面配置/*也是可以的 

     3、创建请求控制器

    springMvc就是封装的servlet，所以我们不需要再创建servlet，只需要创建一个普通java类，在这个普通类上标上@Controller注解将其标识 为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在

    主要每一个请求不能通过DispatcherServlet处理，DispatcherServlet可以处理一些共性问题，比如说获取请求参数、向域对象存储共享数据、页面跳转和重定向，具体请求如何处理还是通过上面的标有@Controller的普通java类

    1. @Controller
    2. public class UserController {
    3.  
    4. }

    4、创建springMvc配置文件

    如果web.xml配置内容如下

    1. <servlet>
    2.     <servlet-name>springMVCservlet-name>
    3.     <servlet-class>org.springframework.web.servlet.DispatcherServletservletclass>
    4. servlet>
    5. <servlet-mapping>
    6.     <servlet-name>springMVCservlet-name>
    7.     <url-pattern>/url-pattern>
    8. servlet-mapping>

    此时SpringMVC的配置文件默认位于WEB-INF下，默认名称为- servlet.xml，例如，以下上面所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVC-servlet.xml

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
    6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    7.        http://www.springframework.org/schema/beans/spring-beans.xsd
    8.        http://www.springframework.org/schema/context
    9.        http://www.springframework.org/schema/context/spring-context.xsd
    10.        http://www.springframework.org/schema/mvc
    11.        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    12.  
    13.     
    14.     <context:component-scan base-package="com.ssmtest.controller"/>
    15.  
    16.     
    17.     
    18.  
    19.     
    20.     <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
    21.         <property name="order" value="1"/>
    22.         <property name="characterEncoding" value="UTF-8"/>
    23.         <property name="templateEngine">
    24.             <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
    25.                 <property name="templateResolver">
    26.                     <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
    27.                         <property name="prefix" value="/view/"/>
    28.                         <property name="suffix" value=".html"/>
    29.                         <property name="templateMode" value="HTML5"/>
    30.                         <property name="characterEncoding" value="UTF-8"/>
    31.                     bean>
    32.                 property>
    33.             bean>
    34.         property>
    35.     bean>
    36.  
    37.     
    38.     <mvc:default-servlet-handler />
    39.  
    40.     
    41.     <mvc:annotation-driven>
    42.         <mvc:message-converters>
    43.             
    44.             <bean class="org.springframework.http.converter.StringHttpMessageConverter">
    45.                 <property name="defaultCharset" value="UTF-8" />
    46.                 <property name="supportedMediaTypes">
    47.                     <list>
    48.                         <value>text/htmlvalue>
    49.                         <value>application/jsonvalue>
    50.                     list>
    51.                 property>
    52.             bean>
    53.         mvc:message-converters>
    54.     mvc:annotation-driven>
    55.  
    56.     
    57.     <mvc:view-controller path="/" view-name="index"/>
    58. beans>

    上面 springMVC-servlet.xml文件是在WEB-INF下的，如果想修改位置以及文件名称，需要修改web.xml为如下

    1. "1.0" encoding="UTF-8"?>
    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
    5.          http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    6.          version="3.1">
    7.  
    8. <servlet>
    9.      <servlet-name>springMVCservlet-name>
    10.      <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    12.      <init-param>
    13.           <param-name>contextConfigLocationparam-name>
    14.           <param-value>classpath:springmvc.xmlparam-value>
    15.      init-param>
    16.      <load-on-startup>1load-on-startup>
    17. servlet>
    18. <servlet-mapping>
    19.     <servlet-name>springMVCservlet-name>
    20.     <url-pattern>/url-pattern>
    21. servlet-mapping>
    22.  
    23.  
    24. web-app>

    注意：SpringMVC中文乱码的三种解决方案

    1.get请求乱码 在Tomcat的server.xml文件夹下修改配置：

    2.POST请求乱码解决方案是在web.xml中输入以下内容：

    1.      
    2.     <filter>
    3.         <filter-name>encodingFilterfilter-name>
    4.         <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    5.         <init-param>
    6.             <param-name>encodingparam-name>
    7.             <param-value>utf-8param-value>
    8.         init-param>
    9.         <init-param>
    10.             <param-name>forceEncodingparam-name>
    11.             <param-value>trueparam-value>
    12.         init-param>
    13.     filter>
    14.     <filter-mapping>
    15.         <filter-name>encodingFilterfilter-name>
    16.         <url-pattern>/*url-pattern>
    17.     filter-mapping>

    SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效 

    3.Response响应请求乱码问题解决方案，是在applicationContext.xml文件中进行以下配置

    2.     
    3.         
    4.             
    5.             "org.springframework.http.converter.StringHttpMessageConverter">
    6.                 "defaultCharset" value="UTF-8" />
    7.                 "supportedMediaTypes">
    8.                     
    9.                         text/html
    10.                         application/json
    11.                     
    12.                 
    13.             
    14.         
    15.

    5、部署测试

    在上面定义的请求控制器定义方法

    1. @RequestMapping("/hello")
    2. public String hello() {
    3. //设置视图名称
    4. return "hello";
    5. }
    6.  
    7.  
    8. @RequestMapping("/index")
    9. public String index() {
    10. //设置视图名称
    11. return "index";
    12. }

    index.html页面

    1. html>
    2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4. <meta charset="UTF-8">
    5. <title>首页title>
    6. head>
    7. <body>
    8. <h1>首页h1>
    9. //下面的@表示thmeleaf会自动帮我们加上应用在tomcat的上下文路径，即可相当于localhost/demo/hello
    10. <a th:href="@{/hello}">HelloWorlda><br/>
    11. body>
    12. html>

    部署，使用tomcat部署web项目

    点击Add Configuration->+

    选择Tomcat Server下的Local，name自定义，选择Deployment,点击+

    选择Artifacts下的exploded 部署

    配置在tomcat服务器中的应用上下文路径，应为tomcat是一个服务器，里面可以部署多个应用，通过下面这个上下文路径就可以访问到指定的应用的路径

     选择server

    上面的1处表示部署项目后点击刷新时候重新部署（Redploy,获取其他选项），如下点击刷新弹出出我们上面选中的Redploy,这里可以Do not ask again

     上面2处表示当前idea窗口失去焦点，时候更新类和资源

    6、总结

    浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器 DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器， 将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的 控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会 被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视 图所对应页面

    三、RequestMapping

    1、作用和位置

    作用：将请求和处理请求的控制器方法关联 起来，建立映射关系

    位置：

    @RequestMapping标识一个类：设置映射请求的请求路径的初始信息

    @RequestMapping标识一个方法：设置映射请求请求路径的具体信息

    2、属性

    查看RequestMapping注解源码，可以看到有如下属性

    1. public @interface RequestMapping {
    2.     String name() default "";
    3.  
    4.     @AliasFor("path")
    5.     String[] value() default {};
    6.  
    7.     @AliasFor("value")
    8.     String[] path() default {};
    9.  
    10.     RequestMethod[] method() default {};
    11.  
    12.     String[] params() default {};
    13.  
    14.     String[] headers() default {};
    15.  
    16.     String[] consumes() default {};
    17.  
    18.     String[] produces() default {};
    19. }

    2.1、value属性

    是@RequestMapping注释的默认属性，因此如果只有唯一的属性，则可以省略该属性名，如果有超过一个属性，则必须写上value属性名称。即如下两个标注含义一样

    @RequestMapping(value="getUser")

    @RequestMapping("getUser")

    value属性支持通配符匹配@RequestMapping(value="getUser/*")；即：http://localhost:8080/getUser/1或者http://localhost:8080/getUser/hahaha都能够正常访问
     

    2.2、path属性

    和value属性使用一致，两者都是用来作为映射使用的。

    @RequestMapping(value="getUser")、@RequestMapping(path="getUser")，这两种情况都能对getUser()方法进行访问

    path属性支持通配符匹配@RequestMapping(path="getUser/*")；即：http://localhost:8080/getUser/1或者http://localhost:8080/getUser/hahaha都能够正常访问
     

    2.3、name属性

    相当于方法的注释，使方法更易理解 

    @RequestMapping(value = "getUser",name = "获取用户信息")

    2.4、method属性

    该属性用来表示该方法仅仅处理哪些HTTP请求方式

    以上方法表示，该方法只支持GET请求。

    此处也可以为@RequestMapping(value = "getUser",method = {RequestMethod.GET,RequestMethod.POST})，说明该方法可以同时支持GET和POST请求。

    如果没有method属性，则说明该方法支持全部的HTTP请求。
     

    2.5、params属性

    该属性指定，请求中必须包含params属性规定的参数时，才能执行该请求

    @RequestMapping(value = "getUser",params = "flag")

    以上方法，说明请求中必须包含flag参数才能执行该请求，flag参数值不做要求

    http://localhost:8080/getUser?flag=xxx     此URL能够正常访问getUser()方法

    http://localhost:8080/getUser       此URL则不能正常访问getUser()方法

    @RequestMapping(value = "getUser",params = "flag=true")

    以上方法，说明请求中必须包含flag参数，而且参数值必须为true才能执行该请求

    http://localhost:8080/getUser?flag=true    此URL能够正常访问getUser()方法

    http://localhost:8080/getUser?flag=false    此URL不能正常访问getUser()方法

    http://localhost:8080/getUser       此URL则不能正常访问getUser()方法


    2.6、header属性

    该属性指定，请求中必须包含某些指定的header值，才能够让该方法处理请求

    @RequestMapping(value = "getUser",headers = "Referer=http://www.xxx.com")

    以上方法 ，必须满足请求的header中包含了指定的"Referer"请求头和值为"http://www.xxx.com"时，才能执行该请求

    @RequestMapping注解的headers属性是一个字符串类型的数组，可以通过四种表达式设置请求头信 息和请求映射的匹配关系

    "header"：要求请求映射所匹配的请求必须携带header请求头信息

    "!header"：要求请求映射所匹配的请求必须不能携带header请求头信息

    "header=value"：要求请求映射所匹配的请求必须携带header请求头信息且header=value "header!=value"：要求请求映射所匹配的请求必须携带header请求头信息且header!=value

    若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面 显示404错误，即资源未找到

    2.7、consumers属性

    @RequestMapping(value = "getUser",consumes = "application/json")

    指定处理请求的提交内容类型（Content-Type），例如：application/json、text/html时，才能够让该方法处理请求

    2.8、produces属性

    @RequestMapping(value = "getUser",produces = "application/json")

    指定返回的内容类型，返回的内容类型必须是request请求头（Accept）中所包含的类型

    此外，produces属性还可以指定返回值的编码

    @RequestMapping(value = "getUser",produces = "application/json，charset=utf-8")，则指明返回utf-8编码

    3、SpringMVC支持ant风格的路径

    ？：表示任意的单个字符

    *：表示任意的0个或多个字符

    **：表示任意层数的任意目录

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

    4、SpringMVC支持路径中的占位符

    原始方式：/deleteUser?id=1

    rest方式：/user/delete/1

    SpringMVC路径中的占位符常用于RESTful风格中，当请求路径中将某些数据通过路径的方式传输到服 务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在 通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参

    1. @RequestMapping("/testRest/{id}/{username}")
    2. public String testRest(@PathVariable("id") String id, @PathVariable("username")
    3. String username){
    4. System.out.println("id:"+id+",username:"+username);
    5. return "success";
    6. }

    四、SpringMVC获取请求参数

    1、通过ServletAPI获取

    将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请 求的请求报文的对象

    1. @RequestMapping("/testParam")
    2. public String testParam(HttpServletRequest request){
    3.     String username = request.getParameter("username");
    4.     String password = request.getParameter("password");
    5.     System.out.println("username:"+username+",password:"+password);
    6.     return "success";
    7. }

    2、通过控制器方法的形参获取请求参数

    在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，在 DispatcherServlet中就会将请求参数赋值给相应的形参

    如：请求地址http://localhost/testParam?username=admin&password=123456

    控制器

    1. @RequestMapping("/testParam")
    2. public String testParam(String username, String password){
    3. System.out.println("username:"+username+",password:"+password);
    4. return "success";
    5. }

     注：

    若请求所传输的请求参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串 数组或者字符串类型的形参接收此请求参数

    若使用字符串数组类型的形参，此参数的数组中包含了每一个数据

    若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果

    3、@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所指定的请求参数没有传输或传输的值 为""时，则使用默认值为形参赋值

    defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值 为""时，则使用默认值为形参赋值

    4、@RequestHeader

    @RequestHeader是将请求头信息和控制器方法的形参创建映射关系

    @RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

    5、@CookieValue

    @CookieValue是将cookie数据和控制器方法的形参创建映射关系 @CookieValue注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

    6、通过POJO获取请求参数

    可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实 体类中的属性名一致，那么请求参数就会为此属性赋值

    1. <form th:action="@{/testpojo}" method="post">
    2.     用户名：<input type="text" name="username"><br>
    3.     密码：<input type="password" name="password"><br>
    4.     性别：<input type="radio" name="sex" value="男">男<input type="radio"
    5.     name="sex" value="女">女<br>
    6.     年龄：<input type="text" name="age"><br>
    7.     邮箱：<input type="text" name="email"><br>
    8.     <input type="submit">
    9. form>
    1. @RequestMapping("/testpojo")
    2. public String testPOJO(User user){
    3.     System.out.println(user);
    4.     return "success";
    5. }

    7、接受/响应json数据

    {key:value,key:value,...}类型的请求参数，此时无法通过request.getParameter()获取，之前我们使用操作 json的相关jar包gson或jackson处理此类请求参数，可以将其转换为指定的实体类对象或map集 合。在SpringMVC中，直接使用@RequestBody注解标识控制器方法的形参即可将此类请求参数 转换为java对象

    需要导入依赖

    com.fasterxml.jackson.core

    在控制器方法的形参位置，设置json格式的请求参数要转换成的java类型（实体类或map）的参 数，并使用@RequestBody注解标识

    1. //将json格式的数据转换为map集合
    2. @RequestMapping("/test/RequestBody/json")
    3. public void testRequestBody(@RequestBody Map map,
    4. HttpServletResponse response) throws IOException {
    5. System.out.println(map);
    6. //{username=admin, password=123456}
    7. response.getWriter().print("hello,axios");
    8. }
    9. //将json格式的数据转换为实体类对象
    10. @RequestMapping("/test/RequestBody/json")
    11. public void testRequestBody(@RequestBody User user, HttpServletResponse
    12. response) throws IOException {
    13. System.out.println(user);
    14. //User{id=null, username='admin', password='123456', age=null,
    15. gender='null'}
    16. response.getWriter().print("hello,axios");
    17. }

    与其对应的响应json数据注解@ResponseBody

    ResponseBody用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到 浏览器 

    1. @RequestMapping("/testResponseBody")
    2. @ResponseBody
    3. public String testResponseBody(){
    4. //此时响应浏览器数据success
    5. return "success";
    6. }

    服务器处理ajax请求之后，大多数情况都需要向浏览器响应一个java对象，此时必须将java对象转换为 json字符串才可以响应到浏览器，之前我们使用操作json数据的jar包gson或jackson将java对象转换为 json字符串。在SpringMVC中，我们可以直接使用@ResponseBody注解实现此功能

    使用@ResponseBody注解标识控制器方法，在方法中，将需要转换为json字符串并响应到浏览器 的java对象作为控制器方法的返回值，此时SpringMVC就可以将此对象直接转换为json字符串并响应到 浏览器

    1. //响应浏览器list集合
    2. @RequestMapping("/test/ResponseBody/json")
    3. @ResponseBody
    4. public List testResponseBody(){
    5. User user1 = new User(1001,"admin1","123456",23,"男");
    6. User user2 = new User(1002,"admin2","123456",23,"男");
    7. User user3 = new User(1003,"admin3","123456",23,"男");
    8. List list = Arrays.asList(user1, user2, user3);
    9. return list;
    10. }
    11. //响应浏览器map集合
    12. @RequestMapping("/test/ResponseBody/json")
    13. @ResponseBody
    14. public Map testResponseBody(){
    15. User user1 = new User(1001,"admin1","123456",23,"男");
    16. User user2 = new User(1002,"admin2","123456",23,"男");
    17. User user3 = new User(1003,"admin3","123456",23,"男");
    18. Map map = new HashMap<>();
    19. map.put("1001", user1);
    20. map.put("1002", user2);
    21. map.put("1003", user3);
    22. return map;
    23. }
    24. //响应浏览器实体类对象
    25. @RequestMapping("/test/ResponseBody/json")
    26. @ResponseBody
    27. public User testResponseBody(){
    28. return user;
    29. }

     @RestController注解是springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了 @Controller注解，并且为其中的每个方法添加了@ResponseBody注解

    五、域对象共享数据

    1、使用ServletAPI向request域对象共享数据

    1. @RequestMapping("/testServletAPI")
    2. public String testServletAPI(HttpServletRequest request){
    3. request.setAttribute("testScope", "hello,servletAPI");
    4. return "success";
    5. }

    2、使用ModelAndView向request域对象共享数据

    1. @RequestMapping("/testModelAndView")
    2. public ModelAndView testModelAndView(){
    3.     /**
    4.     * ModelAndView有Model和View的功能
    5.     * Model主要用于向请求域共享数据
    6.     * View主要用于设置视图，实现页面跳转
    7.     */
    8.     ModelAndView mav = new ModelAndView();
    9.     //向请求域共享数据
    10.     mav.addObject("testScope", "hello,ModelAndView");
    11.     //设置视图，实现页面跳转
    12.     mav.setViewName("success");
    13.     return mav;
    14. }

    3、使用Model向request域对象共享数据

    1. @RequestMapping("/testModel")
    2. public String testModel(Model model){
    3.     model.addAttribute("testScope", "hello,Model");
    4.     return "success";
    5. }

    4、使用map向request域对象共享数据

    1. @RequestMapping("/testMap")
    2. public String testMap(Map map){
    3.     map.put("testScope", "hello,Map");
    4.     return "success";
    5. }

    5、使用ModelMap向request域对象共享数据

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

    Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap 类型的

    6、向session域共享数据

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

     7、向application域共享数据

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

    六、SpringMVC的视图

    SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户

    SpringMVC视图的种类很多，默认有转发视图和重定向视图，但是 当工程引入jstl的依赖，转发视图会自动转换为JstlView

    若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视 图解析器解析之后所得到的是ThymeleafView

    转发视图

    SpringMVC中默认的转发视图是InternalResourceView

    SpringMVC中创建转发视图的情况： 当控制器方法中所设置的视图名称以"forward:"为前缀时，创建InternalResourceView视图，此时的视 图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"forward:"去掉，剩余部 分作为最终路径通过转发的方式实现跳转

    例如"forward:/"，"forward:/employee"

    1. @RequestMapping("/testForward")
    2. public String testForward(){
    3. return "forward:/testHello";
    4. }

    重定向视图 

    SpringMVC中默认的重定向视图是RedirectView 

    当控制器方法中所设置的视图名称以"redirect:"为前缀时，创建RedirectView视图，此时的视图名称不 会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"redirect:"去掉，剩余部分作为最 终路径通过重定向的方式实现跳转

    例如"redirect:/"，"redirect:/employee"

    1. @RequestMapping("/testRedirect")
    2. public String testRedirect(){
    3. return "redirect:/testHello";
    4. }

    重定向视图在解析时，会先将redirect:前缀去掉，然后会判断剩余部分是否以/开头，若是则会自 动拼接上下文路径 

    视图控制器view-controller

    当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用viewcontroller标签进行表示

    2. <mvc:view-controller path="/testView" view-name="success">mvc:view-controller>

    当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将全部失效，此时需 要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签

    七、RESTful

    springMvc也是支持RESTful风格请求方式

    就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。

    它们分别对应四种基本操作：

    GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。

    REST 风格提倡 URL 地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方 式携带请求参数，而是将要发送给服务器的数据作为 URL 地址的一部分，以保证整体风格的一致性

     

     由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？

    SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求 HiddenHttpMethodFilter 处理put和delete请求的条件：

    a>当前请求的请求方式必须为post

    b>当前请求必须传输请求参数_method

    满足以上条件，HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数 _method的值，因此请求参数_method的值才是最终的请求方式 在web.xml中注册HiddenHttpMethodFilter

    1. <filter>
    2. <filter-name>HiddenHttpMethodFilterfilter-name>
    3. <filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilterclass>
    4. filter>
    5. <filter-mapping>
    6. <filter-name>HiddenHttpMethodFilterfilter-name>
    7. <url-pattern>/*url-pattern>
    8. filter-mapping>

    目前为止，SpringMVC中提供了两个过滤器：CharacterEncodingFilter和 HiddenHttpMethodFilter 在web.xml中注册时，必须先注册CharacterEncodingFilter，再注册HiddenHttpMethodFilter

    原因：

    在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字 符集的

    request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作 而 HiddenHttpMethodFilter 恰恰有一个获取请求方式的操作： 

    String paramValue = request.getParameter(this.methodParam);

    案例

    前端链接请求

    update

    后端控制器

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

    八、文件下载、上传

    ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文

    1、下载

    1. @RequestMapping("/testDown")
    2. public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws
    3. IOException {
    4.     //获取ServletContext对象
    5.     ServletContext servletContext = session.getServletContext();
    6.     //获取服务器中文件的真实路径
    7.     String realPath = servletContext.getRealPath("/static/img/1.jpg");
    8.     //创建输入流
    9.     InputStream is = new FileInputStream(realPath);
    10.     //创建字节数组
    11.     byte[] bytes = new byte[is.available()];
    12.     //将流读到字节数组中
    13.     is.read(bytes);
    14.     //创建HttpHeaders对象设置响应头信息
    15.     MultiValueMap headers = new HttpHeaders();
    16.     //设置要下载方式以及下载文件的名字
    17.     headers.add("Content-Disposition", "attachment;filename=1.jpg");
    18.     //设置响应状态码
    19.         HttpStatus statusCode = HttpStatus.OK;
    20.     //创建ResponseEntity对象
    21.     ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers,
    22.     statusCode);
    23.     //关闭输入流
    24.     is.close();
    25.     return responseEntity;
    26. }

    2、上传

    文件上传要求form表单的请求方式必须为post，并且添加属性enctype="multipart/form-data" SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息

    2. <bean id="multipartResolver"
    3. class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    4. bean>

     

    1. @RequestMapping("/testUp")
    2. public String testUp(MultipartFile photo, HttpSession session) throws
    3. IOException {
    4.     //获取上传的文件的文件名
    5.     String fileName = photo.getOriginalFilename();
    6.     //处理文件重名问题
    7.     String hzName = fileName.substring(fileName.lastIndexOf("."));
    8.     fileName = UUID.randomUUID().toString() + hzName;
    9.     //获取服务器中photo目录的路径
    10.     ServletContext servletContext = session.getServletContext();
    11.     String photoPath = servletContext.getRealPath("photo");
    12.     File file = new File(photoPath);
    13.     if(!file.exists()){
    14.     file.mkdir();
    15. }
    16.     String finalPath = photoPath + File.separator + fileName;
    17.     //实现上传功能
    18.         photo.transferTo(new File(finalPath));
    19.     return "success";
    20. }

    九、拦截器

    SpringMVC中的拦截器用于拦截控制器方法的执行

    SpringMVC中的拦截器需要实现HandlerInterceptor

    SpringMVC的拦截器必须在SpringMVC的配置文件中进行配置

    1. <bean class="com.demo.interceptor.FirstInterceptor">bean>
    2. <ref bean="firstInterceptor">ref>
    4. <mvc:interceptor>
    5. <mvc:mapping path="/**"/>
    6. <mvc:exclude-mapping path="/testRequestEntity"/>
    7. <ref bean="firstInterceptor">ref>
    8. mvc:interceptor>

    SpringMVC中的拦截器有三个抽象方法

    preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返 回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方

    postHandle：控制器方法执行之后执行postHandle()

    afterCompletion：处理完视图和模型数据，渲染视图完毕之后执行afterCompletion()

    多个拦截器的执行顺序

    ①若每个拦截器的preHandle()都返回true

    此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：

    preHandle()会按照配置的顺序执行，而postHandle()和afterCompletion()会按照配置的反序执行

    ②若某个拦截器的preHandle()返回了false

    preHandle()返回false和它之前的拦截器的preHandle()都会执行，

    postHandle()都不执行，返回false 的拦截器之前的拦截器的afterCompletion()会执行

    十、异常处理器

    我们每个控制器方法在执行过程中如果发生了异常，就可以通过springMvc提供的一个接口处理异常，这个接口就是HandlerExceptionResolver

    而HandlerExceptionResolver接口的实现类有：DefaultHandlerExceptionResolver和 SimpleMappingExceptionResolver

    springMvc默认使用的异常处理器就是DefaultHandlerExceptionResolver，如果我们要自定义异常处理器，就使用SimpleMappingExceptionResolver类

    1、使用xml配置方式

    springMvc.xml中配置

    2.         <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    3.             <property name="exceptionMappings">
    4.                 <props>
    5.                     
    6.                     <prop key="java.lang.NullPointerException">errorprop>
    7.                     <prop key="java.lang.ArithmeticException">errorprop>
    8.                 props>
    9.             property>
    10.             
    11.             <property name="exceptionAttribute" value="ex"/>
    12.         bean>

    2、注解方式

    1. //@ControllerAdvice将当前类标识为异常处理的组件 @RestControllerAdvice返回rest
    2. @ControllerAdvice
    3. public class ExceptionController {
    4.     //@ExceptionHandler用于设置所标识方法处理的异常
    5.     @ExceptionHandler(ArithmeticException.class)
    6.     //ex表示当前请求处理中出现的异常对象
    7.     public String handleArithmeticException(Exception ex, Model model){
    8.         model.addAttribute("ex", ex);
    9.         return "error";
    10.     }
    11. }

    十一、注解配置SpringMvc

    使用配置类和注解代替web.xml和SpringMVC配置文件的功能

    在Servlet3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类， 如果找到的话就用它来配置Servlet容器，就是替代web.xml。

    Spring提供了这个接口的实现，名为 SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配 置的任务交给它们来完成。

    Spring3.2引入了一个便利的WebApplicationInitializer基础实现，名为 AbstractAnnotationConfigDispatcherServletInitializer，当我们的类继承扩展了 AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候，容器会自 动发现它，并用它来配置Servlet上下文，即替代web.xml文件

    1.  
    2. public class Webint extends AbstractAnnotationConfigDispatcherServletInitializer {
    3.     //设置一个配置类代替spring配置文件
    4.     @Override
    5.     protected Class[] getRootConfigClasses() {
    6.         //spring相关的配置 可以查看spring篇
    7.         return new Class[]{SpringConfig.class};
    8.     }
    9.  
    10.    //设置一个配置类代替Springmvc配置文件
    11.     @Override
    12.     protected Class[] getServletConfigClasses() {
    13.         return new Class[0];
    14.     }
    15.  
    16.     //设置Springmvc前端控制器url-pattern
    17.     @Override
    18.     protected String[] getServletMappings() {
    19.         return new String[]{"/"};
    20.     }
    21.  
    22.     //请求参数编码过滤器
    23.     @Override
    24.     protected Filter[] getServletFilters() {
    25.         CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
    26.         encodingFilter.setEncoding("UTF-8");
    27.         encodingFilter.setForceRequestEncoding(true);
    28.         HiddenHttpMethodFilter hiddenHttpMethodFilter = new
    29.                 HiddenHttpMethodFilter();
    30.         return new Filter[]{encodingFilter, hiddenHttpMethodFilter};
    31.     }
    32. }

    spring配置类（查看ssm注解整合配置篇）

    SpringMvc配置类

    1.  
    2. //标识配置类
    3. @Configuration
    4. //扫描组件
    5. @ComponentScan("com.ssm.controller")
    6. //开启MVC注解驱动
    7. @EnableWebMvc
    8. public class SpringMvcConfig implements WebMvcConfigurer {
    9.     //使用默认的servlet处理静态资源
    10.     @Override
    11.     public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
    12.         configurer.enable();
    13.     }
    14.  
    15.     //配置视图控制
    16.     @Override
    17.     public void addViewControllers(ViewControllerRegistry registry) {
    18.         registry.addViewController("/").setViewName("index");
    19.     }
    20.  
    21.     //配置文件上传解析器 将返回值作为bean（id是方法名）放入ioc容器中
    22.     @Bean
    23.     public CommonsMultipartResolver multipartResolver() {
    24.         return new CommonsMultipartResolver();
    25.     }
    26.  
    27.     //配置拦截器
    28.     @Override
    29.     public void addInterceptors(InterceptorRegistry registry) {
    30.         FirstInterceptor firstInterceptor = new FirstInterceptor();
    31.         registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
    32.     }
    33.  
    34.     //配置异常映射
    35.     @Override
    36.     public void configureHandlerExceptionResolvers(List resolvers) {
    37.         SimpleMappingExceptionResolver exceptionResolver = new
    38.                 SimpleMappingExceptionResolver();
    39.         Properties prop = new Properties();
    40.         prop.setProperty("java.lang.ArithmeticException", "error");
    41.         //设置异常映射
    42.         exceptionResolver.setExceptionMappings(prop);
    43.         //设置共享异常信息的键
    44.         exceptionResolver.setExceptionAttribute("ex");
    45.         resolvers.add(exceptionResolver);
    46.     }
    47.  
    48.     //配置生成模板解析器
    49.     @Bean
    50.     public ITemplateResolver templateResolver() {
    51.         WebApplicationContext webApplicationContext =
    52.                 ContextLoader.getCurrentWebApplicationContext();
    53.         // ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过WebApplicationContext 的方法获得
    54.         ServletContextTemplateResolver templateResolver = new
    55.                 ServletContextTemplateResolver(
    56.                 webApplicationContext.getServletContext());
    57.         templateResolver.setPrefix("/WEB-INF/templates/");
    58.         templateResolver.setSuffix(".html");
    59.         templateResolver.setCharacterEncoding("UTF-8");
    60.         templateResolver.setTemplateMode(TemplateMode.HTML);
    61.         return templateResolver;
    62.     }
    63.  
    64.     //生成模板引擎并为模板引擎注入模板解析器
    65.     @Bean
    66.     public SpringTemplateEngine templateEngine(ITemplateResolver
    67.                                                        templateResolver) {
    68.         SpringTemplateEngine templateEngine = new SpringTemplateEngine();
    69.         templateEngine.setTemplateResolver(templateResolver);
    70.         return templateEngine;
    71.     }
    72.  
    73.     //生成视图解析器并未解析器注入模板引擎
    74.     @Bean
    75.     public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
    76.         ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
    77.         viewResolver.setCharacterEncoding("UTF-8");
    78.         viewResolver.setTemplateEngine(templateEngine);
    79.         return viewResolver;
    80.     }
    81.  
    82. }

    十二、springmvc执行流程

    参考

    Spring MVC执行流程_枫叶..的博客-CSDN博客_springmvc执行流程

  • 相关阅读:
    EN 16034门窗及配件—CE认证
    基于密码芯片的 DDR 加速器的设计与实现
    企业级自定义表单引擎解决方案（十四）--表单模板2
    Excel的VLOOKUP函数的用法
    书生·浦语大模型开源体系（四）笔记
    【思考】我为钱工作 OR 钱为我工作？
    实体注解-批量生成10000条测试数据
    Dubbo入门案例
    3、你真的把MPC搞懂了吗
    vue笔记（二）
  • 原文地址：https://blog.csdn.net/qq_34491508/article/details/126386931