一：SpringMVC注解式开发

1. @RequestMapping定义请求规则

2. 五种数据提交的方式

3. 请求参数中文乱码解决

4. action方法的返回值

5. SpringMVC的四种跳转方式

6. SpringMVC支持的默认参数类型

7. 日期处理

8. 标签的使用

9. 资源在WEB-INF目录下

一：SpringMVC注解式开发

1. @RequestMapping定义请求规则

通过@RequestMapping 注解可以定义处理器对于请求的映射规则（此注解就是来映射服务器访问的路径）。该注解可以注解在方法上，也可以注解在类上，意义是不同的。value 属性值常以“/”开始，当value是其唯一属性时，可以省略属性名；@RequestMapping的value 属性用于定义所匹配请求的 URI，以“/”开始。

（1）此注解可加在方法上，是为此方法注册一个可以访问的名称（路径）

前端请求

<%--发送超链接--%>
<a href="${pageContext.request.contextPath}/demo.action">发送请求</a>

后端代码：只有方法上有@RequestMapping注解

package com.bjpowernode.controller;

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

@Controller
public class DemoAction {
    @RequestMapping("/demo")
    public String demo(){
        return "main";
    }
}

（2）@RequestMapping也可以加在类上，相当于是多了一层路径（虚拟路径），区分不同类中相同的action的名称

前端请求：多一个mvc路径

<%--发送超链接--%>
<a href="${pageContext.request.contextPath}/mvc/demo.action">发送请求</a>

后端代码：在类上和方法上都有@RequestMapping注解

package com.bjpowernode.controller;

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

@Controller
@RequestMapping("/mvc")
public class DemoAction {
    @RequestMapping("/demo")
    public String demo(){
        return "main";
    }
}

（3）此注解可区分get请求和post请求

前端请求：提交一个form表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<--发送超链接-->  
    <form action="${pageContext.request.contextPath}/mvc/demo.action"  method="get" />
    <form action="${pageContext.request.contextPath}/mvc/demo.action"  method="post" />
    <input type="submit" value="提交" />
</body>
</html>

后端代码：使用method属性，指定接收的是get请求还是post请求

使用@RequestMapping注解的method属性method = RequestMethod.GET或.POST！

package com.bjpowernode.controller;

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

@Controller
@RequestMapping("/mvc")
public class DemoAction {
    @RequestMapping(value = "/demo",method = RequestMethod.GET)
    public String demo(){
        System.out.println("发送Get请求");
        return "main";
    }

    @RequestMapping(value = "/demo",method = RequestMethod.POST)
    public String demo1(){
        System.out.println("发送Post请求");
        return "main";
    }
}

（4）补充：客户端浏览器常用的请求方式，及其提交方式有以下几种

也就是说，只要指定了处理器方法匹配的请求提交方式为 POST请求，则相当于指定了请求发送的方式：要么使用表单请求，要么使用 AJAX 请求，其它请求方式被禁用。当然，若不指定 method 属性，则无论是 GET 还是 POST 提交方式，均可匹配！

接下来我们就来分析一下可优化的内容，也就是下面要讲解的知识点：

2. 五种数据提交的方式

（1）单个提交数据

在后端方法中声明一个和前端表单提交的参数名称相同的参数，由框架按照名称直接注入。

前端代码：

<h1>1.单个数据提交</h1>
<form action="${pageContext.request.contextPath}/one.action">
    姓名：<input type="text" name="myname"><br>
    年龄：<input type="text" name="myage"><br>
    <input type="submit" value="提交">
</form>

后端代码：

传的参数必须与前面表中的属性名相同，(myage+10)的目的是为了测试进行了自动类型转换，转换成了int类型。

package com.bjpowernode.controller;

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

@Controller
public class DataSubmitAction {
    @RequestMapping("/one")
    // 方法中的参数与form表单中name属性的值是相同的---按照名字注入
    public String one(String myname,int myage){
        System.out.println("myname="+myname+",myage="+(myage+10));
        return "main";
    }
}

执行结果：

核心：

①表中form中的属性，例如：myname和myage的属性名与action方法参数的名称一致！

②这样就可以完成自动注入值，并且可以自动进行类型的转换！

