SpringMVC框架

一、SpringMVC介绍

1. 官方文档

地址：spring-framework-5.3.8/docs/reference/html/web.html#spring-web

2. SpringMVC 基本介绍

2.1 SpringMVC特点和概述

SpringMVC 从易用性、效率上比曾经流行的Struts2更好

SpringMVC 是Web层的框架【SpringMVC接管了Web层的组件，比如控制器、视图、视图解析器，返回给用户的数据格式，同时支持MVC的开发模式/开发架构】

SpringMVC通过注解，让pojo（普通的Java类）成为控制器，不需要继承类或者实现接口

SpringMVC采用低耦合的组件设计方式，具有更好的扩展和灵活性

支持REST格式的URL请求风格

SpringMVC 是基于Spring的，也就是SpringMVC是在Spring基础上的。SpringMVC的核心包spring-webmvc-xx.jar和spring-web-xx.jar

2.2 梳理Spring、SpringMVC和SpringBoot的关系

SpringMVC只是Spring处理WEB层请求的一个模块/组件，SpringMVC 的基石是Servlet

SpringBoot 是为了简化开发者的使用，推出的封神框架（约定优于配置，简化了Spring的配置流程），SpringBoot包含很多组件/框架，Spring就是最核心的内容之一，也包含SpringMVC

它们的关系大概是：SpringBoot > Spring > SpringMVC

3. 快速入门

3.1 需求说明

需求说明：完成一个最基本的测试案例，登录案例

3.2 代码实现

3.2.1 Controller包

package com.leon.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * ClassName:UserController
 * Package:com.leon.controller
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/13 8:42
 * @Version: 1.0
 */
@Controller
public class UserServlet {


   /*
   *  1.login() 方法用于响应用户的登录请求，其被RequestMapping注解标注
   *  2.RequestMapping注解可以将一个方法变成可以访问的方法，通过指定的URL进行请求
   *    value属性值表示请求的url，也可以理解为在web.xml文件中配置的<url-pattern></url-pattern>
   *  3.注意这个注解可以在类上进行标注，也可以给类进行value赋值，这时就需要加上类的URL
   *  4.即当用户在浏览器输入 http://localhost:8080/web工程路径/{类的URL}/login
   *  5.return "login_ok" 表示返回结果给视图解析器（InternalResourceViewResolver）
   *    视图解析器会根据配置，来决定跳转到哪个界面
   *   <!--配置SpringMVC的视图解析器-->
   * <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
   *    <!--配置前缀，是要访问的包-->
   *     <property name="prefix" value="/WEB-INF/pages/"></property>
   *     <!--配置后缀，是要访问的文件类型 -->
   *    <property name="suffix" value=".jsp"></property>
   * </bean>
   *  根据上面的配置，return "login_ok"，将会被转发到/WEB-INF/pages/login_ok.jsp
   * */
   @RequestMapping(value = "/login")
   public String login(){
      System.out.println("登录成功~~~~~");
      return "login_ok";
   }
}

3.2.2 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置要扫描的包路径-->
    <context:component-scan base-package="com.leon.controller"/>

    <!--配置SpringMVC的视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--配置前缀，是要访问的包-->
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <!--配置后缀，是要访问的文件类型 -->
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

3.2.3 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">
        <!--配置前端控制器/中央处理器/分发控制
            1.用户的请求会经过它的处理器
        -->
        <servlet>
            <servlet-name>springDispatcherServlet</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <!--配置ioc容器文件-->
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:applicationcontext_mvc.xml</param-value>
            </init-param>
            <!--配置加载顺序-->
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>springDispatcherServlet</servlet-name>
            <!--
                1.这里配置的url-pattern是 / ，表示用户的请求都经过 DispatcherServlet
                2.这样配置也支持rest 风格的url请求
            -->
            <url-pattern>/</url-pattern>
        </servlet-mapping>
</web-app>

3.2.4 jsp文件

<%--
  Created by IntelliJ IDEA.
  User: ZGJ
  Author: leon --> ZGJ
  Version: 1.0
  Date: 2024/4/13
  Time: 8:39
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>登录</h1>
    <form action="login" method="post">

        u:<input type="text" name="user"><br>
        p:<input type="password" name="pwd"><br>

        <input type="submit" value="登录">

    </form>

</body>
</html>
======================================================================================
<%--
  Created by IntelliJ IDEA.
  User: ZGJ
  Author: leon --> ZGJ
  Version: 1.0
  Date: 2024/4/13
  Time: 9:12
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>登录成功~~~</h1>

</body>
</html>

3.3 注意事项和使用细节

UserServlet 需要注解成Controller，称之为handler处理器

RequestMapping注解在指定url时，这个value属性名可以省略

关于SpringMVC 的DispatcherServlet的init-param中的contextConfigLocation配置，如果不在web.xml指定applicationcontext_mvc.xml，默认会在/WEB-INF/springDispatcherServle-servlet.xml找这个配置文件

4. SpringMVC执行流程

SpringMVC执行流程图

二、SpringMVC的使用

1. @RequestMapping 注解

1.1 基本使用

@RequestMapping 注解可以指定控制器/处理器的某个方法的请求的url，RequestMapping:请求映射

1.1.1 代码

/*
   *  1.login() 方法用于响应用户的登录请求，其被RequestMapping注解标注
   *  2.RequestMapping注解可以将一个方法变成可以访问的方法，通过指定的URL进行请求
   *    value属性值表示请求的url，也可以理解为在web.xml文件中配置的<url-pattern></url-pattern>
   *  3.注意这个注解可以在类上进行标注，也可以给类进行value赋值，这时就需要加上类的URL
   *  4.即当用户在浏览器输入 http://localhost:8080/web工程路径/{类的URL}/login
   *  5.return "login_ok" 表示返回结果给视图解析器（InternalResourceViewResolver）
   *    视图解析器会根据配置，来决定跳转到哪个界面
   *   <!--配置SpringMVC的视图解析器-->
   * <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
   *    <!--配置前缀，是要访问的包-->
   *     <property name="prefix" value="/WEB-INF/pages/"></property>
   *     <!--配置后缀，是要访问的文件类型 -->
   *    <property name="suffix" value=".jsp"></property>
   * </bean>
   *  根据上面的配置，return "login_ok"，将会被转发到/WEB-INF/pages/login_ok.jsp
   * */
   @RequestMapping(value = "/login")
   public String login(){
      System.out.println("登录成功~~~~~");
      return "login_ok";
   }

1.2 @RequestMapping 其它使用方式

1.2.1 @RequestMappping 可以修饰方法和类

说明

@RequestMapping 注解可以修饰方法，还可以修饰类当同时修饰类和方法时，请求的url就是类和方法的value组合，格式为：/类请求值/方法请求值

1.2.1.1 代码

package com.leon.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * ClassName:UserHandler
 * Package:com.leon.controller
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/13 13:34
 * @Version: 1.0
 */
@RequestMapping("/user")
@Controller
public class UserHandler {


      /*
      *  1. method=RequestMethod.POST: 表示请求buy目标方法必须是POST，
      *     如果不是POST请求方式的话则会报错
      *  2. RequestMethod 常用的四个选项POST,GET,PUT,DELETE
      *  3. SpringMVC 控制器默认支持GET和POST两种方式
      *  4. buy方法的请求URL：http://localhost:8080/springmvc/user/buy
      * */
      @RequestMapping(value = "/buy")
      public String buy(){
         System.out.println("购买商品~~~~");
         return "success";

      }

}
======================================================================================

<%--
  Created by IntelliJ IDEA.
  User: ZGJ
  Author: leon --> ZGJ
  Version: 1.0
  Date: 2024/4/13
  Time: 8:39
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>登录</h1>
    <form action="user/buy" method="post">

        u:<input type="text" name="user"><br>
        p:<input type="password" name="pwd"><br>

        <input type="submit" value="登录">

    </form>

</body>
</html>

1.2.2 @RequestMapping 可以指定请求方式

说明

@RequestMapping还可以指定请求的方式（POST/GET/PUT/DELETE），请求的的方式要和指定的一样，否则会报错

SpringMVC 控制器默认支持GET和POST两种方式，也就是你不指定Method，可以接收GET和POST请求

还可以直接使用@GetMapping，@PostMapping，@PutMapping，@DeleteMapping等这些注解，它们类似于 @RequestMapping（value = url , method = RequestMethod.请求方式）

1.2.2.1 代码

package com.leon.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * ClassName:UserHandler
 * Package:com.leon.controller
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/13 13:34
 * @Version: 1.0
 */
@RequestMapping("/user")
@Controller
public class UserHandler {


      /*
      *  1. method=RequestMethod.POST: 表示请求buy目标方法必须是POST，
      *     如果不是POST请求方式的话则会报错
      *  2. RequestMethod 常用的四个选项POST,GET,PUT,DELETE
      *  3. SpringMVC 控制器默认支持GET和POST两种方式
      *  4. buy方法的请求URL：http://localhost:8080/springmvc/user/buy
      * */
      @RequestMapping(value = "/buy",method = RequestMethod.POST)
      public String buy(){
         System.out.println("购买商品~~~~");
         return "success";

      }

      @GetMapping(value = "shopping")
      public String shopping(){

         System.out.println("逛商城~~~~");

         return "success";

      }
}

1.2.3 @RequestMapping可以指定params和headers支持简单表达式

说明

params =“xxx”，表示请求必须包含名为xxx的请求参数

params != “xxx”，表示请求不能包含名为xxx的请求参数

params = “xxx != value”，表示请求包含名为xxx的请求参数，但不能为value

param = { “xxx = value”,“ttt”}：表示请求必须包含为xxx和ttt的两个请求参数，且xxx参数的值必须为value

注意：方法中的形参名必须要和params的param一样才可以，否则形参值是null,也就是赋值失败

1.2.3.1 代码

 /*
      *  1. params="bookId" 表示请求该方法时，必须给一个bookId参数，只没有要求，请求时，所
      *     携带的参数值会赋值给方法中形参
      *  2. 注意：形参名要和params="bookId"中的请求参数名要一样否则获取不到
      *  3. params = "bookId=100" 表示请求该方法时，必须给一个bookId参数，且值必须是100
      *
      * */

      @RequestMapping(value = "/find",params = "bookId=100",method = RequestMethod.GET)
      public String search(String bookId){
         System.out.println("要买的书的id=="+bookId);

         return "success";
      }

1.2.4 @RequestMapping 支持Ant风格资源地址

说明

? ：配文件中的一个字符

* ：匹配文件中的任意字符

** ：匹配多层路径

Ant风格的URL地址举例

/user/*/createUser：匹配 /user/aaa/createUser、/user/bbb/createUser等URL

/user/**/createUser：匹配/user/createUser、/user/aaa/bbb/createUser等URL

/user/createUser??：匹配/user/createUseraa 、/user/createUserbb等URL

1.2.4.1 代码

@RequestMapping(value = "message/**")
      public String im(){
          System.out.println("发送信息");
          return "success";
      }
======================================================================================

    <h1>Ant的风格使用</h1>
    <a href="user/message/aa">发送信息</a>
    <a href="user/message/aa/dd">发送信息</a>

1.2.5 RequestMapping 可配合@PathVariable 映射URL绑定占位符

说明

@RequestMapping还可以配合@PathVariable映射URL绑定占位符

@PathVariable的value值要和占位符的名称一样，否则会报错

1.2.5.1 代码

 /*
      *     1.{userName} 表示一个占位符，名称为userName，在收到请求后会默认将Url中的值赋值
      *       请求方法的形参，但是需要使用@PathVariable这个注解，且它的value值必须和占位符的
      *       名称一样，否则会报错
      * */
      @RequestMapping(value = "/reg/{userName}/{userId}")
      public String register(@PathVariable("username")String name,
                             @PathVariable("userId")Integer  id){
          System.out.println("注册成功=用户：" + name + "id：" +id);
          return "success";
      }
======================================================================================

<h1>PathVariable的使用</h1>
    <a href="user/reg/lihua/200">发送信息</a>

1.2.6 注意事项和使用细节

映射的URL，不能重复

2. Rest优雅的Url请求风格

2.1 基本介绍

REST：即Representational State Transfer。（资源）表现层状态状态转化。是目前流行的请求方式，它结构清晰，很多网站采用

HTTP协议中，四个表示操作方式的动词：GET、POST 、PUT、 DELETE ，它们分别对应四种基本操作：GET用来获取资源，PSOT用来新建资源，PUT用来更新资源，DELETE用来删除资源

实例

传统方式

getBook?id=1 GET

delete?id=1 GET

update POST

update POST

