36讲——SpringMVC

1、什么是 MVC

MVC 是模型(Model)、视图(View)、控制器(Controller) 的简写，是一种软件设计规范
是将业务逻辑、数据、显示分离的方法来组织代码
MVC 主要作用是 降低视图于业务逻辑的双向耦合
MVC 不是设计模式，MVC是一种架构模式。当然不同的 MVC 存在差异

【Model (模型)】 : 数据模型，提供要展示的数据，因此包含数九和行为，可以认为是领域模型或 JavaBean 组件（包含数据和行为），不过现在一般部分离开来：value Object （数据Dao）和服务层（行为 Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包含数据和业务。

【View(视图)】 : 负责进行模型的展示,一般就是我们见到的用户界面，客户想看到的东西。

【Controller (控制器)】 : 接收用户请求，委托给模型进行处理（状态改变），处理完毕后吧返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作

最典型的MVC 就是 JSP + Servle + JavaBean 的模式

2、认识 SpringMVC

Spring MVC 是Spring FrameWork 的一部分，是基于java 实现的 MVC 的轻量级 Web 框架（SpringMVC 底层还是 servlet）

查看官方文档：https://spring.io/guides/gs/serving-web-content/

Spring MVC 的优点:

轻量级，简单易学
高效，基于请求响应的MVC框架
与Spring兼容性好，无缝结合
约定优于配置
功能强大: ReSTful、数据验证(比如手机号码，邮箱格式验证...)、格式化、本地化、主题等
简洁灵活

Spring 的web 框架围绕 DispatcherServlet 【调度 Servlet】设计

Dispatcher 的作用是将请求分发到不同的处理器。从 Spring 2.5 开始使用 Java 5 或者以上的版本的用户可以采用基于注解形式进行开发，十分简介；

正因为 SpringMVC 好简单,便捷,易学，天生和 Spring 无缝集成 (使用SpringloC和Aop) ，使用约定大于配置，能够进行简单的 junit 测试，支持 Restful 风格异常处理，本地化，国际化，数据验证，类型转化，拦截器等等...... 所以我们要学习

使用的人，使用的公司多

中心控制器

Spring的web框架围绕 DispatcherServlet 设计。DispatcherServlet 的作用是将请求分发4到不同的处理器。从Spring 2.5 开始，使用 Java 5 或者以上版本的用户可以采用基于注解 Controller 声明方式【这里建议使用注解，Spring Mybatis 不建议使用注解】。

Spring MVC 框架像许多其他 MVC 框架一样，以请求为驱动，围绕一个中心 Servlet 分派请求及提供其他功能，DispatcherServlet 是一个实际的 Servlet （他继承 HttpServlet 基类）。

SPringMVC 的原理如下图所示:

官方英文版

Spring MVC框架像许多其他MVC框架一样, 请求驱动,围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

如下图所示当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

2、回顾 Servlet【springmvc_01_servlet 】

【springmvc_01_servlet 】

架构图

index.jsp-->访问 form.jsp -->提交访问 hello.do -- >重定向/转发 -->hello.jsp

新建一个 Maven 父项目并导入依赖

Maven 父项目：意味着不用模板，不用 src 目录

不用模板创建直接 Next

【删除 src 整个目录导入依赖并配置】

删除 src目录

    <dependencies>
        <!-- ============ junit Start ============ -->
        <!--     junit  单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!-- ============ junit End ============ -->
        <!-- ~~~~~~~~~~ servlet  Start ~~~~~~~~~~   -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- ~~~~~~~~~~ servlet  End ~~~~~~~~~~   -->
        <!--~~~~~~~~~~  jsp  Start ~~~~~~~~~~ -->
        <!--支持虚拟路径 ${pageContext.request.contextPath} 等价 项目路径/s -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
        </dependency>
        <!--~~~~~~~~~~  jsp  End ~~~~~~~~~~ -->
        <!-- ~~~~~~~~~~~~  Spring 相关依赖 Start ~~~~~~~~~~~~  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
        <!-- ~~~~~~~~~~~~  Spring 相关依赖 End ~~~~~~~~~~~~  -->
        <!-- ~~~~~~~~~~ JSTL Start ~~~~~~~~~~ -->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- standard JSTL 需要这个 标签库 -->
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>
        <!-- ~~~~~~~~~~ JSTL End ~~~~~~~~~~ -->
    </dependencies>
    <!-- ===============  标记资源文件 自动打包导出 Start ===============-->
    <!--可以照搬的死代码 父子项目时 要放在对应项目中 或者都放也行-->
    <build>
        <resources>
            <!-- 标记资源文件 使其跟随项目打包出去 例如: 配置文件不打包到 Target 目录中 死代码 照搬就行-->
            <resource>
                <!-- resource 应该有默认配置 不需要写 但是java 文件下要写 才能生效-->
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>

        </resources>
    </build>
    <!-- ===============  标记资源文件 自动打包导出 End ===============-->

    <!-- =============== 整体环境 Start =============== -->
    <!--
    项目的源代码编码格式为 UTF-8 Maven 编译器的源代码兼容性版本和编译器的目标版本为 9
    杜绝版本过低的错误 Error 不支持发行版本   5-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>9</maven.compiler.source>
        <maven.compiler.target>9</maven.compiler.target>
    </properties>
    <!-- =============== 整体环境 End   =============== -->

新建子项目 springmvc_01_servlet 并添加框架支持为 web app

不用模板创建直接 Next

添加框架支持为 web app

> 子项目中也添加父项目已有的依赖不影响项目运行

<!-- ~~~~~~~~~~ servlet  Start ~~~~~~~~~~   -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.0</version>
    <scope>provided</scope>
</dependency>
<!-- ~~~~~~~~~~ servlet  End ~~~~~~~~~~   -->
<!--~~~~~~~~~~  jsp  Start ~~~~~~~~~~ -->
<!--支持虚拟路径 ${pageContext.request.contextPath} 等价 项目路径/s -->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.3</version>
</dependency>
<!--~~~~~~~~~~  jsp  End ~~~~~~~~~~ -->

配置 Tomcat 并测试 注意根目录的配置

配置 Tomcat 并测试

Test Tomcat 配置成功

Tomcat 地址问题

如果换了一台电脑,配置路径不一致的话，那么我们需要更改路径，改完不行，可以重启Idea 试试

