Spring第二讲

    <!-- SpringMVC -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.1</version>
    </dependency>

    <!-- ServletAPI -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>

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">
<!--  新创建的xml头部一定要是4.0版本的，如果不是可以去官网复制-->

  <display-name>Archetype Created Web Application</display-name>

<!--
    配置前端控制器:对浏览器发送的请求统一进行处理

    <url-pattern>标签中使用/和/*的区别：
        1、/所匹配的请求可以是/login或.html或.js或.css方式的请求路径，但是/不能匹配.jsp请求路径的请求
        因此就可以避免在访问jsp页面时，该请求被DispatcherServlet处理，从而找不到相应的页面
        2、/*则能够匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用/*的写法

     这里的<servlet-name>是lwl，
     如果不想配置别的名字，那么该servlet对应的配置文件默认名字为lwl-servlet.xml;默认位置为WEB-INF下面
     如果想使用不同的名字，就需要添加<init-param>标签，<param-name>的值是固定的，<param-value>是寻找对应的文件
-->
  <servlet>
    <servlet-name>lwl</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
<!--      如果是一个maven项目:那这里的classpath:就是要去main下面的resources里面去寻找对应的文件-->
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>lwl</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

4、对应控制器的配置文件

<?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.lwl.controller"></context:component-scan>
<!--
        视图解析器：是为了查找对应视图文件，根据视图文件的前后缀
-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--
        prefix：所在的位置，视图文件是在哪个文件夹下面，在查找时是从webapp开始查找
        /就代表是当前文件夹，也就是代表webapp
-->
        <property name="prefix" value="/"></property>
<!--
        suffix：视图文件的后缀，视图文件多是以.jsp结尾的，所以这里填写.jsp
-->
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

5、创建请求控制器

由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器

请求控制器中每一个处理请求的方法成为控制器方法

因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在

//    控制层：替代servlet
//    这里写@Component也是一样效果，但是为了开发人员区分功能（层级），所以这里应该写成@Controller
//    @Controller：把当前类交给ioc容器，作为bean，并且标记为控制层，要在对应的配置文件中进行扫描
@Controller
public class FirstController {

//    给这个方法一个路径
//    在servlet中，这个路径(url)必须是以/为开头的
//    但是在springmvc中，这个/可以不加，它自己会封装
    @RequestMapping("test")
    public String test(){
        System.out.println("这是一个url为test的方法");
//      prefix：所在的位置，视图文件是在哪个文件夹下面，在查找时是从webapp开始查找
//      suffix：视图文件的后缀，视图文件多是以.jsp结尾的，所以这里填写.jsp
//        在这里会将视图文件的路径给组装起来
//        prefix string suffix ==> /views/success.jsp
        return "views/success";
    }
}

对应的视图页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>成功</title>
</head>
<body>
        <h2>这是一个成功的页面</h2>
</body>
</html>

运行进行测试，这里应该会跳到webapp下的views/success.jsp页面中

2 Spring工作流程

2.1 SpringMVC请求流程

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

图示：

2.2 SpringMVC执行流程

常用到的组件：

1） DispatcherServlet：前端控制器，不需要工程师开发，由框架提供

作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求

2） HandlerMapping：处理器映射器，不需要工程师开发，由框架提供

作用：根据请求的url、method等信息查找Handler，即控制器方法

3） Handler：处理器，需要工程师开发，就是Controller文件

作用：在DispatcherServlet的控制下Handler对具体的用户请求进行处理

4） HandlerAdapter：处理器适配器，不需要工程师开发，由框架提供

作用：通过HandlerAdapter对处理器（控制器方法）进行执行

5） ViewResolver：视图解析器，不需要工程师开发，由框架提供

作用：进行视图解析，得到相应的视图，本例中使用的是jsp，另外的还有很多例如：ThymeleafView、InternalResourceView、 RedirectView

6） View：视图

作用：将模型数据通过页面展示给用户

执行流程：

1、用户发送请求至前端控制器DispatcherServlet。

2、 DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4、 DispatcherServlet调用HandlerAdapter处理器适配器。

5、 HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。

6、 Controller执行完成返回ModelAndView。

7、 HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

8、 DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

9、 ViewReslover解析后返回具体View。

10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。

11、 DispatcherServlet响应用户。

图示：

2.3 @RequestMapping注解

从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。

SpringMVC 接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。

Postman下载地址：Download Postman | Get Started for Free

@Controller
@RequestMapping("note")
public class NoteController {
//    @RequestMapping源代码的简单解读
//    1、@java.lang.annotation.Target({java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD})
//          java.lang.annotation.ElementType.TYPE：代表该注解可以作用在类上面,作用在类上面时，是设置请求路径的初始信息
//            访问时，需要先写上类上面的路径，再写方法上面的路径，否则会访问不到，所以作用在类上面也叫窄化路径
//          java.lang.annotation.ElementType.METHOD：代表该注解可以作用在方法上面，作用在方法上面时，设置了路径的具体信息
//    2、@org.springframework.core.annotation.AliasFor("path")
//          java.lang.String[] value() default {};
//          代表该注解中可以存放多个元素，并且value属性和path属性是同样的效果
//          @RequestMapping注解的value属性必须设置，至少通过请求地址匹配请求映射
//    3、@org.springframework.core.annotation.AliasFor("value")
//          java.lang.String[] path() default {};
//          代表该注解中可以存放多个元素，并且value属性和path属性是同样的效果
//    4、org.springframework.web.bind.annotation.RequestMethod[] method() default {};
//          这里是填写请求方法，如get，post等，定义为数组，代表该注解中的路径也可以填写多个
    @RequestMapping("testModelAndView")
    public ModelAndView testModelandView(){
        ModelAndView modelAndView = new ModelAndView();
        Map map = new HashMap<>();
        map.put("name","testModelAndView");
//        在ModelAndView添加一个数据，将名字命名为map，以便在视图文件中取出
        modelAndView.addObject("map",map);
//        这里是设置要寻找的视图文件的名字是什么
        modelAndView.setViewName("testModelAndView");
        return modelAndView;
    }

//    这里写value=和写path=是一样的效果，因为方法中定义的是一个String[]，所以这里可以写多个值，
//    无论使用哪个值都可以访问到这个方法，一般不使用这个数组
    @RequestMapping(value = {"testValue1","testValue2"})
    public String testValue(){
        System.out.println("测试value和path的效果");
        return "testValue";
    }
    @RequestMapping(path = {"testPath1","testPath2"})
    public String testPath(){
        System.out.println("测试value和path的效果");
        return "testValue";
    }

//    如果规定method属性，method属性对请求方法有限制，如果method方法中规定了get那么就能使用get，
//    用未规定的请求方法进行请求会报405错误 - 方法不允许:Request method 'POST' not supported
//    如果不规定method属性，那么所有的请求方法都可以使用

    @RequestMapping(value = "testMethod",method = {RequestMethod.GET,RequestMethod.POST})
    public String testMethod(){
        return "testValue";
    }

//这里引入一个软件，Postman：postman是一款强大网页调试工具的客户端，postman为用户提供强大的WebAPI&HTTP请求调试功能。
// postman能够发送任何类型的HTTP请求(GET，HEAD，POST，PUT），附带任何数量的参数+headers，是一款非常实用的调试工具。

//    @RequestMapping(value = "testGetMapping",method = {RequestMethod.GET})
//    这两种写法是一样的效果，一般建议使用下面这种写法，还有对应的
//    处理get请求的映射-->@GetMapping  （查询）
//    处理post请求的映射-->@PostMapping   (添加)
//    处理put请求的映射-->@PutMapping      （修改）
//    处理delete请求的映射-->@DeleteMapping （删除）
    @GetMapping(value = "testGetMapping")
    public String testGetMapping(){
        return "testValue";
    }
}

对应的视图文件：

testModelAndView：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>testModelAndView</title>
</head>
<body>
        这里取到的map是：${map}<br>
        这里取到的map里面的name值是：${map.name}  || 另一种方式取到的值是：${map["name"]}<br>
        这里是测试ModelAndView的界面
</body>
</html>

testValue：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>测试Value和path的效果</title>
</head>
<body>
        <h2>测试成功</h2>
</body>
</html>

2.4 SpringMVC获取请求参数

通过ServletAPI获取

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

//    在servlet中，我们常用writer来返回Ajax请求的值
    @GetMapping("testAjax")
    public void testAjax(HttpServletResponse response){
        try {
            PrintWriter writer = response.getWriter();
            writer.write("success");
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

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

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

    @GetMapping("testAjaxMVC")
//     @ResponseBody：代表返回的数据就是JSON数据，也就是只会返回下面这个字符串，而不会跳转到success.jsp页面中
    @ResponseBody
    public String testAjaxMVC(){
        return "success";
    }

注：

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

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

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

2.5 @RequestParam

@RequestParam是将请求参数和控制器方法的形参创建映射关系

@RequestParam注解一共有三个属性：

value：指定为形参赋值的请求参数的参数名

required：设置是否必须传输此请求参数，默认值为true

若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter 'xxx' is not present；若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null

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

2.6 通过POJO获取请求参数

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

前端页面：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>学生添加</title>
</head>
<body>
        <form action="testpojo" method="post">
            用户名：<input type="text" name="username"><br>
            密码：<input type="password" name="password"><br>
            性别：<input type="radio" name="sex" value="男">男
                 <input type="radio" name="sex" value="女">女<br>
            年龄：<input type="text" name="age"><br>
            邮箱：<input type="email" name="email"><br>
            <input type="submit" value="提交">
        </form>
</body>
</html>

测试类：
//  前端页面发出请求，通过POJO方法接收前端传来的数据
    @PostMapping("testpojo")
    public void  testSpringMVCPOJOZwf(User user){
        System.out.println("user = " + user);
    }

2.7 解决获取请求参数的乱码问题

解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是必须在web.xml中进行注册

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

<!--  利用字符编码过滤器设置字符编码格式-->
  <filter>
<!--    Spring框架提供的字符编码过滤器，起名为CharacterEncodingFilter-->
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>
      org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
<!--      设置字符编码格式为UTF-8 -->
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
<!--      强行设置编码格式-->
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
<!--    /*代表所有的文件都要经过字符编码过滤器，包括jsp文件-->
    <url-pattern>/*</url-pattern>
  </filter-mapping>

2.8 SpringMVC支持路径中的占位符（重点）

原始方式路径中显示：/deleteUser?id=1

rest方式路径中显示：/user/delete/1

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

@Controller
public class ZwfController {

//  使用postman发送的请求  http://localhost:8080/springDay02MVC_war_exploded/testServletZwf?id=18
//    根据以往的servlet方法获得的参数的方法
    @GetMapping("testServletZwf")
    public String  testServletZwf(HttpServletRequest request){
        String id = request.getParameter("id");
        int ids = 0;
        if (id!=null && id!=""){
            ids = Integer.parseInt(id);
        }
        System.out.println("ids = " + ids);
        return "testValue";
    }

//    SpringMVC方法接收参数值
    @GetMapping("testSpringMVCZwf")
    public String  testSpringMVCZwf(Integer id,String username,String password){
        System.out.println("id = " + id);
        System.out.println("username = " + username);
        System.out.println("password = " + password);
        return "testValue";
    }
//    SpringMVC方法通过POJO（简单的java对象）的方法接收参数值，这种方法叫模型驱动
//    要保证该类中的属性名和传来的参数名一致，一致的属性，会通过实体类的get和set方法来进行赋值
//    与参数名不一致的属性值，参数值传不过来
    @GetMapping("testSpringMVCUserZwf")
    public String  testSpringMVCUserZwf(User user){
        System.out.println("user = " + user);
        return "testValue";
    }

2.9 域对象共享数据

与servlet中相同，数据传递的域也分为三个 request session application

@Controller
public class ShareController {

//    测试域的共享对象：共有三个范围 request  session application
    @GetMapping("testRequest")
    public String testRequest(HttpServletRequest request){
        request.setAttribute("name","testRequestScope");
        return "share/share";
    }

    @GetMapping("testSession")
    public String testSession(HttpSession request){
        request.setAttribute("name","testSessionScope");
        return "share/share";
    }

    @GetMapping("testContext")
    public String testContext(HttpSession request){
        ServletContext servletContext = request.getServletContext();
        servletContext.setAttribute("name","testContextScope");
        return "share/share";
    }
}

2.10 转发视图

SpringMVC中默认的转发视图是InternalResourceView

SpringMVC中创建转发视图的情况：

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

//    测试请求转发:能携带值
    @GetMapping("testForward")
    public String testForward(HttpSession request){
        request.setAttribute("name","testSessionScope");
//        这里跳转页面时，必须加jsp
        return "forward:share/share.jsp";
    }
//    请求转发不仅能跳转到视图文件中，也可以跳转到Controller文件中
    @GetMapping("testForwardController")
    public String testForwardController(HttpSession request){
        return "forward:note/testMethod";
    }

2.11 重定向视图

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

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

//    测试重定向：不能携带值
    @GetMapping("testRedirect")
    public String testRedirect(HttpSession request){
        request.setAttribute("name","testSessionScope");
        return "redirect:share/share.jsp";
    }
//    重定向不仅能跳转到视图文件中，也可以跳转到Controller文件中
    @GetMapping("testRedirectController")
    public String testRedirectController(HttpSession request){
        return "redirect:note/testMethod";
    }

2.12 Spring处理Ajax请求

1）@RequestBody可以获取请求体信息，使用@RequestBody注解标识控制器方法的形参，当前请求的参数在请求体中就会为当前注解所标识的形参赋值

<form action="/test/RequestBody" method="post">
  用户名：<input type="text" name="username">
  密码： <input type="password" name="password">
    <input type="submit">

@RequestMapping("/test/RequestBody")
public String testRequestBody(@RequestBody String requestBody){
    System.out.println("requestBody:"+requestBody);
     return "success";
   } 
   
输出的结果：
requestBody:username=admin&password=123456

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

对应使用到的jar包
<!--1、用来转化数据为JSON类型数据-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>2.0.10</version>
    </dependency>
<!-- 2、通过spring框架，直接封装对象为JSON类型数据-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.12.1</version>
    </dependency>

配置文件中对应的驱动：
<!--    开启mvc的注解驱动：只有在使用Ajax返回JSON对象的时候才会使用这个注解驱动-->
    <mvc:annotation-driven></mvc:annotation-driven>

//    1、在servlet中，测试返回一个JSON对象,要先利用fastjson的jar包将对象转化为JSON类型的对象
    @GetMapping("testPOJO")
//     @ResponseBody：代表返回的数据就是JSON数据
    @ResponseBody
    public String testPOJO(){
        User user = new User();
        user.setAge(23);
//        这里设置中文会产生乱码
        user.setSex("男");
        user.setEmail("234@qq.com");
        user.setUsername("testJSONAjax");
        String userJson = JSON.toJSONString(user);
        return userJson;
    }

//    2、在mvc中，可以直接传输一个JSON对象,需要配置jackson-databind的jar包
//    除此之外，还要在配置文件中配置<mvc:annotation-driven>标签（开启mvc的注解驱动）
    @GetMapping("testPOJOMVC")
//     @ResponseBody：代表返回的数据就是JSON数据
    @ResponseBody
    public User testPOJOMVC(){
        User user = new User();
        user.setAge(23);
//        使用MVC的jar包，这里设置中文不会产生乱码
        user.setSex("男");
        user.setEmail("234@qq.com");
        user.setUsername("testJSONAjax");
        return user;
    }

//    3、传递一个数组，数组中存放实体类对象
    @GetMapping("testPOJOMVCList")
//     @ResponseBody：代表返回的数据就是JSON数据
    @ResponseBody
    public List<User> testPOJOMVCList(){
        List<User> list = new ArrayList<>();
        User user = new User();
        user.setAge(23);
//        使用MVC的jar包，这里设置中文不会产生乱码
        user.setSex("男");
        user.setEmail("234@qq.com");
        user.setUsername("testJSONAjax");
        list.add(user);
        return list;
    }