说明：传统的Url是通过参数来说明crud的类型，rest是通过get/post/put/delete来说明crud的类型

REST的核心过滤器

当前浏览器只支持post/get请求，因此为了得到put/delete的请求方式需要使用Spring提供的HiddenHttpMethodFilter过滤器进行转换

HiddenHttpMethodFilter：浏览器form表单只支持GET与POST请求，而DELETE、PUT等Method并不支持，Spring添加了一个过滤器，可以将这些请求转换成为标准的HTTP方式，使得支持GET、POST、PUT、DELETE请求

HiddenHttpMethodFilter能对POST请求方式进行转换，因此我们需要特别注意这一点

过滤器需要再web.xml中配置

2.2 代码实现

2.2.1 Controller

package com.leon.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

/**
 * ClassName:BookHandler
 * Package:com.leon.controller
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/14 13:53
 * @Version: 1.0
 */
@RequestMapping("/book")
@Controller
public class BookHandler {

    @RequestMapping(value = "/get/{id}",method = RequestMethod.GET)
    public String getBook(@PathVariable("id") Integer id) {
        System.out.println("要查询的书的id = " + id);
        return "success";
    }

    @PostMapping(value = "/post")
    public String addBook( String name) {
        System.out.println("要添加的书的name = " + name);
        return "success";
    }

    @PutMapping(value = "/put")
    public String updateBook( String name) {
        System.out.println("要修改的书的name = " + name);
        //return "success";
        return "redirect:/book/success";//这个是重定向，会被解析成/springmvc/book/success
    }

    @DeleteMapping(value = "/delete/{id}")
    public String deleteBook(@PathVariable("id") Integer  id) {
        System.out.println("要删除的书的id = " + id);
        //return "success"; 这样会报错，因为浏览器解析不了DElETE请求
        /*
        *  1.  redirect:/book/success 重定向
        *  2.  这个会被视图解析器解析成：/springmvc/book/success 然后返回给浏览器
        * */
        return "redirect:/book/success";//这个是重定向，会被解析成/springmvc/book/success
    }

    @RequestMapping("/success")
    public String success(){

        return "success";
    }

}

2.2.2 web.xml

 <!--配置HiddenHttpMethodFilter
        1.用与将POST请求转换为PUT、DELETE

    -->
    <filter>
        <filter-name>hiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>hiddenHttpMethodFilter</filter-name>
        <!--
            1. /* 表示所有请求都需要经过HiddenHttpMethodFilter过滤器
        -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

2.2.3 ioc文件：applicationcontext_ioc.xml

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

    <!--配置要扫描的包路径-->
    <context:component-scan base-package="com.leon.controller"/>

    <!--配置SpringMVC的视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--配置前缀，是要访问的包-->
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <!--配置后缀，是要访问的文件类型 -->
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!--加入两个常规配置-->
    <!--配置支持SpringMVC的高级功能，比如JSR303校验，映射动态请求-->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!--配置将SpringMVC不能处理的请求，交给Tomcat处理，比如css,js-->
    <mvc:default-servlet-handler/>

</beans>

2.2.4 页面

<%--
  Created by IntelliJ IDEA.
  User: ZGJ
  Author: leon --> ZGJ
  Version: 1.0
  Date: 2024/4/14
  Time: 13:48
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<script type="text/javascript" src="script/jquery-3.7.1.min.js"></script>
<script type="text/javascript">
        $(document).ready(function () {
            //获取id=deleteBook的a标签
            $("#deleteBook").click(function (){
                // 获取href的属性值
                var href = this.href;
                // 设置action属性
                $("#hiddenFrom").attr("action",href);
                // 给隐藏的input进行赋值
                $("#hiddenFrom :hidden").val("DELETE");
                // 提交数据
                $("#hiddenFrom").submit();
                // 取消默认行为
                return false;
            })
        });

</script>
<body>

    <h1>rest风格</h1>

    <h2>rest风格查询一本书[get]</h2>
    <a href="book/get/100">查询一本书</a>

    <h2>rest风格添加一本书[post]</h2>
    <form action="book/post" method="post">
        <input type="text" name="name"><br>
        <input type="submit" value="提交">
    </form>

    <h2>rest风格删除一本书[delete]</h2>
    <a href="book/delete/100" id="deleteBook">删除一本书</a>
    <form action="" method="post" id="hiddenFrom">
        <input type="hidden" name="_method">
    </form>


    <h2>rest风格修改一本书[put]</h2>
    <form action="book/put" method="post">
        <input type="text" name="name"><br>
        <input type="hidden" name="_method" value="PUT">
        <input type="submit" value="提交">
    </form>

</body>
</html>

2.3注意事项和使用细节

HiddenHttpMethodFilter，在将post转成DElETE/PUT请求时，是按_method参数名来读取的，然后再根据对应的值修改成DElETE/PUT请求

如果web项目是运行在Tomcat8及以上，会发现被过滤成DElETE和PUT请求，到达控制器时能顺利执行，但是返回时请求转发（forward）会报405的错误提示：消息JSP只允许GET、POST或HEAD

解决方式1：使用Tomcat7

解决方式2：将请求转发（forward）改为请求重定向(redirect)：重定向到一个Handler，由Handler转发到页面

3. SpringMVC 映射请求数据

3.1 RequestParam获取参数值

3.1.1 代码

/*
   * 1. @RequestParam 表示会接收提交的参数，它有value和required的属性
   * 2. value = "name" 表示提交参数的参数名称为name
   * 3. required = "false" 表示参数可以没有，默认是true，表示必须要有这个参数，如果没有则会报错
   * 4. @RequestParam(value = "name",required = false) 表示请求的参数名可以和形参名称不一样也能获取到请求参数的值，
   *     但是请求参数要和value的名称一样否则会赋值失败
   * */
   @RequestMapping(value = "/test1")
   public String test01(@RequestParam(value = "name",required = false) String userName){

      System.out.println("用户名称==" + userName);

      return "success";
   }

3.2 获取Http请求消息头

3.2.1 代码

 /*
   * 1. 如果想获取请求头的信息可以使用RequestHeader注解
   * 2. value属性值表示你要获取请求头的什么部分的信息，然后赋值给形参
   * */
   @RequestMapping(value = "/test2")
   public String test02(@RequestHeader("Accept-Encoding") String ae,
                        @RequestHeader("Host") String host){

      System.out.println("Accept-Encoding ===>" + ae);
      System.out.println("Host ===>" + host);

         return "success";
   }

3.3 获取JavaBean象

3.3.1 代码

 /*
   *  将提交过来的数据封装成JavaBean对象
   * 1. 方法的形参用对应的类型（JavaBean对象）来指定即可，SpringMVC会自动完成封装
   * 2. 如果使用自动完成封装，要求提交的数据的参数名和对象的属性名保持一致，否则会赋值失败，而对象的属性值则是默认值
   * 3. 如果属性是对象，这里仍然是通过属性名.属性名，例如Master中的【pet】 ,即提交的数据参数名是：pet.id pet.name
   *    这就是级联操作
   * 4. 如果提交的数据的参数名和对象的属性名不匹配，则对象的属性就是默认值
   * */
   @RequestMapping(value = "/test3")
   public String test03(Master master){

      System.out.println(master);

      return "success";
   }

3.4 使用Servlet API

3.4.1 说明

开发中，我们可能需要使用到原生的Servlet API

使用Servlet API ，需要引入servlet-api.jar包

3.4.2 代码

/*
   *  1. 如果想要使用Servlet的API直接在形参列表创建对应的对象
   * */
   @RequestMapping(value = "/test4")
   public String test04(HttpServletRequest request,
                        HttpServletResponse response){

      String name = request.getParameter("name");
      String id = request.getParameter("id");

      System.out.println("name==" + name);

      System.out.println("id==" + id);

      return "success";
   }

3.4.3 使用注意事项

除了HttpServletRequest,HttpServletResponse还可以有其它对象，也可以用这样的形式获取例如：HttpSession,java.security.Principal,InputStream,OutputStream,Reader,Writer

其中一些对象也可以通过HttpServletRequest,HttpServletResponse对象获取，比如Session对象，既可以通过参数传入，也可以通过request.getSession()获取，效果一样，推荐使用参数形式传入，更加简单明了

4. 数据模型

4.1 模型数据处理-数据放入request域中

4.1.1 默认机制放入到request域中

/*
   *  1. SpringMVC 会自动将提交过来的数据封装成JavaBean对象，然后再放入到request域中
   *     并且在request域中的key的值是形参对应的类型(类名)名称首字母小写，value则是对象
   *  2. 也可以理解成SpringMVC会自动的将Model模型，放入到request域中，其key值是其类型(类名)首字母小写
   *  3. 在方法中修改master对象的属性值是会影响到request域中的数据的，因它们公用这一个引用
   * */
   @RequestMapping(value = "/test5")
   public String test05(Master master){



      return "request_view";
   }

4.1.2 通过HttpServletRequest放入request域

/*
   *  1. SpringMVC 会自动将提交过来的数据封装成JavaBean对象，然后再放入到request域中
   *     并且在request域中的key的值是形参对应的类型名称首字母小写，value则是对象
   *  2. 也可以理解成SpringMVC会自动的将Model模型，放入到request域中，其key值是其类型首字母小写
   *  3. 在方法中修改master对象的属性值是会影响到request域中的数据的，因它们公用这一个引用
   * */
   @RequestMapping(value = "/test5")
   public String test05(Master master,HttpServletRequest request){

      try {
         //设置编码
         request.setCharacterEncoding("UTF-8");
      } catch (UnsupportedEncodingException e) {
         throw new RuntimeException(e);
      }
      //保存数据到request中
      request.setAttribute("address","天津");

      //这里修改是会影响到request域中的数据的
      master.setName("丽丽");
      return "request_view";
   }

4.1.3 通过请求的方法参数Map 放入到request域中

/*
    *  1. SpringMVC 会自动将提交过来的数据封装成JavaBean对象，然后再放入到request域中
    *     并且在request域中的key的值是形参对应的类型名称首字母小写，value则是对象
    *  2. 也可以理解成SpringMVC会自动的将Model模型，放入到request域中，其key值是其类型首字母小写
    *  3. 在方法中修改master对象的属性值是会影响到request域中的数据的，因它们公用这一个引用
    * */
   @RequestMapping(value = "/test6")
   public String test06(Master master, Map<String,Object> map){

      //添加数据进map集合中
      /*
      *  原理分析
      *  1. 首先SpringMVC会将封装好的Master对象放入到map集合中
      *  2. 然后再将Map集合中的数据进行遍历，查看收否数据
      *  3. 如果有数据，则会将该数据放入到request域中，如果没有则不进行数据存放
      *  4. 存放方式：map的key对应request域的key,map的value对应request域的value
      * */
      map.put("address","yunnan");
      //如果这样操作则会将request域中的master置空
      //map.put("master",null);

      return "request_view";
   }

4.1.4 通过返回ModelAndView放入到request域中

4.1.4.1 代码

@RequestMapping(value = "/test7")
   public ModelAndView test07(Master master){

      /*
      * 原理分析
      *  1. SpringMVC会将返回的ModelAndView进行扫描判断是否有数据
      *  2. 如果有数据则将数据存放进Request域中，如果没有则不存放
      *  3. 存放的格式是ModelAndView中的attributeName对应Request的key，
      *     attributeValue对应的是request的Value
      *  4. 在默认情况下，如果你的方法返回的是String，其底层最后也是封装成一个ModelAndView对象
      * */

      //创建一个ModelAndView对象
      ModelAndView modelAndView = new ModelAndView();

      //保存数据
      modelAndView.addObject("address","beijing");

      //设置视图，你要跳转的视图
      modelAndView.setViewName("request_view");


      return modelAndView;
   }

4.1.4.2 注意事项

从本质看，请求响应的方法return “xx” ，是返回了一个字符串，其实其本质是返回了一个ModelAndView对象，只是默认被封装起来了

ModelAndView既可以包含Model数据包，也可以包含视图信息

ModelAndView对象的addObject方法可以添加key-val数据，默认在Request域中

ModelAndView对象的setViewName方法可以设置视图名称

4.2 模型数据处理-数据放入Session域中

4.2.1 代码

 @RequestMapping(value = "/test8")
   public String test08(Master master,HttpSession session){

      //将数据放入Session域中
      session.setAttribute("master",master);
      //设置数据
      session.setAttribute("address","jiangxi");

      return "request_view";
   }

4.3 模型数据-@ModelAttribute

4.3.1 基本说明

开发中，有时需要使用某个前置方法（比如prepareXxx()，方法名由程序员定义）给目标方法准备一个模型对象