4. 编写 Servlet 并注册

com.xiao.servlet.HelloServlet.java

package com.xiao.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1. 获取前端数据
        String method = req.getParameter("method");
        // 存 Session 中 无论 是转发还是重定向都能访问
        if ("add".equals(method)){// "add".equals(method) 反着调 就不会报空指针异常
            req.getSession().setAttribute("msg","执行了 add 方法");
        }else if ("delete".equals(method)){
            req.getSession().setAttribute("msg","执行了 delete 方法");
        } else {
            req.getSession().setAttribute("msg","执行了 其他 方法");
        }
        // 2. 调用业务层 没有
        // 3. 视图转发或重定向 / 根目录 web
        req.getRequestDispatcher("/WEB-INF/jsp/Hello.jsp").forward(req,resp);
        // 注意 WEB-INF 不能被重定向访问 ！！！

    }

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

注册 servlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.xiao.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello.do</url-pattern>
    </servlet-mapping>

<!--Session 超时-->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>
<!-- 欢迎页-->
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

编写前端页面并测试

form.jsp

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

<%-- ${pageContext.request.contextPath} = /xxz --%>
<form action="${pageContext.request.contextPath}/hello.do" method="get">
    <input type="text" name="method"><br>
    <input type="submit" >

</form>

</body>
</html>

Test

http://localhost:8080/xxz/hello.do?method=delete

http://localhost:8080/xxz/hello.do?method=add

过渡->

【mvc 框架要做哪些事情】

将 url 映射到 java 类或 java 方法
封装用户提交的数据
处理请求--调用相关的业务处理--封装响应数据
将响应的数据进行渲染 .jsp / html 等表示层数据

4、HelloSpringMVC

配置版【springmvc_02_hellomvc】

架构图

#### 4.1、新建一个 Module,添加 web 的支持（几乎都不用 archetype 模板）

4.2、导入SpringMVC 依赖

参考父依赖（完全依赖父项目也行）

4.3、配置 web.xml , 注册 DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
<!-- 1. 注册DispatcherServlet -->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--  关联一个springmvc 的配置文件: 【servletname】 -servlet.xml -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <!--    classpath*: 会去所有的包找 不建议使用   建议使用 classpath:-->
        <param-value>classpath*:springmvc-servlet.xml</param-value> <!-- 这里都行  classpath*: classpath:-->
    </init-param>
    <!-- 启动的级别 1 和服务器一起启动 -->
    <load-on-startup>1</load-on-startup>
</servlet>
<!-- / 匹配所有的请求; （不包括.jsp）
     /* 匹配所有的请求;   （包括.jsp）-->
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>

4.4、编写配置文件 (springmvc-servlet.xml)

编写 classpath 中的配置文件名称: springmvc-servlet.xml : 【servletname】 -servlet.xml （这里的名称是按照官方要求的）

springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 和 spring 是一样的-->

<!--  以下都需要 springmvc 的依赖-->

<!--  1. 添加处理映射器   -->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!--  2. 添加处理器适配器   -->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

<!--  1. 添加处理映射器  2. 添加处理器适配器   其实默认加载 可以不显式定义 -->
    
<!-- 3. 添加视图解析器: DispatcherServlet 给他的 ModelAndView
1. 获取 ModelAndView 的数据
2. 解析 ModelAndeView 的视图名字
3. 拼接视图名字,找到对应的视图  前缀: /WEB-INF/jsp/  内容: hello 后缀: .jsp
4. 将数据渲染到这个视图上
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/"/><!-- 前缀 因为是路径 最后 jsp/ 千万不要忘记了 ！！！ 第一次 踩的坑-->
    <property name="suffix" value=".jsp"/><!-- 后缀 -->
</bean>
<!--  handler
/ 表示项目目录 http://localhost:8088/xxz/hello 的请求 会被 Controller 接收-->
<bean id="/hello" class="com.xiao.controller.HelloController"/>
</beans>

4.5、我们要操作业务 Controller, 要么实现 Controller接口，要么增加注解；需要返回一个 ModelAndView ,装数据，封视图;

秦老师说实际开发不是这样写猜测一个注解搞定

HelloController （我们这里是通过实现 Controller接口）

package com.xiao.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 注意别导错包 不管是啥都要注意这一点
// 注意: 我们先导入(现实) Controller 接口
public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        // ModelAndView 模型和视图 ： 可以理解为 我想给前端带一点数据，并且指定某一个前端
        ModelAndView modelAndView = new ModelAndView();
        // 封装对象，放在 ModelAndView 中。 Model
        modelAndView.addObject("msg","HelloSpringMVC！");
        // 封装要跳转的视图，放在 ModelAndView 中
        modelAndView.setViewName("hello");//: /WEB-INF/jsp/hello.jsp  指向了  /WEB-INF/jsp/hello.jsp 因为 springmvc-servlet.xml 有加前缀后缀

        return modelAndView;
    }
}

4.6、将自己的类交给 SpringIOC 容器,注册 bean

注册到 springmvc-servlet.xml

<!--  handler  -->
    <bean id="/hello" class="com.xiao.controller.HelloController"/>

4.7、写要跳转的jsp 页面, 显示 ModelAndView 存放的数据,以及我们的正常页面

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

Result

流程概述

注解版【springmvc_03_annotation】

4.1 新建 Moudle ,添加web 支持, 建立包结构 com.xiao.controller

4.2 由于 Maven 可能存在资源过滤问题，我们用配置完善

父项目配有就可以不配最好也配一下

<!-- ===============  标记资源文件 自动打包导出 Start ===============-->
<!--可以照搬的死代码 父子项目时 要放在对应项目中 或者都放也行-->
<build>
    <resources>
        <!-- 标记资源文件 使其跟随项目打包出去 例如: 配置文件不打包到 Target 目录中 死代码 照搬就行-->
        <resource>
            <!-- resource 应该有默认配置 不需要写 但是java 文件下要写 才能生效-->
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>

    </resources>
</build>
<!-- ===============  标记资源文件 自动打包导出 End ===============-->

4.3 查看依赖是否导入（ lib目录是否存在于 artifact 中 `Project Strructure 中` ）

主要有 Spring 框架核心库、SpringMVC、Servlet、JSTL等。我们在父项目中已经导入了

4.4 配置 web.xml

【注意点】

注意 web.xml 的版本至少是 4.0的（如果用 maven 模板创建的可能会有版本问题添加支持则不会）
注册 DispatcherServlet
关联 SpringMVC 的配置文件
启动级别为1 (跟随服务器启动)
映射路径为 / 【如果用 /* 则包括了 .jsp 那么我们访问 index.jsp 就会查询这个 controller 那么是查不到的所以会报 404】

<?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. 注册DispatcherServlet -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--  关联一个springmvc 的配置文件: 【servletname】 -servlet.xml -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            
            <param-value>classpath*:springmvc-servlet.xml</param-value> <!-- 这里都行  classpath*: classpath:-->
        </init-param>
        <!-- 启动的级别 1 和服务器一起启动 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!-- / 匹配所有的请求; （不包括.jsp）
         /* 匹配所有的请求;   （包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

4.5 创建和配置 springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">


    <!-- 1. 设置自动扫描包，让指定包下的注解生效，由 IOC 容器统一管理 -->
    <context:component-scan base-package="com.xiao.controller"/>
    <!-- 2. 让 SpringMVC 不处理静态资源 例如 .jsp .css .js .html .mp3 .mp4 就是访问这些静态资源时 不会调用 controller    -->
    <mvc:default-servlet-handler/>
    <!--
       支持 MVC 注解驱	动
            在Spring 中一般采用 @RequestMapping 注解来完成映射关系
            要想使@RequestMapping 注解生效
            必须向上下文中注册 DefaultAnnotationHandlerMapping
            和一个 AnnotationMethodHandlerAdapter 实例
            这两个实例分别在类2级别和方法级别处理
            而 annotation-driver 配置帮助我们自动完成上诉两个实例的注入-->
    <mvc:annotation-driven/>
<!-- 3. 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/><!-- 注意最后一个 / 不能忘记 -->
        <property name="suffix" value=".jsp"/><!-- 注意最后一个 / 不能忘记 -->
    </bean>

</beans>

在视图解析器中我们把所有的视图都存放在 /WEB-INF/ 目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问

4.6 创建 Contrroller

编写一个 Java 控制类: con.xiao.controller.HelloController 注意编码规范

package com.xiao.controller;

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

// 注意不要导错包
@Controller
@RequestMapping("/HelloController")
/*
作用域 可以在 类 方法 上使用
例如:
作于类   那么 下面所有的方法都在  /HelloController 下进行
作于方法 那么 单独该方法在  /HelloController 下进行
 */