（2）对象封装提交数据

在方法中声明一个自定义的实体类参数，框架调用实体类中相应的setter方法注入属性值，只要保证实体类中成员变量的名称与提交请求的name属性值一致即可。

定义实体类：

package com.bjpowernode;

public class User {
    private String name;
    private int age;

    public User() {
    }
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

前端代码：

<h1>2.对象封装数据提交</h1>
<form action="${pageContext.request.contextPath}/two.action">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交">
</form>

后端代码：

这里传的参数不再是表单中的属性名称，我们借用了实体类User，所以参数就是实体类User

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

执行结果：

核心：

①在提交请求中，保证请求参数的名称与实体类中成员变量的名称一致，则可以自动创建对象、可以自动提交数据、自动类型转换、自动封装数据到对象中。

②方法的参数不再是零散的数据，而是我们封装好的实体类User对象。

（3）动态占位符提交（用的少）

仅限于超链接或地址栏提交数据，它是一杠一值（传数据）、一杠一大括号（接收数据），使用注解@PathVariable（路径变量）来解析。

前端代码：

先回忆以前的提交方式，使用?与&的方式，例如：uri/?name=value&name=value的方式

<a href="${pageContext.request.contextPath}/three.action?name=张三&age=20" />

现在使用一杠一值的方式，注意位置是在“.action”页面的前面！

<h1>3.动态占位符数据提交</h1>
<a href="${pageContext.request.contextPath}/three/王五/20.action" />

后端代码：

前端使用一杠一值传，后端使用一杠一大括号接收，里面的参数名随意，但是需要@PathVariable注解：若地址栏中大括号里{}的变量与下面方法的变量保持一致，此时路径变量@PathVariable注解中的value属性就可以省略；若变量没有保持一致，就需要使用路径变量@PathVariable的value属性指定上面地址栏大括号里的变量！

    @RequestMapping("/three/{myname}/{myage}")
    public String three(@PathVariable String myname, @PathVariable int myage){
        System.out.println("myname="+myname+",myage="+(myage+10));
        return "main";
    }

执行结果：

核心：

①前端使用一杠一值的形式提交，后端使用一杠一大括号的形式接收，这里大括号里面的参数随意

②方法中的参数需要使用@PathVariable注解，没有任何属性，这是参数和下面方法中的参数一致

③假如参数不一致，@PathVariable注解就需要带上上面@RequestMapping注解中的参数；例如：

（4）映射名称不一致

form表单中提交请求参数与action方法的形参的名称不一致，使用注解@RequestParam来解析！

前端代码：

前端提交的数据，name属性的值是name和age

<h1>4.映射名称不一致</h1>
<form action="${pageContext.request.contextPath}/four.action">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交">
</form>

后端代码：

后端接收数据，方法中的属性名称是myname和myage，名称不一致，如何解决？使用@RequestParam注解

    @RequestMapping("/four")
    public String four(@RequestParam("name") String myname, @RequestParam("age") int myage){
        System.out.println("myname="+myname+",myage="+(myage+10));
        return "main";
    }

执行结果：

核心：

①前端提交数据的表单，属性名我们可能不知道；后端我们编写代码方法中的属性又是根据我们自己的意愿编写，怎么让两者之间建立联系？使用@RequestParam注解即可。

（5）手工提取数据（了解）

使用原始的方式：在方法参数中声明一个HttpServletRequest request对象，使用request的getParameter()获取表单提交的数据，这样得到的数据还要手工进行数据类型的转换。

前端代码：

<h1>5.手工提交</h1>
<form action="${pageContext.request.contextPath}/five.action">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交">
</form>

后端代码：

此时方法中的参数是HttpServletRequest对象，可以拿来直接用；然后调用getParameter方法根据key获取对应的value值。

注：从请求中得到的数据都是String类型，要想得到其它类型需要进行手动转换。