@ModelAttribute注解可以实现这样的需求

在某个方法上，增加了@ModelAttribute属性后，调用这个类的任何一个方法时，都会先调用这个方法

4.3.2 代码

/*
   *  1. 当Handler的方法被标识@ModelAttribute，就视为一个前置方法，
   *     每当这个类中的其他方法被执行前都会执行这个方法
   *  2. 这个方法类似于AOP中的前置通知
   * */
   @ModelAttribute
   public void prepareModel(){

      System.out.println("===================================prepareModel===================================");

   }

@ModelAttribute最佳实践

修改用户信息（就是经典的使用这种机制的应用）流程如下：

在修改前，在前置方法中从数据库查询出这个用户

在修改方法（目标方法）中，可以使用前置方法从数据库查询的用户

如果表单中对用户的某个属性修改了，则以新的数据为准，如果没有修改，则以数据库的信息为准，比如，用户的某个属性不能修改，就保持原来的值

5. 视图和视图解析器

5.1 基本介绍

在SpringMVC中的目标方法最终返回都是一个视图（有各种视图）

返回的视图都会由一个视图解析器来处理（视图解析器有很多种）

5.2 代码

5.2.1 Handler(Controller)

package com.leon.viewresolver;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * ClassName:GoodsHandler
 * Package:com.leon.viewresolver
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/16 16:08
 * @Version: 1.0
 */
@RequestMapping(value = "/goods")
@Controller
public class GoodsHandler {

    @RequestMapping(value = "/test1")
    public String test01(){

        System.out.println("GoodsHandler===test01()");

        //返回自定以视图，这里需要是自定义视图的Bean的id
        return "goodsView";
    }

}

5.2.2 view视图

package com.leon.viewresolver;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.view.AbstractView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;


/**
 * ClassName:GoodsView
 * Package:com.leon.viewresolver
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/16 16:10
 * @Version: 1.0
 */
@Component
public class GoodsView extends AbstractView {


    @Override
    protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

        System.out.println("自定义的视图······");

        //  跳转页面
        request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);

    }
}

5.2.3 xml文件

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

    <!--配置要扫描的包路径-->
    <context:component-scan base-package="com.leon"/>

    <!--配置SpringMVC的视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--配置前缀，是要访问的包-->
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <!--配置后缀，是要访问的文件类型 -->
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!--加入两个常规配置-->
    <!--配置支持SpringMVC的高级功能，比如JSR303校验，映射动态请求-->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!--配置将SpringMVC不能处理的请求，交给Tomcat处理，比如css,js-->
    <mvc:default-servlet-handler/>

    <!--配置自定视图解析器
        1. 配置自定义视图解析器BeanNameViewResolver
        2. BeanNameViewResolver可以去解析我们自定义的视图
        3. 配置 order属性，表示视图解析器执行的顺序，值越小，优先级越高，
           order属性的默认值是最低优先级，值为Integer.MAX_VALUE

    -->
    <bean class="org.springframework.web.servlet.view.BeanNameViewResolver" >
            <property name="order" value="99"/>
    </bean>

</beans>

5.2.4 自定义视图步骤

自定义视图：创建一个View的Bean，该Bean需要继承自AbstractView，并实现renderMergedOutputModel方法

并把自定义View加入到IOC容器中

自定义视图的视图处理器，使用BeanNameViewResolver，这个视图处理器也需要配置到IOC容器

BeanNameViewResolver的调用优先级需要设置一下，设置order比Integer.MAX_VALUE小的值，以确保其在InternalResourceViewResolver之前被调用

5.2.5 自定义视图解析器执行流程

SpringMVC调用目标方法，返回自定义View在IOC容器中的id

SpringMVC调用BeanNameViewResolver解析视图：从IOC容器中获取，自定义的View的对象（通过目标返回的id值对应的Bean）

SpringMVC调用自定义视图的renderMergedOutputModel方法渲染视图

如果在SpringMVC调用目标方法，返回自定义View在IOC容器中的id，该View不存在，则仍然按照默认的视图处理机制处理

注意：如果默认的视图解析器优先级更高，则不管成功或者失败都不会执行自定义的视图解析器

6. 请求转发或者重定向

6.1 代码

@RequestMapping(value = "/test2")
    public String test02(){

        /*
        * 解析
        *   1. forward关键字，表示请求转发 redirect关键字，表示重定向
        *   2. 注意重定向不能访问WEB-INF，否则会报错
        *   3. return "forward:/WEB-INF/pages/success.jsp" 会被解析成这个URL：
        *      http://localhost:8080/springmvc/WEB-INF/pages/success.jsp
        *   4. redirect:/login.jsp 会被解析成这个URL：http:/localhost:8080/springmvc/login.jsp
        *   5. redirect:/login.jsp 这个可能会和之前学习的路径有冲突，之前学的没有错，是因为SpringMVC将/login.jsp 解析成
        *      /springmvc/login.jsp返回给浏览器
        * */
        //请求转发
        //return "forward:/WEB-INF/pages/success.jsp";
        //会报错，访问不了WEB-INF
        //return "redirect:/WEB-INF/pages/success.jsp";
        //重定向
        return "redirect:/login.jsp";
    }

7. 数据格式化

7.1 基本介绍

在我们提交数据（比如表单时）SpringMVC怎样对提交的数据进行装换和处理的？

基本数据类型可以和字符串之间自动完成装换，比如：

SpringMVC 上下文中内建了很多装换器，可能完成大多数Java类型的转换工作。【相互转换，这里只列出部分】

| 转换 | 装换类 |
| :—————————————: | :—————————-: |
| java.lang.Boolean —> java.lang.String | ObjectToStringConverter |
| java.lang.Character —> java.lang.Number | CharacterToNumberFactory |
| java.lang.Character —> java.lang.String | ObjectToStringConverter |
| java.lang.Enum —> java.lang.String | EnumToStringConverter |
| java.lang.Number —> java.lang.Character | NumberToCharacterConverter |
| java.lang.Number—> java.lang.Number | NumberToNumberConverterFactory |
| java.lang.Number—> java.lang.String | ObjectToStringConverter |
| java.lang.String—> java.lang.Boolean | StringToBooleanConverter |
| java.lang.String—> java.lang.Character | StringToCharacterConverter |
| java.lang.String—> java.lang.Enum | StringToEnumConverterFactory |
| java.lang.String—> java.lang.Number | StringToNumberConverterFactory |
| java.lang.String—> java.lang.Locale | StringToLocalConverter |
| java.lang.String—> java.lang.Properties | StringToPropertiesConverter |
| java.lang.String—> java.lang.UUID | StringToUUIDConverter |
| java.lang.Locale—> java.lang.String | ObjectToStringConverter |
| java.lang.Properties—> java.lang.String | PropertiesToStringConverter |
| java.lang.UUID—> java.lang.String | ObjectToStringConverter |

7.2 基本数据类型和字符串自定转换

7.2.1 Controller

package com.leon.dataconverter;

import com.leon.dataconverter.entity.Monster;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.Map;

/**
 * ClassName:MonsterHandler
 * Package:com.leon.dataconverter
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/26 9:43
 * @Version: 1.0
 */
/*
 * @Scope(value = "prototype") 表示每次请求MonsterHandler时都会生成一个新的对象
 * */
@RequestMapping(value = "monsterConversion")
@Controller
@Scope(value = "prototype")
public class MonsterHandler {

    @RequestMapping(value = "/add")
    //显示添加monster的界面
    public String addMonsterUI(Map<String, Object> map) {

        /*
         *  解读
         *     1. 这里的表单，我们使用SpringMVC的标签来完成
         *     2.SpringMVC 表单标签在显示之前必须在request域中有一个bean，该bean的属性要和表单标签的path对应
         *       request中的key对应form标签的modelAttribute属性值，例如monster。
         *       解读：意思是，如果在request域中存放Monster对象，Monster对象在request域中对应的key值，要和modelAttribute
         *            的属性值一样，也就是保持对应，并且其属性名称要和form标签中的path属性值一样
         * */
        map.put("monster", new Monster());

        /*
         * 1. 如果跳转的页面使用了SpringMVC的form标签，就需要准备一个对象，放入request域中，这个对象的key值monster对应的
         *    是SpringMVC表单标签的modelAttribute="monster"
         * */
        return "dataconverter/monster_addUI";
    }

    @RequestMapping(value = "/save")
    public String saveMonster(Monster monster) {

        System.out.println("==================Monster================== ："+monster);

        return "dataconverter/add_success";
    }


}

7.2.2 entity

package com.leon.dataconverter.entity;

import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.format.annotation.NumberFormat;

import java.util.Date;

/**
 * ClassName:Monster
 * Package:com.leon.dataconverter.entity
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/26 9:22
 * @Version: 1.0
 */
public class Monster {

    private String id;

    private String name;

    private Integer age ;

    private String email ;

    //特殊格式的装换
    /*
     *   1.使用NumberFormat注解进行格式转换，pattern值是格式要求，如果没有满足要求就会报错
     *
     * */
    @NumberFormat(pattern = "##,###.##")
    private float salary ;

    //特殊格式的装换
    /*
    *   1.使用DateTimeFormat注解进行格式转换，pattern值是格式要求，如果没有满足要求就会报错
    *
    * */
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;

    public Monster() {
    }

    public Monster(String id, String name, Integer age, String email, float salary, Date birthday) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.email = email;
        this.salary = salary;
        this.birthday = birthday;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getEmail() {
        return email;
    }

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

    public Float getSalary() {
        return salary;
    }

    public void setSalary(float salary) {
        this.salary = salary;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                ", salary=" + salary +
                ", birthday='" + birthday + '\'' +
                '}';
    }
}

7.2.3 前端主页面

<%@ taglib prefix="from" uri="http://www.springframework.org/tags/form" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%--
  Created by IntelliJ IDEA.
  User: ZGJ
  Author: leon --> ZGJ
  Version: 1.0
  Date: 2024/4/26
  Time: 9:31
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%--
        为了方便回显这里使用，SpringMVC的标签来完成
            1. SpringMVC 表单标签在显示之前必须在request域中有一个bean，该bean的属性要和表单标签的path对应
            2. SpringMVC 的 form:form 标签的action 属性值中的第一个 / 代表WEB应用的根目录
    --%>
    <h3>添加妖怪</h3>
    <from:form action="save" method="post" modelAttribute="monster">
        妖怪名字：<form:input path="name"/><br><br>
        妖怪年龄：<from:input path="age"/><br><br>
        妖怪生日：<from:input path="birthday"/><br><br>
        妖怪工资：<from:input path="salary"/><br><br>
        电子邮件：<from:input path="email"/><br><br>
        <input type="submit" value="添加妖怪">
    </from:form>
</body>
</html>

7.2.4 测试图片

7.3 特殊数据类型和字符串间的装换