public class HelloController {
    /* 真实访问地址: 项目名/HelloController/hello.do
     (注意 如果@RequestMapping 作于类那么 会在类映射下找，他们是拼接合并关系)
     */
    @RequestMapping("/hello.do")
    public String sayHello(Model model){
        // 向模型中添加属性 msg 与 值， 可以在 jsp 页面中取出并渲染
        model.addAttribute("msg","hello,SpringMVC");
        return "hello"; // 会被视图解析器处理 进行我们配置的拼接 实际访问 /WEB-INF/jsp/hello.jsp
        // 按住 CTRL 点击  return "hello"; hello 会跳转到我们 /WEB-INF/jsp/hello.jsp 配置的位置
    }
}

@Controller 是为了让Spring IOC 日期初始化时自动扫描到;
@RequestMapping 是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是 http://localhost:8080/xxz/HelloController/hello.do 或者 /HelloController/hello.do
方法中声明Model 类型的参数是为了把 Action 中的数据带到视图中;
方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成 /WEB-INF/jsp/hello.jsp

4.7 编写视图层 hello.jsp (用于接收消息)

路径: /WEB-INF/jsp/hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${msg}
<%-- 利用 EL 表达式 取出 数据--%>
</body>
</html>

Result

【SpringMVC注解开发基本步骤】

1. 新建 web 项目 （建议使用 添加 web应用支持的方式）
2. 导入相关jar包
3. 编写 web.xml , 注册 DispatcherServlet
4. 编写 springmvc 配置文件
5. 接下来就是去创建对应的控制类 controller
6. 最后完善前端视图和 controller 之间的对应
7. 测试运行调试

使用 springMVC 必须配置的三大件:

处理器映射器、处理器适配器、视图解析器、

通常，我们只需要手动配置视图解析器、而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置。

5、Controller 配置总结【springmvc-04-controller】

SpringMVC : Controller 及 RestFul风格

控制器 Controller

控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现
控制器负责解析用户的请求并将其转换为一个模型
在 SpringMVC 中一个控制器类可以包含多个方法
在 SpringMVC 中，对于Controller 的配置方式有很多种

Controller 的几种配置方式

实现 Controller 接口

新建一个Moudle，springmvc-04-controller 。将刚才的【springmvc_02_hellomvc】拷贝一份, 我们进行操作！

Controller 是一个接口，在 org.springframework.web.servlelt.mvc 包下,接口中只有一个方法，我们通过实现 Controller 接口来使用控制器:

配置 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet-implcontroller.xml</param-value>
            <!-- 我们写两份 springmvc-servlet.xml 配置文件分别指向不同的实现方式 例如: 实现controller接口方式 或 使用注解方式-->
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!-- 在 spring中
    / 表示拦截除了 .jsp 的所有请求
    /* 拦截所有请求
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

配置 springmvc-servlet-implcontroller.xml 【注意】 springmvc-servlet.xml 的配置文件只留下 视图解析器！改名为 springmvc-servlet-implcontroller.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
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 和 spring 是一样的-->
    
    <!--  1. 添加处理映射器  其实默认加载 可以不显式定义 -->

    <!--  2. 添加处理器适配器  其实默认加载 可以不显式定义 -->

    <!-- 3. 配置视图解析器   -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/><!--    prefix 后面的 / 不能少 ！！！-->
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

删除 HelloController 我们写一个 ImplController(其实就是换个名字，但是通过删除来替换名字会好一点以免缓存问题)

package com.xiao.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 注意别导错包 不管是啥都要注意这一点
// 注意: 我们先导入(现实) Controller 接口
public class ImplController implements Controller {

    @Override    //处理请求且返回一个模型与视图对象
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        // ModelAndView 模型和视图 ： 可以理解为 我想给前端带一点数据，并且指定某一个前端
        ModelAndView modelAndView = new ModelAndView();


        // 封装对象，放在 ModelAndView 中。 Model
        modelAndView.addObject("msg","HelloSpringMVC！");
        // 封装要跳转的视图，放在 ModelAndView 中
        modelAndView.setViewName("hello");//: /WEB-INF/jsp/hello.jsp  指向了  /WEB-INF/jsp/hello.jsp 因为 springmvc-servlet.xml 有加前缀后缀

        return modelAndView;
    }
}

在 springmvc-servlet-implcontroller.xml 中注册 ImplController

<bean id="/hello" class="com.xiao.controller.ImplController"/>

其他不变我们运行测试

Result

Controller方式小结：

实现接口Controller定义控制器是较老的办法
缺点是：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller 也就是要定义多个类；定义的方式比较麻烦；

使用注解

@Controller 注解类型用于声明 Spring 类的实例是一个控制器 (在讲 IOC 时还提到了另外3个注解) ；
```
(作用相同名字不同)
@Component 组件	
@Service	service	
@Controller	controller	
@Repository dao
```
Spring 可以使用扫描机制来找到应用程序中所有基于注解的控制类，为了保证 Spring 能找到你的控制器，需要在配置文件中声明组件扫描。

【首先我们在以上 springmvc-04-controller 的操作】

配置 web.xml (调度Servlet 拦截所有请求除了静态资源)

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet-annotation.xml</param-value>
            <!-- 我们写两份 springmvc-servlet.xml 配置文件分别指向不同的实现方式 例如: 实现controller接口方式 或 使用注解方式-->
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!-- 在 spring中
    / 表示拦截除了 .jsp 的所有请求
    /* 拦截所有请求
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

配置 springmvc-servlet-implements.xml 改名为 **springmvc-servlet-annotation.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
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 和 spring 是一样的-->

    <!-- 1. 设置自动扫描包，让指定包下的注解生效，由 IOC 容器统一管理 -->
    <context:component-scan base-package="com.xiao.controller"/>
    <!-- 2. 让 SpringMVC 不处理静态资源 例如 .jsp .css .js .html .mp3 .mp4 就是访问这些静态资源时 不会调用 controller    -->
    <mvc:default-servlet-handler/>
    <!-- 3. 添加 MVC 注解驱动-->
    <mvc:annotation-driven/>

    <!-- 3. 配置视图解析器   -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/><!--    prefix 后面的 / 不能少 ！！！-->
        <property name="suffix" value=".jsp"/>
    </bean>

<!-- 【注意】 注解实现 Controller 是不用声明 Controller的 bean 的 要不然会包 already bean 异常 因为我们在注解里 @RequestMapper("/hello") 中声明过了 -->
</beans>

配置 Controller

package com.xiao.controller;

        import org.springframework.stereotype.Controller;
        import org.springframework.web.bind.annotation.RequestMapping;
        import org.springframework.ui.Model;
@Controller
// 父级映射访问路径 / 项目目录
// 被这个注解的类中的所有方法，如果返回值是 String，并且有具体页面可以跳转，那么就会被视图解析器解析;
@RequestMapping("/anno")

public class AnnoController {
    // 映射访问路径
    @RequestMapping("/sayhello") // 注意 这个 Model 不要导错包
    public String sayHello(Model module){
        System.out.println("Model");
        module.addAttribute("msg","Annotation-sayhello,Hello SpringMVC");
        return "hello";
    }


    // 映射访问路径
    @RequestMapping("/mytest") // 注意 这个 Model 不要导错包
    public String myTest(Model module){
        System.out.println("Model");
        module.addAttribute("msg","Annotation-mytest,Hello SpringMVC");
        return "hello";
    }
}

其他不变我们运行测试

Result

【注解方式是使用最多最推荐的方式】

【可以发现，我们的两个请求都可以指向一个视图，但是页面结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱耦合关系】

@RequestMapping

@RequestMapping 注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

只注解在方法上面

@Controller
public class TestController {
    @RequestMapping("/h1")
    public String test(){
        return "test";
    }
}

访问路径：http://localhost:8080/ 项目名 / h1

同时注解类与方法

@Controller
@RequestMapping("/admin")
public class TestController {
    @RequestMapping("/h1")
    public String test(){
        return "test";
    }
}

访问路径 http://localhost:8080 / 项目名/ admin /h1 , 需要先指定类的路径再指定方法的路径；

6、RestFul 【springmvc_05_RestFul】

【概念】:

RestFul 是一个资源定位及资源操作的风格。不是标准也不是协议，是一种架构设计的风格，基于这个风格设计的软件可以更加简洁、更有层次、更加易于实现缓存等机制。

【功能】

资源:互联网所有的事务都可以被抽象为资源

资源操作: 使用 post 、delete 、put 、get、实用不同方法对资源进行操作。

分别对应添加、删除、修改、查询。

传统方式操作资源 ：通过不同的参数来实现不同的效果！方法单一，post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查询,GET
http://127.0.0.1/item/saveItem.action 新增,POST
http://127.0.0.1/item/updateItem.action 更新,POST
http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

使用RestFul 操作资源: 可以通过不同的请求方式来实现不同的效果! 如下:请求地址一样，但是实现的功能可以不同！

 http://127.0.0.1/item/1 查询,GET
 http://127.0.0.1/item 新增,POST
 http://127.0.0.1/item 更新,PUT
 http://127.0.0.1/item/1 删除,DELETE

传统方式操作资源，只有 get post ，需要写不同的参数来实现不同效果比如 /delete.do 来实现删除，

而RestFul 是用 / delete 或者某代号表示删除。

【传统方式操作资源】

// =============== 原本操作资源的方式 Start ================
    //传统方式     : http://localhost:8088/xxz/mySource?a=1&b=2
    @RequestMapping("/mySource") // 原本我们的请求方式
    public String  mySource(int a ,int b,Model model){
        int i = a+b;
        model.addAttribute("msg","计算结果: "+i);
        return "hello";
    }
// =============== 原本操作资源的方式 End ================

Result 风格

// =============== RestFul 风格 Start ================
    //RestFul风格  : http://localhost:8088/xxz/restFul/1/2
//映射访问路径
@RequestMapping("/restFul/{a}/{b}") // 原本我们的请求方式
public String  restFul(@PathVariable  int a ,@PathVariable int b, Model model){
    int i = a+b;
    model.addAttribute("msg","计算结果: "+i);
    return "hello";
}
// =============== RestFul 风格 End ================

注意传入参数格式不符合可能会导致 404

【思考: 使用路径变量的好处?】

使路径变得更加简洁
获得参数更加方便，框架会自动进行类型转化
通过路径变量的类型可以约束访问参数，，如果参数类型不一样，则访问不到对应请求方法，如这里访问的是路径 /restFul/1/b,

使用method属性指定请求类型

用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如 GET、POST、HEAD、OPTIONS、PUT、PATCH、DELETE、TRACE等

我们来测试一下:

增加一个方法

    // 单独访问会报错 因为 默认走 Get 不是 Post http://localhost:8088/xxz/method/post
    @RequestMapping(value = "/method/post",method = {RequestMethod.POST})
    public String methodPost01 (Model model){
        model.addAttribute("msg","hello method  GET/Post");
        return "hello";
    }

Result

同样的请求通过请求方法不同跳转不同内容

//RequestMethod.POST  映射访问路径，必须是 POST 请求 因为我们 默认走的是 GET 所以会报错  改成 RequestMethod.GET 就可以访问
// 这里要用 path 或 value 因为 name 进行了别名 alias
     @RequestMapping(value = "/method",method = {RequestMethod.POST}) // 简化写法 @PostMapping(value = "/method")

    public String methodPost (Model model){
        model.addAttribute("msg","hello method  Post");
        return "hello";
    }
    /* 我们都是实现了 /method 的请求 但是是不同方式实现的
    以上 是用 Post 方法 以下是 Get 方法
    然而我们浏览器默认是走 Get 方法所以会访问下面的内容
    这样就实现了 同一个请求 走不同内容的目的
     */
    // 简化写法
    @GetMapping(value = "/method")
    public String methodGet (Model model){
        model.addAttribute("msg","hello method  GET");
        return "hello";
    }