    @RequestMapping("/five")
    public String five(HttpServletRequest request){
        // 根据key获取value
        String name = request.getParameter("name");
        // 需要手动转换为int类型
        int age = Integer.parseInt(request.getParameter("age"));
        System.out.println("name="+name+",age="+(age+10));
        return "main";
    }

执行结果：

核心：

①方法的参数传一个HttpServletRequest对象，不需要创建直接可以使用，然后调用getParameter方法获取到value；想要其它类型的数据还需要自己手动进行转换。

3. 请求参数中文乱码解决

（1）对于前面所接收的请求参数，若是Post请求，并含有中文，则会出现中文乱码问题。Spring对于请求参数中的中文乱码问题，给出了专门的字符集过滤器：spring-web-5.2.5.RELEASE.jar 的org.springframework.web.filter 包下的 CharacterEncodingFilter 类

（2）在web.xml中配置过滤器CharacterEncodingFilter，建议一开始就放在最前面！

（1）解决方案

在 web.xml配置中注册字符集过滤器，即可解决 Spring 的请求参数的中文乱码问题。不过，最好将该过滤器注册在其它过滤器之前，因为过滤器的执行是按照其注册顺序进行的。

 <!--注册过滤器：解决post请求乱码问题-->
    <filter>
        <filter-name>encode</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>
        <!--强制request使用字符集encoding-->
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <!--强制response使用字符集encoding-->
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>encode</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

（2）CharaterEncodingFilter源码分析

三个参数：编码方式encoding、forceRequestEncoding和forceResponseEncoding默认值都是false

所在在配置中设置encoding值为UTF-8，另外两个参数设置成true后，会走以下代码

4. action方法的返回值

（1）String：客户端资源的地址，自动拼接前缀和后缀，还可以屏蔽自动拼接字符串，可以指定返回的路径。
（2）Object：返回json格式的对象，自动将对象或集合转为json，使用jackson工具进行转换，必须要添加jackson依赖，一般用于ajax请求。
（3）void：无返回值，一般用于ajax请求。
（4）基本数据类型：用于ajax请求。
（5）ModelAndView：返回数据和视图对象，现在用的很少。

完成ajax请求访问服务器，返回学生集合
第一步：增加jackson依赖

        <!--添加jackson依赖-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.8</version>
        </dependency>

第二步：springmvc配置

不需要视图解析器（InternalResourceViewResolver），发送的是ajax请求，哪里来回到哪里去，但是需要添加注解驱动<mvc:annotation-driven/>，这个注解驱动是用来解析@ResponseBody注解

<?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.bjpowernode.controller"/>
    <!--添加注解驱动，专门处理ajax请求-->
    <mvc:annotation-driven/>
</beans>

第三步：web.xml配置

配置解决中文乱码问题和注册springmvc！

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