特殊格式的转换需要使用注解，这里使用了【@NumberFormat(pattern = “##,###.##“)】和【@DateTimeFormat(pattern = “yyyy-MM-dd”)】等

这些注解需要标注到要转换的JavaBean的属性上面，pattern的属性值是要转换的格式，如果没有按照指定的格式传输数据会报错

格式转换的注解只负责格式的转换，并不负责验证不要搞混了

注意：被标注的属性是被最终转换成的类型，所以要转换的类型要和注解所转换的类型匹配，否则会失效

7.3.1 代码同基本数据类型的转换一样，只不过是在指定的属性上添加了注解

//特殊格式的装换
    /*
     *   1.使用NumberFormat注解进行格式转换，pattern值是格式要求，如果没有满足要求就会报错
     *
     * */
    @NumberFormat(pattern = "##,###.##")
    private float salary ;

    //特殊格式的装换
    /*
    *   1.使用DateTimeFormat注解进行格式转换，pattern值是格式要求，如果没有满足要求就会报错
    *
    * */
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;

7.3.1 测试图片

8. 验证以及国际化

3.1 概述

对于输入的数据（比如表单数据），进行必要的验证，并给出相应的提示信息

对于验证表单数据，SpringMVC提供了很多实用的注解，这些注解由JSR 303验证框架提供

JSR 303 验证框架

JSR 303 是Java为Bean数据合法性校验提供的标准框架，它已经包含在JavaEE中

JSR 303 通过在Bean属性上标注类似于@NotNull、@Max 等标准的注解指定校验规则，并通过标准的验证接口对Bean进行验证

JSR 303 提供的基本验证注解有：

| 注解 | 功能说明 |
| ————————- | ———————————————————— |
| @Null | 被注解的元素必须为null |
| @NotNull | 被注释的元素必须不为null |
| @AssertTrue | 被注释的元素必须为true |
| @AssertFalse | 被注释的元素必须为false |
| @Min(value) | 被注释的元素必须是一个数字，其值必须大于等于指定的最小值 |
| @Max(value) | 被注释的元素必须是一个数字，其值必须小于等于指定的最大值 |
| @DecimalMin(value) | 被注释的元素必须是一个数字（小数），其值必须大于等于指定的最小值 |
| @DecimalMin(value) | 被注释的元素必须是一个数字（小数），其值必须小于等于指定的最大值 |
| @Size(max,min) | 被注释的元素的大小必须在指定的范围内 |
| @Digits(integer,fraction) | 被注释的元素必须是一个数字，其值必须在可接受的范围内 |
| @Past | 被注释的元素必须是一个过去的日期 |
| @Future | 被注释的元素必须是一个将来的日期 |
| @Pattern(value) | 被注释的元素必须符合指定的正则表达式 |

Hibernate Validator扩展注解

Hibernate Validator 和Hibernate没有关系，只是JSR 303 实现的一个扩展

Hibernate Validator 是JSR 303 的一个参考实现，除了支持所有的标注校验注解外，它还支持以下的扩展注解

| 注解 | 功能说明 |
| ——— | ———————————————————— |
| @Email | 被注释的元素必须是电子邮箱地址 |
| @Length | 被注释的字符串的大小必须在指定的范围内（也就是长度） |
| @NotEmpty | 被注释的字符串必须是非空（还可以修饰其他的元素，详细看NotEmpty类） |
| @Range | 被注释的元素必须在合适的范围内 |

3.2 数据验证

需要在目标JavaBean的属性上标注验证的注解，然后在处理器的目标方法的形参列表中，在目标JavaBean的前面标注一个@Valid，Springmvc底层会自动处理和验证

每一个验证注解都有自己的一个message()属性，这个是用来发生错误时的提示信息，它们有默认的值，可以自己定义的错误验证信息

注解之间可以搭配使用

3.3 国际化

需要在IOC配置文件中配置一个bean，这个类的名字是：org.springframework.context.support.ResourceBundleMessageSource还需要配置一个basename属性，属性值是你配置在src下的properties文件的名称，一般定义为：i18nxxxx.properties
特别注意配置文件中的属性命名要求，验证类.request域中的key值.属性名称，例如：NotEmpty.monster.name，注意要是Unicode编码格式，完整的样式是
#用户名不能为空
NotEmpty.monster.name= \u7528\u6237\u540d\u4e0d\u80fd\u4e3a\u7a7a

3.4 代码

/*
    * 1. @Valid Monster monster 表示对monster接收的数据进行校验
    * 2. Errors errors 表示如果校验出现错误，将校验的错误信息保存errors
    * 3. Map<String,Object> map 表示如果校验出现错误，将校验的错误信息保存map同时保存monster对象
    * 4. 校验发生的时机：在Springmvc底层，反射调用目标方法时，会接收到Http请求的数据，然后根据注解来进行验证，
    *    在验证过程中，如果出现了错误，就把错误信息填充errors和map。
    * */
   @RequestMapping(value = "/validate")
   public String validateMonster(@Valid Monster monster , Errors errors,Map<String, Object> map) {

      System.out.println("-------Monster：" + monster);

      System.out.println("==============================map==============================");

      //遍历集合
      for (Map.Entry<String, Object> entry : map.entrySet()) {

         System.out.println(entry.getKey() + ":" + entry.getValue());

      }

      System.out.println("==============================Error==============================");

      //获取所有的错误信息
      List<ObjectError> allErrors = errors.getAllErrors();

      //遍历错误信息
      for (ObjectError allError : allErrors) {

         System.out.println(allError);

      }

      return "dataconverter/monster_addUI";
   }
======================================================================================

 <!--配置国际化错误信息的资源处理bean-->
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">

        <!--
            配置国际化文件名字
            1. 如果这样配置，表示messageSource去src/i18nxxxx.properties去读取错误信息
        -->
        <property name="basename" value="i18n"/>

    </bean>
======================================================================================
#用户名不能为空
NotEmpty.monster.name= \u7528\u6237\u540d\u4e0d\u80fd\u4e3a\u7a7a
#请输入正确的范围
Range.monster.age= \u8bf7\u8f93\u5165\u6b63\u786e\u7684\u8303\u56f4
#请输入正确的生日格式
typeMismatch.monster.birthday= \u8bf7\u8f93\u5165\u6b63\u786e\u7684\u751f\u65e5\u683c\u5f0f
#请输入正确的薪资
typeMismatch.monster.salary= \u8bf7\u8f93\u5165\u6b63\u786e\u7684\u85aa\u8d44

3.5 数据验证和国际化细节

在需要验证的JavaBean/pojo的字段加上相应的验证注解

目标方法上，在JavaBean/pojo类型的参数前，添加@Valid注解，告知Springmvc该bean是需要验证的

在@Valid 注解之后，添加一个Errors或BindingResult类型的参数，可以获取到错误信息

需要使用标签来显示错误消息，这个标签，需要写在标签内生效

错误消息的国际化文件i18n.properties，中文需要是Unicode编码，使用工具转码

格式：验证规则.表单modelAttribute值.属性名=消息

NotEmpty.monster.name=\u7528\u6237\u540d\u4e0d\u80fd\u4e3a\u7a7a

typeMismatch.monster.birthday= \u8bf7\u8f93\u5165\u6b63\u786e\u7684\u751f\u65e5\u683c\u5f0f

注解@NotNull和@NotEmpty的区别说明

查看源码可以知道：@NotEmpty {Asserts that the annotated string, collection, map or array is not null or empty.}

查看源码可以知道：@NotNull {The annotated element must not be null. Accepts any type.}

有的时候验证注解会组合使用，因为它们功能单一，组合起来效果更好

3.6 数据类型转换校验核心类

SpringMVC通过反射机制对目标方法进行解析，将请求消息绑定到处理方法的入参中。数据绑定的核心部件是DataBinder，运行机制如下

3.7 取消属性绑定

3.7.1 说明

在默认情况下，表单提交的数据会和pojo类型的JavaBean属性绑定，如果程序员在开发中，希望取消某个属性绑定，也就是说，不希望接收到某个表单属性的值，则可以通过@InitBinder注解取消绑定

编写一个方法，使用@InitBinder标识的该方法，可以对WebDataBinder对象进行初始化

WebDataBinder是DataBinder的子类，用于完成由表单字段到JavaBean属性的绑定

@InitBinder方法不能有返回值，它必须声明为void

@InitBinder方法的参数通常是WebDataBinder

3.7.2 代码

//取消绑定Monster的name表单提交的值给monster.name属性
   @InitBinder
   public void initBinder(WebDataBinder binder) {
      /*
      * 1. 方法上需要标注@InitBinder springmvc底层会初始化这个方法的形参WebDataBinder
      * 2. 调用WebDataBinder.setDisallowedFields("name")表示取消指定属性的绑定
      *     即：当表单提交字段name时，就不在把接收到的name值，填充到model数据monster的name属性
      * 3. 机制：Springmvc在底层通过反射调用目标方法时。接收到Http请求的参数和值，使用反射+注解技术
      *     取消对指定属性的填充
      * 4. setDisallowedFields支持可变参数，可以填写多个字段
      * 5. 如果我们取消某个属性绑定，验证就没有意义了，应当把验证的注解去掉
      * */

      binder.setDisallowedFields("name");



   }

3.7.3 注意事项和细节说明

setDisallowedFields() 是可变形参，可以指定多个字段

当将一个字段/属性，设置为disallowed，就不在接收表单提交的值，那么这字段/属性的值，就是该对象默认的值（具体看程序员定义时指定）

一般来说，如果不接收表单字段提交数据，则该对象字段的验证也就没有意义了可以注销掉

9.中文乱码处理

9.1 自定义中文乱码过滤器

9.1.1 代码

package com.leon.filter;


import javax.servlet.*;
import java.io.IOException;

/**
 * ClassName:MyCharacterFilter
 * Package:com.leon.filter
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/27 10:28
 * @Version: 1.0
 */
public class MyCharacterFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //设置编码
        servletRequest.setCharacterEncoding("UTF-8");
        //放行
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {

    }
}
======================================================================================

  <!--
        配置处理中文乱码的过滤器
           1.拦截所有请求，处理编码，提醒：如果是比较重要的过滤器，要配置在web.xml前面
    -->
    <filter>
        <filter-name>MyCharacterFilter</filter-name>
        <filter-class>com.leon.filter.MyCharacterFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>MyCharacterFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>1

9.2 Spring提供的过滤器处理中文

9.2.1 代码

<!--配置Spring提供的过滤器，解决中文乱码-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <!--配置要过滤成什么编码-->
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

11. 处理json和HttpMessageConverter< T>

11.1 处理JSON-@ResponseBody

需要在目标方法上标注注解@ResponseBody，表示这个方法返回的数据是以json的格式返回的

底层通过反射+io等来实现的，要注意这个注解只是将方法返回的数据以json格式返回，而不是把请求过来的数据封装成JavaBean或者json数据

返回的数据可以是集合

@ResponseBody可以修饰Handler类，@Controller和@ResponseBody可以组合成@RestController，这个是注解包含这个两个注解的功能

11.1.1 代码

package com.leon.json;

import com.leon.json.entity.Dog;
import com.leon.json.entity.User;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * ClassName:JsonHandler
 * Package:com.leon.json
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/27 13:50
 * @Version: 1.0
 */
@RequestMapping(value = "/json")
//@Controller
//@ResponseBody
@RestController
public class JsonHandler {


    /*
    * 1. @ResponseBody注解表示返回的数据是以json的格式
    *
    * */
    @RequestMapping(value = "/dog")
    //@ResponseBody
    public Dog jsonDog(){
        Dog dog = new Dog();

        dog.setName("大黄");
        dog.setAddress("小明家");
        return  dog ;

    }
}
======================================================================================
<%--
  Created by IntelliJ IDEA.
  User: ZGJ
  Author: leon --> ZGJ
  Version: 1.0
  Date: 2024/4/27
  Time: 13:45
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<script type="application/javascript" src="script/jquery-3.7.1.min.js"></script>
<script type="application/javascript">
    $(document).ready(function () {
        $("#requestJson").click(function () {

            // 获取href元素值
            var url = this.href;

            // 为了每次都是新的请求，这里返回时间数据
            var data = new Date();

            $.ajax({
                url:url,
                type:"POST",
                data:data,
                success:function (data) {
                    console.log(data);
                },
                dataType:"json"
            })

            // 取消默认行为
            return false ;

        });

        $("#submitJson").click(function () {

            //创建一个Url
            let url ="/springmvc/json/user";
            //获取用户
            let name = $("#name").val();
            //获取年龄
            let age = $("#age").val();

            let data =JSON.stringify( {name:name,age:age});

            $.ajax({
                url:url,
                type: "POST",
                data:data,
                success:function (data) {
                    console.log(data);
                },
                // 设置返回的数据格式
                contentType:"application/json;charset=utf-8"

            });

        });
    })
</script>
<body>
<h1>请求一个json数据</h1>
<a href="<%=request.getContextPath()%>/json/dog" id="requestJson">点击获取JSON数据</a>

<h1>发出一个json数据</h1>
   u:<input type="text" id="name" name="username"><br><br>
   a:<input type="text" id="age" name="age"><br><br>
    <button id="submitJson">提交</button>
</body>
</html>

11.2 处理JSON-@RequestBody

需要标注在目标方法的形参中，要被封装成的目标bean形参之前，表示将请求过来的json数据封装成指定的JavaBean

底层是通过反射+io等实现的，需要注意这个注解只是将请求过来的数据封装成指定的对象类型，而不是把请求过来的数据封装成json格式数据。

封装的数据可以是集合

注意：被封装的对象的属性要和json中的key值对应，否则会封装失败

11.2.1 代码

package com.leon.json;

import com.leon.json.entity.Dog;
import com.leon.json.entity.User;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * ClassName:JsonHandler
 * Package:com.leon.json
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/27 13:50
 * @Version: 1.0
 */
@RequestMapping(value = "/json")
//@Controller
//@ResponseBody
@RestController
public class JsonHandler {


    /*
    * 1. @ResponseBody注解表示返回的数据是以json的格式
    *
    * */
    @RequestMapping(value = "/dog")
    //@ResponseBody
    public Dog jsonDog(){
        Dog dog = new Dog();

        dog.setName("大黄");
        dog.setAddress("小明家");
        return  dog ;

    }