小结：

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

所有的地址栏请求默认都会是 HTTP GET 类型的。

方法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

@GetMapping 是一个组合注解

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

平时使用的会比较多！

7、结果跳转方式（了解）

以下是不常用的方法了解即可平时都是用 springmvc 加视图解析器来完成跳转

7.1、ModelAndView

设置ModelAndView 对象，根据view 的名称，和视图解析器跳转到指定的页面

页面: {视图解析器前缀} + viewName ={视图解析器后缀}

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

对应的controller类

public class ControllerTest1 implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        return mv;
    }
}

7.2、ServletAPI

通过设置 Servlet API 不需要视图解析器

通过 HttpServletResponse 进行输出、实现重定向和转发

@Controller
public class ResultGo {
    @RequestMapping("/result/t1")
    public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.getWriter().println("Hello,Spring BY servlet API");
    }
    @RequestMapping("/result/t2")
    public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.sendRedirect("/index.jsp");
    }
    @RequestMapping("/result/t3")
    public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
        //转发
        req.setAttribute("msg","/result/t3");
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
    }
}

7.3、 Springmvc

【通过 Springmvc 来实现转发和重定向 - 无需视图解析器】

可以重定向到另外一个请求实现

@Controller
public class ResultSpringMVC {
    @RequestMapping("/rsm/t1")
    public String test1(){
        //转发 默认的转发
        return "/index.jsp";// 需要写完全限定名
    }
    @RequestMapping("/rsm/t2")
    public String test2(){
        //转发二  可以显示定义 转发 forward:
        return "forward:/index.jsp";
    }
    @RequestMapping("/rsm/t3")
    public String test3(){
        //重定向
        return "redirect:/index.jsp";
    }
}

【通过 SpringMVC 来实现转发和重定向 - 有视图解析器】

重定向，不需要视图解析器，本质就是重新请求一个新地址，所以注意路径问题

可以重定向到另外的一个请求实现

@Controller
public class ResultSpringMVC2 {
    @RequestMapping("/rsm2/t1")
    public String test1(){
        //转发
        return "test";
    }
    @RequestMapping("/rsm2/t2")
    public String test2(){
        //重定向  redirect:
        return "redirect:/index.jsp";
        //return "redirect:hello.do"; //hello.do为另一个请求/
    }
}

8、接受请求参数及数据回显

8.1、处理提交的数据【springmvc_06_receive】

8.1.1、提交的域名称和处理方法的参数名一致

提交数据: http://localhost:8088/xxz/hello.do?name=项晓忠

处理方法:

// 提交的域名称和处理方法的参数名一致 提交数据 : http://localhost:8088/xxz/hello.do?name=项晓忠
@RequestMapping("/hello.do")
public String hello(String name, Model model){
    System.out.println(name);
    model.addAttribute("msg",name);
    return "hello";
}

Result

#### 8.1.2、提交的域名称和处理方法的参数名不一致

提交数据: http://localhost:8088/xxz/hello02.do?username=项晓忠

处理方法:

    // 提交的域名称和处理方法的参数名  不一致 提交数据 : http://localhost:8088/xxz/hello02.do?username=项晓忠
    // 如果前端没有传递 username 会报错
    @RequestMapping("/hello02.do")
// 其实 不管名字是否一致 我们都可以加上 @RequestParam("username") 可以让我们知道 这是前端要的数据
    public String hello02(@RequestParam("username") String name, Model model){
        System.out.println(name);
        model.addAttribute("msg",name);
        return "hello";
    }

Result

8.1.3、提交的是对象的情况

要求提交的表单域和对象的属性名一致，参数使用对象即可

实体类

package com.xiao.pojo;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
@NoArgsConstructor
@ToString
@Data
public class User {
    private int id;
    private  String name;
    private int age;
}

提交数据: http://localhost:8088/xxz/user?id=1&name=项晓忠&age=25

处理方法:

    // 提交的是 对象的情况
    @RequestMapping("/user")
    public String hello03(User user ,Model model){
        System.out.println(user.toString());
        model.addAttribute("msg",user.toString());
        return "hello";
    }

Result

如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是 null

例如: http://localhost:8088/xxz/user?id=1&username=项晓忠&age=25

结果: User(id=1, name=null, age=25)

8.2、数据显示到前端