    <!--注册过滤器：解决post请求乱码问题-->
    <filter>
        <filter-name>encode</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>
        <!--强制request使用字符集encoding-->
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <!--强制response使用字符集encoding-->
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encode</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--注册springmvc-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>

</web-app>

第四步：在webapp目录下新建js目录，添加jQuery函数库，在index.jsp页面上导入函数库

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <%--引入JQuery库--%>
    <script src="js/jquery-3.3.1.js"></script>
</head>
<body>
<a href="javascript:showStu()">访问服务器返回学生集合</a>
<div id="mydiv">等待服务器返回数据</div>

<script type="text/javascript">
    // 使用JQuery封装的ajax()方法发送请求
    $.ajax({
        url:"${pageContext.request.contextPath}/list.action",
        type:"get",
        dataType:"json",
        success:function (stuList){
            var s = "";
            $.each(stuList,function (i,stu) {
                s += stu.name + "---"+stu.age+"<br>";
            });
            // 回显数据到div
            $("#mydiv").html(s);
        }
    });
</script>
</body>
</html>

Student类：因为上面是要返回学生集合

package com.bjpowernode.pojo;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

第五步：服务器端代码

@ResponseBody的作用：其实是将java对象转为json格式的数据，使用<mvc:annotation-driven/>就是专门用来处理@ResponseBody注解的！

注：发送ajax请求一定要使用@ResponseBody注解！

package com.bjpowernode.controller;

import com.bjpowernode.pojo.Student;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

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

@Controller
public class StudentListAction {
    @RequestMapping("/list")
    @ResponseBody // 处理ajax一定要加@ResponseBody注解
    public List<Student> list(){
        List<Student> list = new ArrayList<>();
        // 添加数据
        Student stu1 = new Student("张三", 18);
        Student stu2 = new Student("李四", 19);
        Student stu3 = new Student("王五", 20);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        // 实际上SpringMVC框架会将list集合自动转为json数组
        return list;
    }

}

第六步：测试

点击超链接前

点击超链接后

5. SpringMVC的四种跳转方式

默认的跳转是请求转发，直接跳转到jsp页面展示，还可以使用框架提供的关键字redirect:，进行一个重定向操作，包括重定向页面和重定向action，使用框架提供的关键字forward:，进行服务器内部转发操作，包括转发页面和转发action。

注：当使用redirect:和forward:关键字时，视图解析器中前缀后缀的拼接就无效了。

首先我们先通过一张图区分一下转发和重定向：

我们也可以通过一个生活中的例子来理解：有三个人你、我、他

转发：你给我打电话问事情，我不知道，我把我的电话给了身边的他；但是本质上还是我的电话，显示的地址就是我的地址：http://localhost:8080/one.action

重定向：你给我打电话问事情，我不知道，把电话挂了；你重新给他打电话进行询问，所以本质是他的电话，显示的地址就是他的地址：http://localhost:8080/main.jsp

（1）请求转发的跳转代码

index.jsp：

两种转发方式，一种是我们前面一直用的，默认的跳转方式；另一种是跳转到其它的action

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<br>
<a href="${pageContext.request.contextPath}/one.action">1.请求转发页面(默认)</a>
<a href="${pageContext.request.contextPath}/two.action">2.请求转发action</a>
</body>
</html>

Other.action：第二种跳转到其它action，肯定需要定义一个其它的action

package com.bjpowernode.controller;

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

@Controller
public class OtherAction {
    @RequestMapping("/other")
    public String other(){
        System.out.println("这是other的action访问........");
        return "main";
    }
}

测试：

解释forward：是屏蔽视图解析器中前缀和后缀的拼接；

如果没有forward:，最终展现的结果就是admin/other.action！

package com.bjpowernode.controller;

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

@Controller
public class JumpAction {

    @RequestMapping("/one")
    public String one(){
        // 默认使用视图解析器拼接前缀和后缀进行页面跳转
        System.out.println("这是请求转发页面跳转........");
        return "main";
    }

    @RequestMapping("/two")
    public String two(){
        // 使用forward:可以屏蔽前后缀的拼接
        return "forward:/other.action";
    }
}

结果1：请求转发页面是从index.jsp--->one.action--->main.jsp，最终地址是one.action的地址

结果2：请求转发页面是从index.jsp--->two.action--->other.action--->main.jsp，最终地址是two.action的地址

结论：最终的地址都是第一次页面跳转的地址，与前面我们分析的一致！

（2）重定向的跳转代码

index.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<br>
<a href="${pageContext.request.contextPath}/three.action">1.重定向页面</a><br>
<a href="${pageContext.request.contextPath}/four.action">2.重定向action</a><br>
</body>
</html>

测试：

解释redirect：也是屏蔽视图解析器中前缀和后缀的拼接；无论是重定向页面还是重定向其它action，都要使用redirect。

注：在重定向页面时需要写上页面的绝对路径，例如：redirect:/admin/main.jsp，对于重定向其它action和转发相似。

package com.bjpowernode.controller;

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

@Controller
public class JumpAction {
    @RequestMapping("/three")
    public String three(){
        // 屏蔽视图解析器拼接前缀和后缀进行页面跳转
        System.out.println("这是重定向页面跳转........");
        return "redirect:/admin/main.jsp";
    }