    /*
    * 1.@RequestBody表示将请求的过来的json格式的数据封装成一个UserJavaBean
    * */
    @RequestMapping(value = "/user")
    //@ResponseBody
    public List<User> jsonUser(@RequestBody List<User> users){

        System.out.println("user:===>" + users);

        return users;
    }
}
======================================================================================
<%--
  Created by IntelliJ IDEA.
  User: ZGJ
  Author: leon --> ZGJ
  Version: 1.0
  Date: 2024/4/27
  Time: 13:45
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<script type="application/javascript" src="script/jquery-3.7.1.min.js"></script>
<script type="application/javascript">
    $(document).ready(function () {
        $("#requestJson").click(function () {

            // 获取href元素值
            var url = this.href;

            // 为了每次都是新的请求，这里返回时间数据
            var data = new Date();

            $.ajax({
                url:url,
                type:"POST",
                data:data,
                success:function (data) {
                    console.log(data);
                },
                dataType:"json"
            })

            // 取消默认行为
            return false ;

        });

        $("#submitJson").click(function () {

            //创建一个Url
            let url ="/springmvc/json/user";
            //获取用户
            let name = $("#name").val();
            //获取年龄
            let age = $("#age").val();

            let data =JSON.stringify( {name:name,age:age});

            $.ajax({
                url:url,
                type: "POST",
                data:data,
                success:function (data) {
                    console.log(data);
                },
                // 设置返回的数据格式
                contentType:"application/json;charset=utf-8"

            });

        });
    })
</script>
<body>
<h1>请求一个json数据</h1>
<a href="<%=request.getContextPath()%>/json/dog" id="requestJson">点击获取JSON数据</a>

<h1>发出一个json数据</h1>
   u:<input type="text" id="name" name="username"><br><br>
   a:<input type="text" id="age" name="age"><br><br>
    <button id="submitJson">提交</button>
</body>
</html>

11.3 HttpMessageConverter机制介绍

11.3.1 基本说明

SpringMVC处理JSON底层实现是依靠HttpMessageConverter< T>进行转换的

工作机制图

处理JSON-底层实现（HttpMessageConverter< T>）

使用HttpMessageConverter< T>将请求信息转化并绑定到处理方法的入参中，或将响应结果转为对应类型的响应信息，Spring提供了两种途径

使用@ResponseBody/@RequestBody对目标方法进行标注

使用HttpEntity< T>/ResponseEntity< T>作为目标方法的入参或返回值

当控制器处理方法使用到@RequestBody/@ResponseBody或HttpEntity< T>/ResponseEntity< T>时，Spring首先根据请求头或者响应头的Accept属性选择匹配的HttpMessageConverter，进而根据参数类型或者泛型类型的过滤得到匹配的HttpMessageConverter，若找不到可用的HttpMessageConverter将报错

12.文件的下载

12.1 基本说明

需要把目标方法的返回值设置成ResponseEntity< T>，这样是告诉SpringMVC你返回的是一个文件

创建ResponseEntity类需要三个参数分别是：① Http的响应头Headers ②Http响应状态 ③下载的文件数据

方法的形参可以设置一个HttpSession方便获取文件的绝对路径

建议将泛型设置成byte类型，因为可以读成二进制文件，更方便

12.2 代码

@RequestMapping(value = "downFile")
    public ResponseEntity<byte[]> downFile(HttpSession session){

        //构建一个ResponseEntity 对象 需要： 1. Http的响应头Headers 2.Http响应状态 3. 下载的文件数据

        //获取要下载的文件的绝对路径
        InputStream resourceAsStream = session.getServletContext().getResourceAsStream("/img/background.jpg");

        try {
            //创建一个byte数组,resourceAsStream.available()表示获取文件的大小
            byte[] bytes = new byte[resourceAsStream.available()];

            //读取资源
           resourceAsStream.read(bytes);

            //创建返回的HttpStatus
            HttpStatus ok = HttpStatus.OK;

            //创建需要的Headers
            HttpHeaders headers = new HttpHeaders();
            //设置如何处理响应的内容
            headers.add("Content-Disposition",
                    "attachment;filename=background.jpg");
            //创建ResponseEntity
            /*
            * public ResponseEntity(@Nullable T body,
            * @Nullable MultiValueMap<String, String> headers, HttpStatus status) {} 需要的构造器参数
             * */
            ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes,headers,ok);

            //返回数据
            return responseEntity;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }


    }

13.文件的上传

13.1 基本介绍

SpringMVC为文件上传提供了直接的支持，这种支持是通过即插即用的MultipartResolver实现的，Spring用Jakarta Commons FileUpload技术实现了一个MultipartResolver实现类：CommonsMultipartResolver

SpringMVC上下文中默认没有装配MultipartResolver，因此默认情况下不能处理文件的上传工作，如果想使用Spring的文件上传功能，需要在上下文中配置MultipartResolver

13.2 代码

package com.leon.fileUpload;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;

/**
 * ClassName:FileUploadHandler
 * Package:com.leon.fileUpload
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/5/3 19:53
 * @Version: 1.0
 */
@Controller
@RequestMapping(value = "/file")
public class FileUploadHandler {


    @RequestMapping(value = "/upload")
    public String handleFileUpload(MultipartFile file,
                                   HttpServletRequest request) {

        //获取文件名
        String filename = file.getOriginalFilename();

        System.out.println("你上传的文件名称" + filename);


        //获取保存的绝对路径
        String path = request.getServletContext().getRealPath("/img/" + filename);


        //创建文件
        File saveToFile = new File(path);

        //将上传的文件，转存到saveToFile
        try {
            file.transferTo(saveToFile);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }


        return "success";
    }

}
======================================================================================
<%--
  Created by IntelliJ IDEA.
  User: ZGJ
  Author: leon --> ZGJ
  Version: 1.0
  Date: 2024/5/3
  Time: 19:46
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>文件上传</title>
</head>
<body>
    <h1>文件上传演示</h1>
    <form action="<%=request.getContextPath()%>/file/upload" method="post" enctype="multipart/form-data">
       文件介绍：<input type="text" name="introduce"><br>
       选择文件：<input type="file" name="file"><br>
        <input type="submit" value="提交">

    </form>






</body>
</html>

=====================================================================================
<!--配置SpringMVC的文件上传解析器
        1. 这个bean的id是通过MultipartResolver这个接口来获取的，所以id名必须设置成multipartResolver
    -->
    <bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver" id="multipartResolver"/>

13.3 注意事项

在配置CommonsMultipartResolver时要注意一个问题，因为SpringMVC是通过MultipartResolver接口来获取CommonsMultipartResolver的，所以id的名称必须是multipartResolver否则会报错

在Controller类中的文件上传方法中，MultipartFile 这个形参是一定要的，它的实现接口子类封装了文件上传的方法，这个形参的名称要和请求参数的file的类型的名称一样，否则会上传失败，也可以使用RequestParam注解来指定

注意在form表单中要设置为POST请求，因为POST请求对数据大小理论上没有限制，数据格式也要设置成enctype=“multipart/form-data”

14. 自定义拦截器

14.1 自定义单个拦截器

14.1.1 说明

SpringMVC也可以使用拦截器对请求进行拦截处理，用户可以自定义拦截器来实现特定的功能

自定义的拦截器必须实现HandlerIntercepior接口

自定义拦截器的三个方法

preHandler()：这个方法在业务处理器处理请求之前被调用，在该方法中对用户请求request进行处理

psotHandler()：这个方法在目标方法处理完请求之后执行

afterCompletion()：这个方法在完全处理完请求后被调用，可以在该方法中进行一些资源清理的操作

14.1.2 自定义拦截器流程分析

自定义拦截器执行流程

自定义拦截器执行流程说明

如果preHandle 方法，返回false，则不再执行目标方法，可以在此指定返回页面

postHandle在目标方法被执行后执行，可以在方法中访问到目标方法返回的ModelAndView对象

若preHandle返回true，则afterCompletion 方法，在渲染视图之后被执行

若preHandle返回false，则afterCompletion 方法，不会被嗲用

配置拦截器时，可以指定该拦截器对那些请求生效，哪些请求不生效

14.1.3 代码

package com.leon.interceptor;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * ClassName:FurnHandler
 * Package:com.leon.interceptor
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/5/3 21:23
 * @Version: 1.0
 */
@Controller
@RequestMapping(value = "/furn")
public class FurnHandler {

    @RequestMapping(value = "/hi")
    public String hi() {

        System.out.println("====================FurnHandler[hi()]===================");

        return "success";
    }

    @RequestMapping(value = "/hello")
    public String holle() {

        System.out.println("====================FurnHandler[holle()]===================");

        return "success";
    }

}
======================================================================================
package com.leon.interceptor;

import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * ClassName:MyInterceptor01
 * Package:com.leon.interceptor
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/5/3 21:10
 * @Version: 1.0
 */
@Controller
public class MyInterceptor01 implements HandlerInterceptor {

    /*
    * 1. 该方法在执行目标方法之前被执行
    * 2. 如果该方法返回为false，则不会在执行目标方法
    * 3. 该方法可以获取到request，Response，目标Handler
    * 4. 这里可以根据业务要求跳转到指定的页面
    * */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("MyInterceptor01 ==================preHandle()==================");

        return true;
    }

    /*
    * 1. 该方法在执行目标方法之后被执行
    * 2. 该目标方法可以获取到目标方法返回的ModelAndView对象，也可以获取到目标Handler
    * */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor01 ==================postHandle()==================");
    }

    /*
    * 1.该方法在执行完DispatcherServlet的render方法之后被执行
    **/
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor01 ==================afterCompletion()==================");
    }
}
======================================================================================
<!--配置拦截器-->
    <mvc:interceptors>

        <!--
            1. 第一种配置方式：直接使用ref，引用对应的拦截器
            2. 这种方式会拦截所有的目标方法
        -->
        <!--<ref bean="myInterceptor01"/>-->


        <!--
            1.第二种配置方式
              mvc:mapping path="/hi" 指定要拦截的路径
              通过ref来指定自定义拦截器
        -->
        <!--<mvc:interceptor>-->
        <!--    <mvc:mapping path="/furn/hi"/>-->
        <!--    <ref bean="myInterceptor01"/>-->
        <!--</mvc:interceptor>-->

        <!--
            1.第二种配置方式：可以使用通配符来进行路径拦截
                mvc:mapping path="/furn/h*" 表示要拦截的路径
                mvc:exclude-mapping path="/furn/hi" 表示要排除哪个路径，可以使用通配符
                通过ref来指定自定义拦截器
        -->
        <mvc:interceptor>
            <mvc:mapping path="/furn/h*"/>
            <mvc:exclude-mapping path="/furn/h?"/>
            <ref bean="myInterceptor01"/>
        </mvc:interceptor>
    </mvc:interceptors>

14.1.4 注意事项和细节

默认配置是所有的目标方法都进行拦截，也可以指定拦截目标方法，比如只是拦截hi

      <mvc:interceptor>
          <mvc:mapping path="/furn/hi"/>
          <ref bean="myInterceptor01"/>
      </mvc:interceptor>
mvc:mapping 支持通配符，同时可以指定不对哪些目标方法进行拦截

      <mvc:interceptor>
          <mvc:mapping path="/furn/h*"/>
          <mvc:exclude-mapping path="/furn/h?"/>
          <ref bean="myInterceptor01"/>
      </mvc:interceptor>
拦截器需要配置才生效，不配置是不生效的

如果preHandle()方法返回了false，就不会执行目标方法（前提是目标方法被拦截了），程序员可以在这个方法中根据业务指定需要跳转的页面

14.2 自定义多个拦截器

14.2.1 自定义多个拦截器执行流程

14.2.2 代码

package com.leon.interceptor;

import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * ClassName:MyInterceptor01
 * Package:com.leon.interceptor
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/5/3 21:10
 * @Version: 1.0
 */
@Controller
public class MyInterceptor01 implements HandlerInterceptor {

    /*
    * 1. 该方法在执行目标方法之前被执行
    * 2. 如果该方法返回为false，则不会在执行目标方法
    * 3. 该方法可以获取到request，Response，目标Handler
    * 4. 这里可以根据业务要求跳转到指定的页面
    * */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("MyInterceptor01 ==================preHandle()[01]==================");

        return true;
    }

    /*
    * 1. 该方法在执行目标方法之后被执行
    * 2. 该目标方法可以获取到目标方法返回的ModelAndView对象，也可以获取到目标Handler
    * */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor01 ==================postHandle()[01]==================");
    }

    /*
    * 1.该方法在执行完DispatcherServlet的render方法之后被执行
    **/
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor01 ==================afterCompletion()[01]==================");
    }
}

======================================================================================

package com.leon.interceptor;