8.2.1、通过ModelAndView

就是我们一开始使用的方法，配置版的 springmvc 这里不过多解释

public class ControllerTest1 implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        return mv;
    }
}

8.2.2、通过ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
    //封装要显示到视图中的数据
    //相当于req.setAttribute("name",name);
    model.addAttribute("name",name);
    System.out.println(name);
    return "hello";
}

8.2.3、通过Model

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
    //封装要显示到视图中的数据
    //相当于req.setAttribute("name",name);
    model.addAttribute("msg",name);
    System.out.println(name);
    return "test";
}

【区别】

就对于新手而言简单来说区别就是：

Model 只有几个方法只适用于储存数据，简化 了新手对于 Model 对象的操作和理解 【一般都是使用 model】
    
ModelMap 继承了 LinkeMap,除了实现自身的一些方法，同样继承 LinkedMap 的方法和特性
    
ModelAndView 可以储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转

当然更多的以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。

请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间去学点英文，框架的官方文档永远是最好的教程。

9、乱码问题【springmvc_07_filter】

测试步骤：

我们可以在首页编写一个提交的表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/e/t" method="post">
    <input type="text" name="name">
    <input type="submit">
</form>
</body>
</html>

后台编写对应的处理类

// 从表单来的参数 提供 给 hello.jsp 
@RequestMapping("/e/t")
public String test02(Model model,@RequestParam("name") String name){ // @RequestParam("name") 虽然这里前端和后端参数名一致 但是我们也@RequestParam("name") 注解一下 表示这是前端提供的数据

    model.addAttribute("msg",name);

    return "hello";
}

提交后发现乱码

以前的乱码问题通过过滤器来解决，而 SpringMVC 给我们提供了一个过滤器，可以在 web.xml 中配置

修改了 xml文件需要重启服务器！！！

<filter>
    <filter-name>encoding</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>utf-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

添加 filter 后确实解决了乱码问题

但是我们发现 , 有些极端情况下.这个过滤器对get的支持不好 .

处理方法:

检查tomcat server.xml 配置文件中添加设置编码为 URIEncoding="utf-8"

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

自定义过滤器

package com.xiao.filter;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;
/**
 * 解决get和post请求 全部乱码的过滤器
 */