    @RequestMapping("/four")
    public String four(){
        // 屏蔽视图解析器拼接前缀和后缀进行页面跳转
        System.out.println("这是重定向其它action........");
        return "redirect:/other.action";
    }

}

结果1：从index.jsp--->three.action，发现是重定向到main.jsp，所以是又重新发出请求从index.jsp

--->main.jsp，最终地址是main.jsp的地址

结果2：先从index.jsp--->four.action，发现是是重定向到other.action，

所以是又重新发出请求从index.jsp--->other.action，然后other.action又是转发到main.jsp，最终地址是other.action的地址

结论：最终的地址是最后一次重定向的地址，与前面我们分析的一致！

注：我们也可以利用forword和redirect随便跳转页面，后面跟绝对路径即可；但是转发可以携带数据，重定向不能携带数据（容易数据丢失）；并且转发是只能在服务器内部转发，重定向可以访问外部资源！

6. SpringMVC支持的默认参数类型

这些类型不需要创建，只要写在方法参数中就可以使用了（常见的）

（1）HttpServletRequest 对象

（2）HttpServletResponse 对象

（3）HttpSession 对象

（4）Model/ModelMap 对象　

（5）Map<String,Object>对象

注意：Map、Model、ModelMap和request一样，都使用请求作用域进行数据传递，所以服务器端的跳转必须是请求转发，这样才能携带数据。

index.jsp页面，也可以携带数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<br><br><br>
<a href="${pageContext.request.contextPath}/data.action?data=李四">访问服务器，进行数据携带跳转</a><br>
</body>
</html>

DataAction类，存入数据

package com.bjpowernode.controller;

import com.bjpowernode.pojo.Student;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;

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

@Controller
public class DataAction {
    @RequestMapping("/data")
    public String data(HttpServletRequest request,
                       HttpServletResponse response,
                       HttpSession session,
                       Model model,
                       Map map,
                       ModelMap modelMap
                       ){
        // 创建一个数据
        Student stu = new Student("张三", 22);
        // 传递数据
        request.setAttribute("requestStu",stu);
        session.setAttribute("sessionStu",stu);
        model.addAttribute("modelStu",stu);
        map.put("mapStu",stu);
        modelMap.addAttribute("modelMapStu",stu);

        return "main";
    }
}

跳转到main.jsp取出数据

注：取数据，可以从DataAction类中取出存入的数据；也可以直接从index.jsp中取出携带的数据，但是需要使用 “param.” 的方式！

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

<%--取出数据--%>
requestStu对应数据：${requestStu}<br>
sessionStu对应数据：${sessionStu}<br>
modelStu对应数据：${modelStu}<br>
mapStu对应数据：${mapStu}<br>
modelMapStu对应数据：${modelMapStu}<br>

从index.jsp页面中来的数据：${param.data}

</body>
</html>

测试结果：都能正常取出数据

注意：如果使用重定向呢？

如果使用重定向，只有session域的数据还在，其它数据都会丢失！

执行结果：

7. 日期处理

日期类型不能自动注入到方法的参数中，需要单独做转换处理。

（1）日期注入

第一种情况：单个日期注入

使用注解的方式对日期进行格式化：@DateTimeFormat，此注解必须搭配springmvc.xml文件中的<mvc:annotation-driven>标签一起使用！

index.jsp中表单提交日期格式的字符串

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/mydate.action">
    日期：<input type="date" name="mydate">
    <input type="submit" value="提交">
</form>
</body>
</html>

springmvc.xml中添加注解驱动

<!--添加注解驱动-->
<mvc:annotation-driven />

MyDateAction程序

①@DateTimeFormat(pattern = "yyyy-MM-dd")是把提交过来的字符串转换为日期格式

②new SimpleDateFormat("yyyy-MM-dd")是为了格式化日期

package com.bjpowernode.controller;

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

import java.text.SimpleDateFormat;
import java.util.Date;

@Controller
public class MyDateAction {

    // 用来格式化日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    @RequestMapping("/mydate")
    public String MyDate(@DateTimeFormat(pattern = "yyyy-MM-dd") Date mydate){
        // 未格式化的日期
        System.out.println(mydate);
        // 格式化的日期
        System.out.println(sdf.format(mydate));
        return "main";
    }
}

执行结果：

第二种情况：类中全局日期处理

注册一个@InitBinder注解，用来解析本类中所有的日期类型，自动转换！

package com.bjpowernode.controller;

import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.RequestMapping;

import java.text.SimpleDateFormat;
import java.util.Date;

@Controller
public class MyDateAction {