import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * ClassName:MyInterceptor01
 * Package:com.leon.interceptor
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/5/3 21:10
 * @Version: 1.0
 */
@Controller
public class MyInterceptor02 implements HandlerInterceptor {

    /*
    * 1. 该方法在执行目标方法之前被执行
    * 2. 如果该方法返回为false，则不会在执行目标方法
    * 3. 该方法可以获取到request，Response，目标Handler
    * 4. 这里可以根据业务要求跳转到指定的页面
    * */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("MyInterceptor02 ==================preHandle()[02]==================");

        return true;
    }

    /*
    * 1. 该方法在执行目标方法之后被执行
    * 2. 该目标方法可以获取到目标方法返回的ModelAndView对象，也可以获取到目标Handler
    * */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor02 ==================postHandle()[02]==================");
    }

    /*
    * 1.该方法在执行完DispatcherServlet的render方法之后被执行
    **/
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor02 ==================afterCompletion()[02]==================");
    }
}

======================================================================================
package com.leon.interceptor;

import com.leon.json.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * ClassName:FurnHandler
 * Package:com.leon.interceptor
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/5/3 21:23
 * @Version: 1.0
 */
@Controller
@RequestMapping(value = "/furn")
public class FurnHandler {

    @RequestMapping(value = "/hi")
    public String hi() {

        System.out.println("====================FurnHandler[hi()]===================");

        return "success";
    }

    @RequestMapping(value = "/hello")
    public String holle(User user) {

        System.out.println("====================FurnHandler[holle()]===================");

        return "success";
    }

}


======================================================================================

<!--配置拦截器-->
    <mvc:interceptors>

        <!--
            1. 第一种配置方式：直接使用ref，引用对应的拦截器
            2. 这种方式会拦截所有的目标方法
        -->
        <!--<ref bean="myInterceptor01"/>-->


        <!--
            1.第二种配置方式
              mvc:mapping path="/hi" 指定要拦截的路径
              通过ref来指定自定义拦截器
        -->
        <!--<mvc:interceptor>-->
        <!--    <mvc:mapping path="/furn/hi"/>-->
        <!--    <ref bean="myInterceptor01"/>-->
        <!--</mvc:interceptor>-->

        <!--
            1.第二种配置方式：可以使用通配符来进行路径拦截
                mvc:mapping path="/furn/h*" 表示要拦截的路径
                mvc:exclude-mapping path="/furn/hi" 表示要排除哪个路径，可以使用通配符
                通过ref来指定自定义拦截器
        -->
        <mvc:interceptor>
            <mvc:mapping path="/furn/h*"/>
            <mvc:exclude-mapping path="/furn/h?"/>
            <ref bean="myInterceptor01"/>
        </mvc:interceptor>

        <!--
            配置多个拦截器
        -->
        <mvc:interceptor>
            <mvc:mapping path="/furn/hello"/>
            <ref bean="myInterceptor02"/>
        </mvc:interceptor>
    </mvc:interceptors>

14.2.3 注意事项和使用细节

如果第1个拦截器的preHandle()返回false，后面不执行

如果第2个拦截器的preHandle()返回false，就直接执行第1个拦截器的afterCompletion()方法，如果拦截器更多，规则类似。

说明：前面说的规则，都是目标方法被拦截的

15. 异常处理

15.1 基本介绍

SpringMVC 通过HandlerExceptionResolver处理程序的异常，包括Handler 映射、数据绑定以及目标方法执行时发生的异常

主要处理Handler中用@ExceptionHandler注解标注的定义的方法

ExceptionHandlerMethodResolver内部若找不到@ExceptionHandler注解的话，会找@ControllerAdvice类的@ExceptionHandler注解方法吗，这样就相当于一个全局异常处理器

15.2 局部异常

15.2.1 代码

package com.leon.exception;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;

/**
 * ClassName:MyExceptionHandler
 * Package:com.leon.exception
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/5/4 15:21
 * @Version: 1.0
 */
@Controller
@RequestMapping(value = "/exception")
public class MyExceptionHandler {


    /*
    * 1. localException()用于处理局部异常的方法
    * 2. 这里只处理了ArithmeticException和NullPointerException异常
    * 3. 形参是Exception，SpringMVC会自动的传入生成的异常给Exception，通过Exception形参可以获取到
    *    异常信息
    *
    * */
    @ExceptionHandler({ArithmeticException.class, NullPointerException.class})
    public String localException(Exception e, HttpServletRequest request) {

        System.out.println("异常信息是： " + e.getMessage());

        //将信息保存到request域中
        request.setAttribute("reason", e.getMessage());


        return "forward:/error.jsp";
    }



    @RequestMapping(value ="/test01")
    public String test01(int num){

        int i = 9 / num;

        return "success";
    }



}

15.2.1 注意事项和细节

如果不确定是什么异常可以直接使用Exception类

15.3 全局异常

15.3.1 代码

package com.leon.exception;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import javax.servlet.http.HttpServletRequest;

/**
 * ClassName:MyGlobalException
 * Package:com.leon.exception
 * Description:
 *     1. 被注解@ControllerAdvice标注以后，这个就是一个全局异常类
 * @Author: leon-->ZGJ
 * @Create: 2024/5/4 15:48
 * @Version: 1.0
 */
@ControllerAdvice
public class MyGlobalException {


    /*
    * 1. 全局异常就是不管是哪个Handler抛出异常，都可以捕获
    * 2. 如果不确定会发生什么异常，可以直接写一个Exception异常类，这样所有的异常都会处理
    *
    * */
    @ExceptionHandler({NumberFormatException.class, ClassCastException.class})
    public String globalException(Exception e, HttpServletRequest request){
        System.out.println("全局异常信息是： " + e.getMessage());

        //将信息保存到request域中
        request.setAttribute("reason", e.getMessage());


        return "forward:/error.jsp";
    }




}

15.3.2 注意实现和细节

局部异常的优先级高于全局异常

如果不确定是什么异常可以直接使用Exception类

15.4 自定义异常

15.4.1 代码

package com.leon.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

/**
 * ClassName:AgeException
 * Package:com.leon.exception
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/5/4 16:07
 * @Version: 1.0
 */
@ResponseStatus(reason = "年龄需要1-120之间",value =HttpStatus.BAD_REQUEST)
public class AgeException extends RuntimeException{

    public AgeException() {
    }

    public AgeException(String message) {
        super(message);
    }
}
======================================================================================
@RequestMapping(value = "/test02")
    public String test02() {

        throw new AgeException("年龄必须在1-120之间======");
    }

15.4.2 注意事项和细节

@ResponseStatus(reason = “年龄需要1-120之间”,value =HttpStatus.BAD_REQUEST)，这里的reason的属性值是提供给Tomcat使用的，如果想要在SpringMVC中获取到信息，需要通过构造器（或其他的方式）传入异常信息

15.5 SimpleMappingExceptionResolver

15.5.1 基本说明

如果希望对所有异常进行统一处理，可以使用SimpleMappingExceptionResolver

它将异常类名映射为视图名，即发生异常时使用对应的视图报告异常，需要在IOC容器中配置

注意：在IOC容器中配置的视图名是返回给视图解析器解析的

15.5.2 代码

<!--配置一个统一异常处理器-->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="exceptionMappings">
            <props>
                <prop key="java.lang.ArrayIndexOutOfBoundsException">forward:/arrError.jsp</prop>
                <prop key="java.lang.Exception">forward:/allError.jsp</prop>
            </props>
        </property>

    </bean>

15.6 处理异常优先级

局部异常 > 全局异常 > SimpleMappingExceptionResolver > Tomcat 异常机制

三、手动实现SpringMVC的部分功能

1. controller包

package com.leon.controller;

import com.leon.pojo.Monster;
import com.leon.service.MonsterService;
import com.leon.springmvc_v1.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;

/**
 * ClassName:MonsterController
 * Package:com.leon.controller
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/21 21:13
 * @Version: 1.0
 */
@Controller
@RequestMapping(value = "/monster")
public class MonsterController {

    @Autowired
    private MonsterService monsterService;

    @Autowired
    private OrderController orderController;

    //为了方便使用HttpServletRequest和HttpServletResponse两个形参
    @RequestMapping(value = "/list")
    public void monsterList(HttpServletRequest request,
                            HttpServletResponse response
                           ){


        List<Monster> monsterList = monsterService.monsterList();

        for (Monster monster : monsterList) {
            System.out.println(monster);
        }

        //设置文件类型和字符编码
        response.setContentType("text/html;charset=utf-8");
        //获取输出流
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
        //    输出信息
            writer.write("<h1>妖怪信息列表</h1>");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //刷新数据
            writer.flush();
            //关闭资源
            writer.close();
        }

    }

    @RequestMapping(value = "/select")
    public void monsterSelect(HttpServletRequest request,
                            HttpServletResponse response,
                               String username) {
        System.out.println("username===> " + username);

        //设置文件类型和字符编码
        response.setContentType("text/html;charset=utf-8");
        //获取输出流
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
            //    输出信息
            writer.write("<h1>妖怪信息列表</h1>");

            List<Monster> monsterList = monsterService.selectMonsterByName(username);

            StringBuilder stringBuilder = new StringBuilder();

            stringBuilder.append("<table border='1px' width='400px' style='border-collapse: collapse'>");

            for (Monster monster : monsterList) {

                stringBuilder.append("<tr>\n" +
                        "            <td>"+monster.getId()+"</td>\n" +
                        "            <td>"+monster.getName()+"</td>\n" +
                        "            <td>"+monster.getSkill()+"</td>\n" +
                        "            <td>"+monster.getAge()+"</td>\n" +
                        "        </tr>");

            }

            stringBuilder.append("</table>");

            //遍历
            writer.write(stringBuilder.toString());


        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //刷新数据
            writer.flush();
            //关闭资源
            writer.close();
        }


    }

    @RequestMapping(value = "/login")
    public String monsterLogin( HttpServletRequest request,String username) {

        request.setAttribute("name",username);

        System.out.println(username);

        boolean flag  = monsterService.monsterLogin(username);

        if(flag){

            return "forward:/login_ok.jsp";

        }

        return "forward:/login_error.jsp";

    }

    @RequestMapping(value = "/json")
    @ResponseBody
    public List<Monster> monsterJson(){

        List<Monster> monsterList = monsterService.monsterList();
        System.out.println("monsterJson ==> ");

        return monsterList;

    }

}
======================================================================================

package com.leon.controller;

import com.leon.springmvc_v1.annotation.Controller;
import com.leon.springmvc_v1.annotation.RequestMapping;



import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * ClassName:OrderController
 * Package:com.leon.controller
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 16:13
 * @Version: 1.0
 */
@Controller
@RequestMapping(value = "/order")
public class OrderController {

    @RequestMapping(value = "/list")
    public void orderList(HttpServletRequest request, HttpServletResponse response){

        //设置文件类型和字符编码
        response.setContentType("text/html;charset=utf-8");
        //获取输出流
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
            //    输出信息
            writer.write("<h1>订单信息列表</h1>");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //刷新数据
            writer.flush();
            //关闭资源
            writer.close();
        }

    }

    @RequestMapping(value = "/add")
    public void orderAdd(HttpServletRequest request, HttpServletResponse response){

        //设置文件类型和字符编码
        response.setContentType("text/html;charset=utf-8");
        //获取输出流
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
            //    输出信息
            writer.write("<h1>添加订单·····</h1>");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //刷新数据
            writer.flush();
            //关闭资源
            writer.close();
        }

    }


}

2. pojo包

package com.leon.pojo;

/**
 * ClassName:Monster
 * Package:com.leon.pojo
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 17:01
 * @Version: 1.0
 */
public class Monster {

    private String id ;

    private String name ;

    private String skill ;

    private Integer age ;


    public Monster() {
    }

    public Monster(String id, String name, String skill, Integer age) {
        this.id = id;
        this.name = name;
        this.skill = skill;
        this.age = age;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", skill='" + skill + '\'' +
                ", age=" + age +
                '}';
    }
}

3. service

package com.leon.service;

import com.leon.pojo.Monster;

import java.util.List;

/**
 * ClassName:MonsterService
 * Package:com.leon.service
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 10:20
 * @Version: 1.0
 */
public interface MonsterService {

    public List<Monster> monsterList();

    public List<Monster> selectMonsterByName(String name);

    public boolean monsterLogin(String name);

}
======================================================================================
package com.leon.service.impl;

import com.leon.pojo.Monster;
import com.leon.service.MonsterService;
import com.leon.springmvc_v1.annotation.Service;

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

/**
 * ClassName:MonsterServiceImpl
 * Package:com.leon.service.impl
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 10:20
 * @Version: 1.0
 */