public class GenericEncodingFilter implements Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //处理response的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");
        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对request包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
}
//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {
    private HttpServletRequest request;
    //是否编码的标记
    private boolean hasEncode;
    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
        super(request);// super必须写
        this.request = request;
    }
    // 对需要增强方法 进行覆盖
    @Override
    public Map getParameterMap() {
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post请求
            try {
                // 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 处理get乱码
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }
    //取一个值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }
    //取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

在 web.xml 中配置这个过滤器即可

    <!-- ============ 网上大神写的 自定义通用 过滤器 Start ============ -->
    <!-- 听说 比 Spring 的要强-->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>com.xiao.filter.GenericEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--
    <url-pattern>/</url-pattern>  / 不包含静态资源的 所以 如果写这个是不会过滤到的 
    我们要过滤 .jsp 要写 /* 
    -->
    <!-- ============ 网上大神写的 自定义通用 过滤器 End ============ -->

10、Json 【springmvc_08_json】

10.1、什么是 Json

Json（JavaScript Object Notaion） Js对象符号是一种轻量级的数据交换格式，目前使用特别广泛
采用完全独立于编程语言的文本格式来存储和表示数据
简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言
易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率

在JavaScript 语言中，一切都是对象。因此，任何 JavaScript 支持的类型都可以通过 JSON 来表示，例如: 字符串、数字、对象、数组等。看看他的要求和语法格式。

对象表示键值对，数据由逗号分隔
花括号保存对象
方括号保存数组

Json 键值对是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也是大同小异，键值对组合中的键名写在前面并用双引号 ”“ 包裹，使用冒号 : 分隔，然后紧接着写值:

{"name": "项晓忠"}
{"age": "3"}
{"sex": "男"}

很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解:

JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串

var obj ={a:'Hello',b:'World'}; // 这是一个对象，注意键值名也是可以使用引号包裹的

var json ='{"a":"Hello","b"："World"}'; // 这是一个 JSON 字符串 本质是一个字符串

10.2、JSON 和 JavaScript 对象互转

要实现从 JSON 字符串转换位 JavaScript 对象，使用 JSON.parse() 方法

var obj = JSON.parse('{"a":"Hello","b","World"}');
// 结果是  {a:'Hello',b:'World'}

要实现从 JavaScript 对象转换位 JSON字符串,使用 JSON.stringify() 方法;

var json = JSON.stringify({a:'Hello',b:'World'});
// 结果是 ‘{"a":"hello","b":"World"}’

10.3、代码测试

Project Structure

新建一个 Moudle、springmvc_08_json 添加 web 支持

在 web 目录下新建 json-1.html ，编写测试内容

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>JSON_01_项晓忠</title>
</head>
<body>

<script type="text/javascript">
    // <script /> 是不可以 自闭合的 会报错!!!

    // 编写一个 js 对象
    var user = {
            name:"项晓忠",
            age:3,
            sex:"男"
        };

    // 将 js 对象 转化为 json 对象
    var strJson = JSON.stringify(user);
    console.log(strJson);

    // 将 JSON 字符串 转化为 JS 对象
    var user2 = JSON.parse(strJson);
    console.log(user2);
    // 打印 JS对象的属性
    console.log(user2.age,user2.name,user2.sex);
</script>


</body>
</html>

Result

10.4、Controller 返回 JSON 数据

Jackson 应该是目前比较好的 json 解析工具了
当然工具不止这一个，比如还有阿里的 fastjson 等等

10.4.1、导入 jackson 的jar包

<!-- ~~~~~~~~~~~~ json 解析工具 jackson Start   ~~~~~~~~~~~~  -->    
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.8</version>
    </dependency>
<!-- ~~~~~~~~~~~~ json 解析工具 jackson End   ~~~~~~~~~~~~  -->

10.4.2、配置 SpringMVC 需要的配置

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>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value> classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--设置启动几倍为 1 级 跟随服务器启动-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!-- 除了所有请求都被 springmvc 拦截-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- ============ SpringMVC 的字符编码过滤器 Start ============ -->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
        <!-- 拦截所有资源 /* 包括静态资源 / 不包括静态资源-->
    </filter-mapping>
    <!-- ============ SpringMVC 的字符编码过滤器 End ============ -->
</web-app>

10.4.3、编写实体类

package com.xiao.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
// 需要 导入 lombok
@ToString
@NoArgsConstructor
@AllArgsConstructor
@Data
public class User {
    private String name;
    private int age;
    private String sex;
}

10.4.4、编写 Controller

这里我们需要学习两个新东西,一个是 @ResponseBody ,一个是 ObjectMapper 对象

package com.xiao.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.xiao.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {



    @RequestMapping("/json1")
    @ResponseBody
    public String json1() throws JsonProcessingException {
        // 创建一个 jackson 的对象映射器,用来解析数据
        ObjectMapper objectMapper = new ObjectMapper();

        // 创建一个对象
        User user = new User("项晓忠1号",3,"男");
        // 将我们的对象解析成 json 格式
        String str = objectMapper.writeValueAsString(user);
        // 由于 @ResponseBody 注解, 这里会将 str 转成 json 格式返回;十分方便
    return str;
    }
}

10.4.5、配置Tomcat ，启动测试一下！

http://localhost:8088/xxz/json1

Result

发现乱码问题，我们需要设置一下他的编码格式为 utf-8 以及他返回的类型

通过 @RequestMapping 的produces 属性来实现，修改下代码

    // @RequestMapping("/json1") 会有乱码问题
    @RequestMapping(value = "/json1" ,produces="application/json;charset=ytf-8")

deploy（重新部署）后再次测试乱码解决

Result

【注意：使用json记得处理乱码问题】

10.4.6、代码优化

乱码统一解决

上一种方法比较麻烦,如果项目中有许多请求则每一个都需要添加，可以通过 Spring 配置统一指定,这样就不用每次都去处理了!

我们可以在 springmvc-servlet.xml 的配置文件上添加一段消息 StringHttpMessageConverter 转化配置

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

返回字符串统一解决

在类上直间使用 @RestController 来代替 @Controller ，这样子，里面的所有方法都只会返回 json 字符串了，不用再每一个都添加 @RestponseBody ! 我们在前后端分离开发中，一般都使用 @RestController 十分方便

// 乱码统一解决 + 返回字符串统一解决 后
@RequestMapping("/json3") // 因为我们配置了 StringHttpMessageConverter  解决json 乱码问题 所以不会乱码
public String json3() throws JsonProcessingException {
    // 创建一个 jackson 的对象映射器,用来解析数据
    ObjectMapper objectMapper = new ObjectMapper();

    // 创建一个对象
    User user = new User("项晓忠1号",3,"男");
    // 将我们的对象解析成 json 格式
    String str = objectMapper.writeValueAsString(user);
    // 由于 @ResponseBody 注解, 这里会将 str 转成 json 格式返回;十分方便
    return str;
}

Result

10.4.7、集合对象的输出

@RequestMapping("/json4")
public  String json4() throws JsonProcessingException {
    // 创建一个 jackson 的对象映射器,用来解析数据
    ObjectMapper objectMapper = new ObjectMapper();
    // 创建一组对象
    User user1 = new User("项晓忠1号", 3, "男");
    User user2 = new User("项晓忠2号", 3, "男");
    User user3 = new User("项晓忠3号", 3, "男");
    List<User> users = new ArrayList<User>();
    users.add(user1);
    users.add(user1);
    users.add(user1);

    // 将集合对象转化为 json 格式
    String strUsers = objectMapper.writeValueAsString(users);

    return strUsers;
}

Result

10.4.8、时间对象的输出

@RequestMapping("/json5")
public String json5() throws JsonProcessingException {
    // 创建一个 jackson 的对象映射器 用来解析数据
    ObjectMapper objectMapper = new ObjectMapper();

    // 创建一个时间对象 java.util.Date
    Date date = new Date();
    // 将我们的对象 解析为 json 格式
    String dateStr = objectMapper.writeValueAsString(date);

    return dateStr;
}

Result

默认日期格式会变成一个到毫秒的时间戳，是1970年1月1日到当前日期的毫秒数（1毫秒=1000微秒 1微秒=1000纳秒）
Jackson 默认会把时间转化成 timestamps 格式

【解决方案: 取消 timestamps 形式，自定义时间格式】

@RequestMapping("/json6")
public String json6() throws JsonProcessingException {
    // 创建一个 jackson 的对象映射器 用来解析数据
    ObjectMapper objectMapper = new ObjectMapper();

    // 设置不使用时间差方式 要导入这个类 我第一次用的时候 Alt+Enter 没导入 import com.fasterxml.jackson.databind.SerializationFeature;
    objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);

    // 自定义日期格式对象
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

    // 指定的日期格式
    objectMapper.setDateFormat(dateFormat);

    // 创建一个时间对象 java.util.Date
    Date date = new Date();

    // 将我们的对象 解析为 json 格式
    String dateStr = objectMapper.writeValueAsString(date);

    return dateStr;
}

Result

10.4.9、抽取为工具类

如果要经常实用的话，这样是比较麻烦的。我们可以将这些代码封装到一个工具类中;

package com.xiao.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {

    public static String getJson(Object object){
        return getJson(object,"yyyy/MM/dd HH:mm:ss");
    }

    public static String getJson(Object object,String dateFormat){
        ObjectMapper objectMapper = new ObjectMapper();
        // 不使用时间差的方式
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);

        // 自定义时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateFormat);
        // 指定时间格式
        objectMapper.setDateFormat(simpleDateFormat);

        try {
            return  objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            return null;
        }

    }

}

当我们使用工具类时，代码更加简洁了

@RequestMapping("/json7")
public String json7() {
    Date date = new Date();
    return JsonUtils.getJson(date);
}

Result

@RequestMapping("/json02")
public String json02() throws JsonProcessingException {
    // 创建一个对象
    User user = new User("项晓忠1号",3,"男");
    // 因为工具类 封装的 是设置过时间格式 的 ObjectMapper 所以你也能传入非日期的类型
    return JsonUtils.getJson(user);
}

Result

10.5、FastJson

fastJson.jar 是阿里开发的一款专门用于 java开发的包，可以方便的视线 json 对象与 javaBean对象的转化。实现 JavaBean对象与json 字符串的转化，实现 json对象与json 字符串的转化。实现json转换的方法很多，最后的实现结果都是一样的。

导入 fastjson 的依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.60</version>
</dependency>

fastjson 三个主要的类:

【JSONObject 代表 json 对象】
- JSONObject 实现了Map 接口，猜想 JSONObject 底层操作是由 Map 实现的。
- JSONObject 对应 json 对象，通过各种形式的 get() 方法可以获取 json 对象中的数据，也可利用诸如 size(),isEmpty()等方法获取键值对的个数和判断是否为空。其本质是通过实现 Map 接口并调用接口中的方法完成的
【JSONArray 代表 json 对象数组】
- 内部是有List 接口中的方法来完成操作的
【JSON 代表 JSONObject 和 JSONArray的转化】
- JSON类源码分析与使用
- 仔细观察这些方法主要是实现 json 对象，json对象数组，javabean对象，json字符串之间的相互转换

src/test/java/FastJsonDemo.java

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.xiao.pojo.User;
import java.util.ArrayList;
import java.util.List;
public class FastJsonDemo {
    public static void main(String[] args) {
        //创建一个对象
        User user1 = new User("秦疆1号", 3, "男");
        User user2 = new User("秦疆2号", 3, "男");
        User user3 = new User("秦疆3号", 3, "男");
        User user4 = new User("秦疆4号", 3, "男");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>"+str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>"+str2);
        System.out.println("\n****** JSON字符串 转 Java对象*******");
        User jp_user1=JSON.parseObject(str2,User.class);
        System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);
        System.out.println("\n****** Java对象 转 JSON对象 ******");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));
        System.out.println("\n****** JSON对象 转 Java对象 ******");
        User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
    }
}

可能遇到的问题

“Web“ facet resources

问题解决添加Web支持
Project Structure–>Modeles–>右键项目名–>Add–>Web

由于依赖缺失引起的 404 问题

Project Structure -> Artifacts -> 查看对应项目的 Output Layout web-inf 下是否有lib 如果没有要新建并导入全部lib（之后有更新都要手动导入）

一些预防手段

检查依赖是否完整

是否一同打包

需要注意的是 lib 目录应该在 WEB-INF 下 !!!

拓展

MVC 实体类
前端拿到数据传输到实体类
比如实体类 USer 有：用户名，用户密码，生日，爱好 ......20个属性
前端只要：用户名，密码
那么如果我们传输一个 User 是很浪费资源的
这个时候我们写一个 vo 包写一个 UserVo 只拿用户名和密码。（这也是一种设计思想）
pojo:User
vo: UserVo
只要没改 xml 就用 redeploy 修改 jsp 用 update-resources 其他用 restart

posted @ 2023-11-16 16:23 项晓忠阅读(49) 评论(0) 收藏举报

Deep

朝闻道，夕死可矣

36讲——SpringMVC

36讲——SpringMVC

1、 什么是 MVC

2、认识 SpringMVC

中心控制器

2、回顾 Servlet【springmvc_01_servlet 】

Test Tomcat 配置成功

4、HelloSpringMVC

配置版【springmvc_02_hellomvc】

4.2、导入SpringMVC 依赖

4.3、配置 web.xml , 注册 DispatcherServlet

4.4、编写配置文件 (springmvc-servlet.xml)

4.5、 我们要操作业务 Controller, 要么实现 Controller接口，要么增加注解；需要返回一个 ModelAndView ,装数据，封视图;

4.6、将自己的类交给 SpringIOC 容器,注册 bean

4.7、 写要跳转的jsp 页面, 显示 ModelAndView 存放的数据,以及我们的正常页面

注解版 【springmvc_03_annotation】

4.1 新建 Moudle ,添加web 支持, 建立包结构 com.xiao.controller

4.2 由于 Maven 可能存在资源过滤问题，我们用配置完善

4.3 查看 依赖 是否导入 （ lib目录是否存在于 artifact 中 Project Strructure 中 ）

4.4 配置 web.xml

4.5 创建和配置 springmvc-servlet.xml

4.6 创建 Contrroller

4.7 编写视图层 hello.jsp (用于接收消息)

5、Controller 配置总结 【springmvc-04-controller】

控制器 Controller

Controller 的几种配置方式

实现 Controller 接口

使用注解

@RequestMapping

6、RestFul 【springmvc_05_RestFul】

Result 风格

使用method属性指定请求类型

同样的请求通过请求方法不同跳转不同内容

7、结果跳转方式（了解）

7.1、ModelAndView

7.2、ServletAPI

7.3、 Springmvc

8、接受请求参数及数据回显

8.1、处理提交的数据【springmvc_06_receive】

8.1.1、提交的域名称和处理方法的参数名 一致

8.1.3、提交的是对象的情况

8.2、数据显示到前端

8.2.1、通过ModelAndView

8.2.2、 通过ModelMap

8.2.3、 通过Model

9、乱码问题【springmvc_07_filter】

10、Json 【springmvc_08_json】

10.1、什么是 Json

10.2、JSON 和 JavaScript 对象互转

10.3、代码测试

10.4、Controller 返回 JSON 数据

10.4.1、导入 jackson 的jar包

10.4.2、配置 SpringMVC 需要的配置

10.4.3、编写实体类

10.4.4、编写 Controller

10.4.5、配置Tomcat ， 启动测试一下！

10.4.6、代码优化

乱码统一解决

返回字符串统一解决

10.4.7、集合对象的输出

10.4.8、时间对象的输出

10.4.9、抽取为工具类

10.5、FastJson

可能遇到的问题

一些预防手段

拓展

公告

1、什么是 MVC

4.5、我们要操作业务 Controller, 要么实现 Controller接口，要么增加注解；需要返回一个 ModelAndView ,装数据，封视图;

4.7、写要跳转的jsp 页面, 显示 ModelAndView 存放的数据,以及我们的正常页面

注解版【springmvc_03_annotation】

4.3 查看依赖是否导入（ lib目录是否存在于 artifact 中 `Project Strructure 中` ）

5、Controller 配置总结【springmvc-04-controller】

8.1.1、提交的域名称和处理方法的参数名一致

8.2.2、通过ModelMap

8.2.3、通过Model

10.4.5、配置Tomcat ，启动测试一下！