    // 用来格式化日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    // 注册一个全局的日期处理注解
    @InitBinder
    public void initBinder(WebDataBinder dataBinder){
        dataBinder.registerCustomEditor(Date.class,new CustomDateEditor(sdf,true));
    }

    @RequestMapping("/mydate")
    public String MyDate(Date mydate){
        System.out.println(sdf.format(mydate));
        return "main";
    }

}

核心代码解析：

①WebDataBinder参数表示数据绑定，表示所有的数据都可以通过它进行绑定！

②调用registerCustomEditor方法表示自定义一个转换器：

第一个参数是要转换的类型：Date.class

第二个参数是使用什么工具去转？

创建一个CustomDateEditor对象：一个参数是格式化的日期的sdf，另一个参数是boolean类型，true表示日期为空也不报错。

    // 注册一个全局的日期处理注解，下面这个方法需要自己编写
    @InitBinder
    public void initBinder(WebDataBinder dataBinder){
        dataBinder.registerCustomEditor(Date.class,new CustomDateEditor(sdf,true));
    }

补充：如果日期作为成员变量，例如在User类当中有一个属性是Date，那么既可以在属性上使用@DateTimeFormat注解，也可以在对应的set方法setDate上面使用@DateTimeFormat注解

（2）日期显示

第一种情况：单个数据显示

单个日期传递很简单，直接格式化好以后，放到request域当中即可

传数据

package com.bjpowernode.controller;

import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import java.text.SimpleDateFormat;
import java.util.Date;

@Controller
public class MyDateAction {

    // 用来格式化日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    // 注册一个全局的日期处理注解
    @InitBinder
    public void initBinder(WebDataBinder dataBinder){
        dataBinder.registerCustomEditor(Date.class,new CustomDateEditor(sdf,true));
    }
    // 存入数据
    @RequestMapping("/mydate")
    public String MyDate(Date mydate, HttpServletRequest request){
        // 格式化以后放到request域当中，传过去的实际上是日期格式的字符串
        request.setAttribute("mydate",sdf.format(mydate));
        return "showdate";
    }
}

取数据

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

单个日期提交数据：${mydate}

</body>
</html>

第二种情况：实体类对象的成员变量是日期类型

如果是list集合当中的实体类对象的成员变量是日期类型，则必须使用JSTL标签库进行显示，使用JSTL的步骤：

①添加依赖

②在页面上导入标签库

③使用标签遍历显示数据

先创建一个User类

package com.bjpowernode.pojo;

import java.util.Date;

public class User {
    private String name;
    // 实体类当中含有Date类型
    private Date birth;

    public User() {
    }
    public User(String name, Date birth) {
        this.name = name;
        this.birth = birth;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", birth=" + birth +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }
}

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<a href="${pageContext.request.contextPath}/list.action">显示集合对象的日期成员</a>
</body>
</html>

存入数据

package com.bjpowernode.controller;

import com.bjpowernode.pojo.User;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Controller
public class MyDateAction {