@Service(value = "monsterServiceImpl")
public class MonsterServiceImpl implements MonsterService {
    @Override
    public List<Monster> monsterList() {

        List<Monster> monsters = new ArrayList<>();

        monsters.add(new Monster("100", "牛魔王", "芭蕉扇", 400));
        monsters.add(new Monster("200", "白骨精", "魅惑", 200));

        return monsters;
    }

    @Override
    public List<Monster> selectMonsterByName(String name) {

        //类似数据库
        List<Monster> monsters = new ArrayList<>();

        monsters.add(new Monster("100", "牛魔王", "芭蕉扇", 400));
        monsters.add(new Monster("200", "白骨精", "魅惑", 200));
        monsters.add(new Monster("300", "黄袍怪", "吹风", 200));
        monsters.add(new Monster("400", "金角大王", "吐金珠", 200));
        monsters.add(new Monster("500", "豹妖", "大铁锤", 200));

        // 查询到的数据
        List<Monster> findMonster = new ArrayList<>();

        //查询
        for (Monster monster : monsters) {

            if (monster.getName().contains(name)) {
                findMonster.add(monster);
            }

        }


        return findMonster;
    }

    @Override
    public boolean monsterLogin(String name) {

        if("白骨精".equals(name)){
            return true ;
        }

        return false;
    }
}

4. springmvc 包

4.1 annotion 包

package com.leon.springmvc_v1.annotation;

import java.lang.annotation.*;

/**
 * ClassName:Autowired
 * Package:com.leon.springmvc.annotation
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 19:27
 * @Version: 1.0
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
}
======================================================================================
package com.leon.springmvc_v1.annotation;

import java.lang.annotation.*;

/**
 * ClassName:Controller
 * Package:com.leon.springmvc.annotation
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/21 21:01
 * @Version: 1.0
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Controller {

    String value() default "";
}
======================================================================================
package com.leon.springmvc_v1.annotation;

import java.lang.annotation.*;

/**
 * ClassName:RequestMapping
 * Package:com.leon.springmvc.annotation
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/21 21:01
 * @Version: 1.0
 */

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestMapping {

    String value() default "";

}
======================================================================================
package com.leon.springmvc_v1.annotation;

import java.lang.annotation.*;

/**
 * ClassName:RequestParam
 * Package:com.leon.springmvc.annotation
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 20:34
 * @Version: 1.0
 */
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {

    String value() default "";

}
======================================================================================
package com.leon.springmvc_v1.annotation;

import java.lang.annotation.*;

/**
 * ClassName:ResponseBody
 * Package:com.leon.springmvc.annotation
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/23 14:20
 * @Version: 1.0
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ResponseBody {
}
======================================================================================
package com.leon.springmvc_v1.annotation;

import java.lang.annotation.*;

/**
 * ClassName:Service
 * Package:com.leon.springmvc.annotation
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 13:13
 * @Version: 1.0
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {

    String value() default "";

}

4.2 context 包

package com.leon.springmvc_v1.context;

import com.leon.springmvc_v1.annotation.Autowired;
import com.leon.springmvc_v1.annotation.Controller;
import com.leon.springmvc_v1.annotation.Service;
import com.leon.springmvc_v1.utils.StringUtils;
import com.leon.springmvc_v1.xml.XMLParser;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ClassName:WebAppliactionContext
 * Package:com.leon.springmvc.context
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 10:06
 * @Version: 1.0
 */
public class WebApplicationContext {

    //用于存放扫描到的类的全路径
    private Map<String, String> classFullPathMap = new HashMap<>();

    //要扫描的XMl
    private String xmlFileName;

    //用于存放对象
    private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();

    public WebApplicationContext() {
    }

    public WebApplicationContext(String parameter) {

        //初始化xmlFileName
        xmlFileName = getFileName(parameter);

        //调用初始化方法
        init();

    }

    public void init() {

        List<String> componentScan = XMLParser.getComponentScan(xmlFileName);

        //判断是否有数据
        if (!componentScan.isEmpty()) {

            //遍历集合中的路径
            for (String packagePath : componentScan) {

                //扫描包
                getClassFilePath(packagePath);

            }

        }

        executeInjectionInstance();

        executeAutoWried();


    }


    //扫描指定包下的所有类文件
    public void getClassFilePath(String packagePath) {

        //获取类加载器获取绝对路径
        ClassLoader classLoader =
                WebApplicationContext.class.getClassLoader();

        //将路径中的"."替换成"/"
        String filePath = packagePath.replace(".", "/");

        //获取真实工作目录的绝对路径
        URL workAbsolutePath = classLoader.getResource(filePath);

        //获取目标目录
        File targetFile = new File(workAbsolutePath.getFile());

        //判断目标文件是否是一个目录
        if (targetFile.isDirectory()) {

            //获取目标目录下的所有子文件或者子目录
            File[] files = targetFile.listFiles();

            //循环遍历
            for (File file : files) {

                //判断是否是目录
                if (file.isDirectory()) {

                    //如果是则使用递归将子目录文件遍历出来
                    getClassFilePath(packagePath + "." + file.getName());

                } else {

                    //获取类名
                    String className = file.getName().split("\\.")[0];
                    //获取路径
                    String classFullPath = packagePath + "." + className;

                    //将路径保存
                    classFullPathMap.put(StringUtils.uncapitalize(className), classFullPath);

                }

            }


        }

    }

    //将classFullPathMap中被标注(Controller,Service)的类注入到IOC容器中
    public void executeInjectionInstance() {

        //判断classFullPathMap是否有数据
        if (classFullPathMap.isEmpty()) {

            return;

        }


        //遍历classFullPathMap
        for (String key : classFullPathMap.keySet()) {

            //获取类的全路径
            String classFullPath = classFullPathMap.get(key);

            try {
                //获取class类
                Class<?> beanClass = Class.forName(classFullPath);

                //判断是否有被标注
                if (beanClass.isAnnotationPresent(Controller.class)
                        || beanClass.isAnnotationPresent(Service.class)) {

                    //获取类名
                    String beanName = key;

                    //获取构造器
                    Constructor<?> declaredConstructor =
                            beanClass.getDeclaredConstructor();

                    //创建对象
                    Object instance = declaredConstructor.newInstance();

                    //判断是否是Controller注解
                    if (beanClass.isAnnotationPresent(Controller.class)) {

                        //获取注解对象
                        Controller controller =
                                beanClass.getDeclaredAnnotation(Controller.class);

                        //获取自己指定的名称
                        String assignName = controller.value();

                        //判断是否是默认值
                        if (!"".equals(assignName)) {

                            //将指定的名称赋值给beanName
                            beanName = assignName;

                        }

                        //将对象存放到IOC容器中
                        singletonObjects.put(beanName, instance);

                    }

                    //判断是否是Controller注解
                    if (beanClass.isAnnotationPresent(Service.class)) {

                        //获取注解对象
                        Service service =
                                beanClass.getDeclaredAnnotation(Service.class);

                        //获取自己指定的名称
                        String assignName = service.value();

                        //判断是否是默认值
                        if (!"".equals(assignName)) {

                            //将对象存放到IOC容器中
                            singletonObjects.put(assignName, instance);

                        } else {
                            //保存一个本身类名映射的对象
                            singletonObjects.put(beanName, instance);
                        }

                        //获取接口信息
                        Class<?>[] interfaces = beanClass.getInterfaces();

                        //遍历接口
                        for (Class<?> interfaceClass : interfaces) {

                            //获取接口名称
                            String interfaceClassSimpleName = interfaceClass.getSimpleName();


                            //保存对象
                            singletonObjects.put(StringUtils.uncapitalize(interfaceClassSimpleName), instance);

                        }

                    }


                }

            } catch (Exception e) {
                e.printStackTrace();
            }

        }


    }

    public ConcurrentHashMap<String, Object> getSingletonObjects() {
        return singletonObjects;
    }

    //这是一个解析构造器传值过来的字符串，解析成一个XMl文件
    public String getFileName(String parameter) {

        //将字符串进行分割
        String fileName = parameter.split(":")[1];

        return fileName;
    }

    public void executeAutoWried(){

        //判断容器中是否有数据
        if(singletonObjects.isEmpty()){

            return;

        }

        //遍历容器
        for (Map.Entry<String, Object> entry : singletonObjects.entrySet()) {

            //获取对象
            Object bean = entry.getValue();

            //获取所有字段
            Field[] fields = bean.getClass().getDeclaredFields();

            //遍历所有字段或者属性
            for (Field field : fields) {

                //判断是否被Autowired标注
                if(field.isAnnotationPresent(Autowired.class)){

                    //获取字段类型
                    Class<?> type = field.getType();

                    //获取字段类型名称
                    String typeSimpleName = type.getSimpleName();

                    //获取目标类型的bean对象
                    Object targetObject = singletonObjects.get(StringUtils.uncapitalize(typeSimpleName));

                    //判断是否为空
                    if(targetObject != null){

                        //允许强制访问
                        field.setAccessible(true);

                        try {

                            //进行赋值
                            field.set(bean,targetObject);

                        } catch (IllegalAccessException e) {
                            throw new RuntimeException(e);
                        }

                    }

                }

            }


        }



    }
}

4.3 mapping 包

package com.leon.springmvc_v1.mapping;

import java.lang.reflect.Method;

/**
 * ClassName:Handler
 * Package:com.leon.springmvc.mapping
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 13:53
 * @Version: 1.0
 */
public class Handler {

    //记录Url
    private String url;

    //记录对应的Controller
    private Object targetObject;

    //记录对应的方法
    private Method targetMethod;


    public Handler() {
    }

    public Handler(String url, Object targetObject, Method targetMethod) {
        this.url = url;
        this.targetObject = targetObject;
        this.targetMethod = targetMethod;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public Object getTargetObject() {
        return targetObject;
    }

    public void setTargetObject(Object targetObject) {
        this.targetObject = targetObject;
    }

    public Method getTargetMethod() {
        return targetMethod;
    }

    public void setTargetMethod(Method targetMethod) {
        this.targetMethod = targetMethod;
    }

    @Override
    public String toString() {
        return "Handler{" +
                "url='" + url + '\'' +
                ", targetObject=" + targetObject +
                ", targetMethod=" + targetMethod +
                '}';
    }

}
======================================================================================
package com.leon.springmvc_v1.mapping;

import com.leon.springmvc_v1.annotation.Controller;
import com.leon.springmvc_v1.annotation.RequestMapping;
import com.leon.springmvc_v1.context.WebApplicationContext;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ClassName:HandlerMapping
 * Package:com.leon.springmvc.mapping
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 13:55
 * @Version: 1.0
 */
public class HandlerMapping {

    //用于存放映射关系的集合
    private ConcurrentHashMap<String,Handler> handlerMap = new ConcurrentHashMap<>();

    private WebApplicationContext ioc;

    public HandlerMapping(WebApplicationContext ioc) {

        //初始化IOC
        this.ioc = ioc ;

        //初始化handlerMap
        initHandlerMapping();


    }



    //初始化handlerMap
    public void initHandlerMapping(){

        //获取IOC
        ConcurrentHashMap<String, Object> singletonObjects = ioc.getSingletonObjects();

        //判断是否为空
        if(singletonObjects.isEmpty()){

            return;

        }

        //循环遍历map
        for (Map.Entry<String, Object> entry : singletonObjects.entrySet()) {

            //获取Value值
            Object entryValue = entry.getValue();

            //获取class对象
            Class<?> valueClass = entryValue.getClass();

            //判断是否有Controller注解
            if(valueClass.isAnnotationPresent(Controller.class)){

                //创建url
                String  classUrl = "";

                //判断是否有RequestMapping注解
                if(valueClass.isAnnotationPresent(RequestMapping.class)){

                    //创建RequestMapping对象
                    RequestMapping requestMapping =
                            valueClass.getDeclaredAnnotation(RequestMapping.class);

                    //获取指定的Url值
                    String assignUrl = requestMapping.value();

                    //判断是否指定了
                    if(!"".equals(assignUrl)){
                        classUrl = assignUrl;
                    }

                }

                //获取所有方法
                Method[] methods = valueClass.getMethods();

                //遍历methods
                for (Method method : methods) {


                    //判断是否有RequestMapping注解
                    if(method.isAnnotationPresent(RequestMapping.class)){

                        //创建RequestMapping对象
                        RequestMapping requestMapping =
                                method.getDeclaredAnnotation(RequestMapping.class);

                        //获取指定的Url
                        String assignUrl = requestMapping.value();

                        //判断是否为空
                        if(!"".equals(assignUrl)){

                            String requestUrl = classUrl + assignUrl;

                            //将映射信息存放到handlerMap
                            handlerMap.put(requestUrl,new Handler(requestUrl,entryValue,method));
                        }



                    }


                }

            }

        }

    }


    //用于返回handler对象
    public Handler getHandler(HttpServletRequest request){

        //判断映射关系的集合是否有数据
        if(handlerMap.isEmpty()){
            return null;
        }

        //获取请求的Url
        String requestUrl = request.getRequestURI();

        //获取项目工程路径
        String contextPath = request.getContextPath();

        //循环遍历handlerMap
        for (Map.Entry<String, Handler> entry : handlerMap.entrySet()) {

            //获取的完整的Url
            String temp  = contextPath + entry.getKey();

            //判断key中是否包含Url
            if(temp.equals(requestUrl)){

                //返回handler
                return entry.getValue();
            }

        }

        return  null;
    }


}

4.4 servlet 包

package com.leon.springmvc_v1.servlet;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.leon.springmvc_v1.annotation.RequestParam;
import com.leon.springmvc_v1.annotation.ResponseBody;
import com.leon.springmvc_v1.context.WebApplicationContext;
import com.leon.springmvc_v1.mapping.Handler;
import com.leon.springmvc_v1.mapping.HandlerMapping;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.List;
import java.util.Map;

/**
 * ClassName:DispatcherServlet
 * Package:com.leon.springmvc.servlet
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/21 21:03
 * @Version: 1.0
 */
public class DispatcherServlet extends HttpServlet {

    //创建IOC容器对象
    private WebApplicationContext ioc;

    //创建映射器对象
    private HandlerMapping handlerMapping;

    @Override
    public void init(ServletConfig config) throws ServletException {

        //获取配置文件中的IOC文件名称
        String parameter = config.getInitParameter("contextConfigLocation");

        //初始化IOC
        ioc = new WebApplicationContext(parameter);

        //初始化HandlerMapping
        handlerMapping = new HandlerMapping(ioc);


    }

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

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

        executeDispatcher(req, resp);

    }

    private void executeDispatcher(HttpServletRequest request, HttpServletResponse response) {

        //获取Handler对象
        Handler handler = handlerMapping.getHandler(request);

        //判断是否存在
        if (null == handler) {

            //设置404状态
            response.setStatus(404);

        } else {

            //获取方法对象
            Method targetMethod = handler.getTargetMethod();

            //获取方法的形参列表
            Class<?>[] parameterTypes = targetMethod.getParameterTypes();

            //设置编码格式
            try {
                request.setCharacterEncoding("utf-8");
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException(e);
            }
            //获取请求参数列表
            /*
             *  1. 这里Value是一个数组，是因为你请求的参数可能是一个多选框或者是一个复选框
             * */
            Map<String, String[]> parameterMap = request.getParameterMap();

            //创建一个记录参数位置的数组
            Object[] parameters = new Object[parameterTypes.length];

            //遍历形参列表
            for (int i = 0; i < parameters.length; i++) {

                //判断是否是指定类型的HttpServletRequest参数
                if (parameterTypes[i].isAssignableFrom(HttpServletRequest.class)) {

                    //赋值给记录数组指定位置
                    parameters[i] = request;

                }
                //判断是否是指定类型的HttpServletResponse参数
                if (parameterTypes[i].isAssignableFrom(HttpServletResponse.class)) {
                    //赋值给记录数组指定位置
                    parameters[i] = response;
                }

            }

            //通过获取请求参数给指定形参赋值
            //遍历parameterMap
            for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {

                //获取key值，也就是请求参数名称
                String requestParamName = entry.getKey();

                //获取Value值，也就是请求参数值，这里默认请求参数只有一个值
                String requestParamValue = entry.getValue()[0];

                //获取匹配的下标
                int index = getRequestParamParameterIndex(targetMethod, requestParamName);

                //判断是否存在
                if (index != -1) {

                    //对参数值数组进行赋值
                    parameters[index] = requestParamValue;

                } else {

                    //默认方式赋值
                    int paramIndex = getDefaultParamIndex(targetMethod, requestParamName);

                    //判断是否存在
                    if (paramIndex != -1) {

                        //对参数进行赋值
                        parameters[paramIndex] = requestParamValue;
                    }

                }

            }


            try {

                //执行方法
                Object invoke = targetMethod.invoke(handler.getTargetObject(), parameters);

                viewParser(invoke, targetMethod ,request, response);

            } catch (Exception e) {
                e.printStackTrace();
            }


        }


    }


    //用于返回方法中形参的指定下标
    public int getRequestParamParameterIndex(Method method, String parameterName) {

        //获取方法的形参
        Parameter[] parameters = method.getParameters();

        //遍历形参
        for (int i = 0; i < parameters.length; i++) {

            //判断是否有RequestParam注解
            if (parameters[i].isAnnotationPresent(RequestParam.class)) {

                //获取RequestParam的Value值
                RequestParam param =
                        parameters[i].getDeclaredAnnotation(RequestParam.class);

                //获取Value值
                String paramName = param.value();

                //判断是否为默认值
                if (!"".equals(paramName)) {

                    //判断是否相同
                    if (paramName.equals(parameterName)) {
                        return i;
                    }

                }


            }

        }


        return -1;
    }

    public int getDefaultParamIndex(Method method, String parameterName) {

        //获取参数列表
        Parameter[] parameters = method.getParameters();

        //循环遍历
        for (int i = 0; i < parameters.length; i++) {

            //获取参数的名称
            String paramName = parameters[i].getName();

            //判断是否相同
            if (paramName.equals(parameterName)) {

                //返回指定下标
                return i;
            }

        }


        return -1;

    }


    //视图解析器方法
    public void viewParser(Object returnResult,Method method, HttpServletRequest request, HttpServletResponse response) {

        try {
            //判断是否是字符串
            if (returnResult instanceof String) {

                // 进行强转
                String result = (String) returnResult;

                //进行判断操作
                if (result.contains(":")) {

                    //进行截取
                    String[] requestModeAndPath = result.split(":");

                    //获取请求方式
                    String mode = requestModeAndPath[0];
                    //获取请求路径
                    String path = requestModeAndPath[1];

                    //判断是否是请求转发
                    if ("forward".equals(mode)) {

                        //请求转发
                        request.getRequestDispatcher(path).forward(request, response);
                    }
                    //判断是否是重定向
                    if ("redirect".equals(mode)) {

                        //重定向
                        response.sendRedirect(request.getContextPath() + path);

                    }

                } else {

                    //默认请求转发
                    request.getRequestDispatcher(result).forward(request, response);
                }

            }
            //判断是否是List集合
            if(returnResult instanceof List){

                //判断该方法是否被ResponseBody所标注
                if(method.isAnnotationPresent(ResponseBody.class)){

                    //获取转换对象
                    ObjectMapper objectMapper = new ObjectMapper();
                    //进行转换
                    String json = objectMapper.writeValueAsString(returnResult);

                    //设置编码格式
                    response.setContentType("text/html;charset=UTF-8");

                    //获取输出流
                    PrintWriter writer = response.getWriter();

                    //输出JSON格式字符串
                    writer.write(json);

                    //进行刷新
                    writer.flush();

                    //关闭资源
                    writer.close();

                }

            }

        } catch (ServletException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }


}

4.5 utils 包

package com.leon.springmvc_v1.utils;

/**
 * ClassName:StringUtils
 * Package:com.leon.springmvc.utils
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/22 9:51
 * @Version: 1.0
 */
public class StringUtils {


    public static String uncapitalize(String convertTarget){

        //获取第一个字符
        String target = convertTarget.charAt(0) + "";
        //转换成首字母小写
        convertTarget = convertTarget.replace(target,target.toLowerCase());

        return convertTarget;
    }

}

4.6 xml 包

package com.leon.springmvc_v1.xml;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;


/**
 * ClassName:XMLParser
 * Package:com.leon.springmvc.xml
 * Description:
 *
 * @Author: leon-->ZGJ
 * @Create: 2024/4/21 17:50
 * @Version: 1.0
 */
public class XMLParser {

    //用于存放要扫描的包
    private static List<String> packegePath = new ArrayList<>();

    public static List<String> getComponentScan(String fileName){
        //创建一个解析器
        SAXReader reader = new SAXReader();
        //获取真实的工作目录的绝对路径，并获取输入流
        InputStream resourceAsStream = XMLParser.class.getClassLoader().getResourceAsStream(fileName);
        try {
            //读取document树
            Document document = reader.read(resourceAsStream);
            //获取根元素
            Element rootElement = document.getRootElement();
            //获取指定元素
            List<Element> elements = rootElement.elements("componentScan");
            //循环遍历
            for (Element element : elements) {
                //获取属性值
                String value = element.attributeValue("base-package");
                //将属性值放入到集合中
                packegePath.add(value);
            }

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return packegePath;
    }

}

5. 配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <componentScan base-package="com.leon.controller"></componentScan>
    <componentScan base-package="com.leon.service"></componentScan>
</beans>

6. web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!--配置前端分发器-->
  <servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>com.leon.springmvc_v1.servlet.DispatcherServlet</servlet-class>
    <!--配置获取IOC文件属性-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!--配置加载顺序-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
<!--配置前端控制器-->
<!--  <servlet>-->
<!--    <servlet-name>DispatcherServlet</servlet-name>-->
<!--    <servlet-class>com.leon.springmvc_V2.servlet.DispatcherServlet</servlet-class>-->
<!--    <init-param>-->
<!--      <param-name>contextConfigLocation</param-name>-->
<!--      <param-value>classpath:springmvc.xml</param-value>-->
<!--    </init-param>-->
<!--    <load-on-startup>1</load-on-startup>-->
<!--  </servlet>-->
<!--  <servlet-mapping>-->
<!--    <servlet-name>DispatcherServlet</servlet-name>-->
<!--    <url-pattern>/</url-pattern>-->
<!--  </servlet-mapping>-->
<!--  -->
</web-app>

Share

SpringMVC框架

SpringMVC框架

一、SpringMVC介绍

1. 官方文档

2. SpringMVC 基本介绍

2.1 SpringMVC特点和概述

2.2 梳理Spring、SpringMVC和SpringBoot的关系

3. 快速入门

3.1 需求说明

3.2 代码实现

3.2.1 Controller包

3.2.2 ioc文件

3.2.3 web.xml文件

3.2.4 jsp文件

3.3 注意事项和使用细节

4. SpringMVC执行流程

二、SpringMVC的使用

1. @RequestMapping 注解

1.1 基本使用

1.1.1 代码

1.2 @RequestMapping 其它使用方式

1.2.1 @RequestMappping 可以修饰方法和类

1.2.1.1 代码

1.2.2 @RequestMapping 可以指定请求方式

1.2.2.1 代码

1.2.3 @RequestMapping可以指定params和headers支持简单表达式

1.2.3.1 代码

1.2.4 @RequestMapping 支持Ant风格资源地址

1.2.4.1 代码

1.2.5 RequestMapping 可配合@PathVariable 映射URL绑定占位符

1.2.5.1 代码

1.2.6 注意事项和使用细节

2. Rest优雅的Url请求风格

2.1 基本介绍

2.2 代码实现

2.2.1 Controller

2.2.2 web.xml

2.2.3 ioc文件：applicationcontext_ioc.xml

2.2.4 页面

2.3注意事项和使用细节

3. SpringMVC 映射请求数据

3.1 RequestParam获取参数值

3.1.1 代码

3.2 获取Http请求消息头

3.2.1 代码

3.3 获取JavaBean象

3.3.1 代码

3.4 使用Servlet API

3.4.1 说明

3.4.2 代码

3.4.3 使用注意事项

4. 数据模型

4.1 模型数据处理-数据放入request域中

4.1.1 默认机制放入到request域中

4.1.2 通过HttpServletRequest放入request域

4.1.3 通过请求的方法参数Map 放入到request域中

4.1.4 通过返回ModelAndView放入到request域中

4.1.4.1 代码

4.1.4.2 注意事项

4.2 模型数据处理-数据放入Session域中

4.2.1 代码

4.3 模型数据-@ModelAttribute

4.3.1 基本说明

4.3.2 代码

@ModelAttribute最佳实践

5. 视图和视图解析器

5.1 基本介绍

5.2 代码

5.2.1 Handler(Controller)

5.2.2 view视图

5.2.3 xml文件

5.2.4 自定义视图步骤

5.2.5 自定义视图解析器执行流程

6. 请求转发或者重定向

6.1 代码

7. 数据格式化

7.1 基本介绍

7.2 基本数据类型和字符串自定转换

7.2.1 Controller