    // 用来格式化日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    @RequestMapping("/list")
    public String list(HttpServletRequest request) throws ParseException {
        User u1 = new User("张三", sdf.parse("1999-01-01"));
        User u2 = new User("李四", sdf.parse("1999-02-02"));
        User u3 = new User("王五", sdf.parse("1999-03-03"));
        List<User> list = new ArrayList<>();
        list.add(u1);
        list.add(u2);
        list.add(u3);
        // 放到request当中
        request.setAttribute("userList",list);
        return "showdate";
    }
    
}

获取数据

①添加JSTL依赖

<dependency>
     <groupId>javax.servlet</groupId>
     <artifactId>jstl</artifactId>
     <version>1.2</version>
</dependency>

②在页面上导入标签库

<%--导入jstl核心标签库--%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--导入jstl格式化标签库--%>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

③使用标签格式化和遍历显示数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <%--导入jstl核心标签库--%>
    <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%--导入jstl格式化标签库--%>
    <%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
</head>
<body>
单个日期提交数据：${mydate}
<br><br>
<h2>学生集合</h2>
<table width="50%" border="1px">
    <tr>
        <th>姓名</th>
        <th>生日</th>
    </tr>
    <c:forEach items="${userList}" var="user">
        <tr>
            <td>${user.name}</td>
            <td><fmt:formatDate value="${user.birth}" pattern="yyyy-MM-dd"></fmt:formatDate> </td>
        </tr>
    </c:forEach>

</table>
</body>
</html>

执行结果：

补充：JSON中的日期显示

需要在类中的成员变量的getXXX方法上加@JsonFormat注解

8. <mvc:annotation-driven/>标签的使用

前言：目前我们发送ajax请求和日期转换都使用了这个标签，功能很强大！

<mvc:annotation-driven/>会自动注册两个bean（俩个帮手），分别为DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter。是springmvc为@controller分发请求所必须的，除了注册了这两个bean，还提供了很多支持。

（1）支持使用ConversionService 实例对表单参数进行类型转换；

（2）支持使用 @NumberFormat 、@DateTimeFormat；

（3）注解完成数据类型的格式化；

（4）支持使用 @RequestBody 和 @ResponseBody 注解；

（5）静态资源的分流也使用这个标签;

9. 资源在WEB-INF目录下

（1）将动态资源放在WEB-INF目录下，这样可以保证资源的安全性；在WEB-INF目录下的动态资源不可以直接访问，必须要通过请求转发的方式进行访问。这样避免了通过地址栏直接对资源的访问，重定向也无法访问动态资源。

第一步：在WEB-INF目录下创建一个jsp目录，在目录下创建index.jsp和main.jsp

开启Tomcat服务器，使用路径直接访问，根本访问不到，更安全了

第二步：只能通过请求转发的方式进行访问

WebInfAction程序

package com.bjpowernode.controller;

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

@Controller
public class WebInfAction {
    @RequestMapping("/showIndex")
    public String showIndex(){
        System.out.println("访问index.jsp页面");
        return "index";
    }

    @RequestMapping("/showMain")
    public String showMain(){
        System.out.println("访问main.jsp页面");
        return "main";
    }
}

需要地址的拼接，所以springmvc.xml中也要修改视图解析器的前缀

  <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--<property name="prefix" value="/admin/"></property>-->
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

第三步：进行测试，直接输入地址栏，通过转发的方式，可以正常访问

注：这样就相当于把index.jsp和main.jsp保护起来了，不能直接访问，要想访问必须通过WebInfAction才可以

（2）去掉后缀action的访问

修改web.xml，把<url-pattern>标签的路径修改为“/”，表示拦截所有的请求；优先访问的是没有后缀的，然后再去访问带.jsp或.action的

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
       <!-- <url-pattern>*.action</url-pattern>-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

测试：以后访问就可以不需要后缀直接访问

缺点：知道http://localhost:8080/web-inf/showIndex这个地址也能直接访问到，所以就需要增加一个权限验证功能。

（3）登录页面处理：登录成功才让你访问，登录失败打回原始的登录页面

增加login.jsp登录页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/login">
    姓名:<input type="text" name="name"><br>
    密码:<input type="password" name="pwd"><br>
    <input type="submit" value="登录">
</form>
</body>
</html>

WebInfAction中做登录判断

package com.bjpowernode.controller;

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

import javax.servlet.http.HttpServletRequest;

@Controller
public class WebInfAction {
    // 首先要跳转到登录页面
    @RequestMapping("/showLogin")
    public String submit(){
        System.out.println("访问login.jsp进行登录");
        return "login";
    }
    // 跳转到login.jsp后，在进行判断
    @RequestMapping("/login")
    public String login(String name, String pwd, HttpServletRequest request){ // 与前端保持一致，提交的数据自动吸过来
        // 进行判断,equalsIgnoreCase忽略大小写
        if ("root".equalsIgnoreCase(name) && "123".equalsIgnoreCase(pwd)){
            // 登录成功，可以访问main.jsp
            return "main";
        }else {
            // HttpServletRequest是用来提示登录失败的信息
            request.setAttribute("msg","用户名或者密码不正确");
            // 登录失败，跳转到登录页面login.jsp,在login.jsp中${msg}打印这个提示错误的信息
            return "login";
        }
    }
}

登录失败：会有提示，并且保持原来的登录页面