速过 Spring mvc

入门案例

创建 Maven 工程

1. 添加 web 模块

2. 打包方式：war包

<packaging>war</packaging>

3. 引入依赖

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.1</version>
  </dependency>
  <dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
  </dependency>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>

  </dependency>
  <dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf-spring5</artifactId>
    <version>3.0.12.RELEASE</version>
  </dependency>
</dependencies>

配置 web.xml

注册 SpringMVC 的前端控制器 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">


    <!-- 配置前端 SpringMVC 的前端控制器 DispatcherServlet -->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <!--
        url-pattern 中 / 和 /* 的区别:
            /  : 匹配浏览器向服务器发送的所有请求 （不包括 .jsp）
            /* ： 匹配浏览器向服务器发送的所有请求 （包括 .jsp）
    -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

创建请求控制器

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

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

因为SpringMVC的控制器由一个POJO类担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring的ioc来管理

@Controller
public class HelloController {
    // 通过SpringMVC的自动会加上前缀和后缀
    return "index";
}

创建SpringMVC的配置文件

<?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.lyq.controller"/>

    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="utf-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                        <!-- /WEB-INF/templates/index.html -->
                        <property name="prefix" value="/WEB-INF/templates/"/>
                        <property name="suffix" value=".html"/>
                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="utf-8"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>
</beans>

@RequestMapping 注解

@RequestMapping注解的功能

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

@RequestMapping注解的位置

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

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

@Controller
@RequestMapping("/test")
public class TestRequestMappingController {
    @RequestMapping("/hello")
    public String hello(){
        return "index";
    }
}

@RequestMapping注解的value属性

@Controller
public class ProtalController {
    @RequestMapping(
            value = {"/hello", "/abc"}, 
            method = RequestMethod.GET)
    public String protal(){
        return "hello";
    }
}

SpringMVC 支持 ant 风格的路径

?：代表任意的单个字符

*：标识任意的 0 个或者多个字符

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

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

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

原始方式： /deleteUser?id=1

rest方式：/deleteUser/1

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

@RequestMapping("/test/rest/{username}/{id}")
public String testRest(@PathVariable("id") Integer id, @PathVariable("username") String username){
    System.out.println("id:" + id);
    System.out.println("username：" + username);
    return "success";
}

SpringMVC 获取请求参数

通过 ServletAPI 获取

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

@RequestMapping("/param/servletAPI")
public String getParamByServletAPI(HttpServletRequest request){
    String password = request.getParameter("password");
    String username = request.getParameter("username");
    System.out.println("username : " + username + ",password" + password);
    return "success";
}

通过 @RequestParam 注解

@RequestMapping("/param")
public String getParam(@RequestParam(value = "username", required = true) String username, String password){
    System.out.println(password);
    System.out.println(username);
    return "success";
}

@CookieValue 和 @RequestHeader

@RequestMapping("/param")
public String getParam(
        @RequestParam(value = "username", required = true) String username, String password,
        @RequestHeader("referer") String referer,
        @CookieValue("asd") String cookie

){
    System.out.println(password);
    System.out.println(username);
    return "success";
}

通过 pojo 获取参数

public String getParamBuPojo(User user){
    System.out.println(user);
    return "success";
}

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

解决获取请求参数乱码问题，可以使用SpringMVC提供的编码过滤器

在web-xml配置文件中设置

<!--配置Spring的编码过滤器-->
<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

RESTful 风格

RESTful 的实现

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

他们分别对应四种基本操作：GET用来获取资源，POST用来新建资源、PUT用来更新资源、DELETE用来删除资源

操作	传统方式	REST风格
查询操作	getUserById?id=1	user/1 -> get 请求方式
保存操作	saveUser	user -> post 请求方式
删除操作	deleteUser?id=1	user/1 -> delete 请求方式
修改操作	updateUser	user -> put 请求方式

RESTful 实现增删改查

/**
 * @description
 * 根据 id 查询用户   /user/1  -> get
 * 添加用户          /user    -> post
 * 查询所有用户       /user    -> get
 * 删除用户          /user/1  -> delete
 * 修改用户信息       /user    -> put
 */

@Controller
@RequestMapping("/user")
public class TestRestController {
    @RequestMapping
    public String getAllUser(){
        System.out.println("查询所有用户信息");
        return "success";
    }

    @GetMapping("/{id}")
    public String getUserById(@PathVariable("id") Integer id){
        System.out.println("查询 对应 id 用户 " + id);
        return "success";
    }

    @PostMapping
    public String saveUser(){
        System.out.println("保存用户信息");
        return "success";
    }

    @PutMapping
    public String updateUser(){
        System.out.println("修改用户信息");
        return "success";
    }

    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable("id") Integer id){
        System.out.println("删除用户信息" + id);
        return "success";
    }
}

SpringMVC 处理 ajax 请求

使用 @RequestBody 处理 JSON 数据

1. 导入依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.3</version>
</dependency>

2. 设置springMVC 配置文件

// 开启注解驱动
<mvc:annotation-driven></mvc:annotation-driven>

3. 编写方法

@PostMapping("/test/ajax")
public String getJsonData(@RequestBody User user){
    System.out.println(user);
    return "zzz";
}

@ResponseBody

将所标识的控制器方法的返回值作为响应报文的响应体响应到浏览器

配置方式和上述一样

@PostMapping("/test/ResponseBody")
@ResponseBody
public User testResponseBody(@RequestBody User user){
    User user1 = new User("admin","123456",1001,23,"男");
    return user1;
}

@RestController

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

文件上传和下载

文件下载

@Controller
public class FileUpAndDownController {
    @RequestMapping("/test/down")
    public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws Exception{
        ServletContext servletContext = session.getServletContext();
        String realPath = servletContext.getRealPath("static/img/1.jpg");
        InputStream is = new FileInputStream(realPath);
        byte[] bytes = new byte[is.available()];
        is.read(bytes);
        MultiValueMap<String,String> headers = new HttpHeaders();
        headers.add("Content-Disposition", "attachment;filename=1.jpg");
        HttpStatus status = HttpStatus.OK;
        ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes,headers,status);
        is.close();
        return responseEntity;
    }

}

文件上传

配置依赖

<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.3.1</version>
</dependency>

编写 controller

@RequestMapping("/test/up")
public String testUp(MultipartFile photo, HttpSession httpSession) throws IOException {
    // 获取上传的文件的文件名
    String fileName = photo.getOriginalFilename();

    // 获取 ServletContext 对象
    ServletContext servletContext = httpSession.getServletContext();

    // 获取当前工程的真实路径
    String photoPath = servletContext.getRealPath("photo");

    // 创建 photoPath 所对应的 file 对象
    File file = new File(photoPath);

    // 判断 file 对应目录是否存在
    if(!file.exists()){
        file.mkdir();
    }

    // 最终存放路径
    String finalPath = photoPath + File.separator + fileName;

    // 上传文件
    photo.transferTo(new File(finalPath));

    System.out.println(fileName);
    System.out.println(photo);
    System.out.println(httpSession);
    return "success";
}

配置文件上传解析器（springmvc.xml）

<!-- 配置文件上传解析器   -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
</bean>

解决文件上传出现重名问题（UUID）

public String testUp(MultipartFile photo, HttpSession httpSession) throws IOException {
    // 获取上传的文件的文件名
    String fileName = photo.getOriginalFilename();

    // 获取上传的文件的后缀名
    String hzName = fileName.substring(fileName.lastIndexOf("."));
    
    // 获取 uuid
    String uuid = UUID.randomUUID().toString();
    
    fileName = uuid + hzName;

    // 获取 ServletContext 对象
    ServletContext servletContext = httpSession.getServletContext();

    // 获取当前工程的真实路径
    String photoPath = servletContext.getRealPath("photo");

    // 创建 photoPath 所对应的 file 对象
    File file = new File(photoPath);

    // 判断 file 对应目录是否存在
    if(!file.exists()){
        file.mkdir();
    }

    // 最终存放路径
    String finalPath = photoPath + File.separator + fileName;

    // 上传文件
    photo.transferTo(new File(finalPath));

    return "success";
}

拦截器

拦截器的配置

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

SpringMVC 中的拦截器需要实现HandlerIntreceptor

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

编写拦截器类

public class InterceptorController implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle");

        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");

    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }
}

将拦截器配置到spring-mvc中

<mvc:interceptors>
    <bean class="com.lyq.interceptor.InterceptorController"/>
</mvc:interceptors>

mvc:interceptors 拦截器配置

<mvc:interceptors>
    <!-- bean 和 ref 标签所配置的拦截器默认对 DispatcherServlet 处理的所有请求进行拦截 -->
    <!--<ref bean="interceptorController"/>-->
    <mvc:interceptor>
        <!-- 配置需要拦截的请求的路径，/** 拦截所有请求 -->
        <mvc:mapping path="/**"/>
        <!-- exclude-mapping 白名单 -->
        <mvc:exclude-mapping path="/abc"/>
        <ref bean="interceptorController"/>
    </mvc:interceptor>
</mvc:interceptors>

多个拦截器的执行顺序

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

preHandle()按照配置的顺序执行

postHandle() 和 afterCompletion()按照配置的反序执行

异常处理器

基于配置的异常处理

SpringMVC 提供了一个处理控制器方法执行过程中能够所出现的异常的接口：HandlerExceptionResolver

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

SpringMVC 提供了自定义的异常处理器 SimpleMappingExceptionResolver，使用方式：

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
            <!-- key 设置出现的异常，value 设置出现异常时要跳转的页面所对应的逻辑视图 -->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!-- 设置共享在请求域中的异常信息的属性名 -->
    <property name="exceptionAttribute" value="ex"></property>
</bean>

基于注解配置异常处理

// 作用：将当前类标识为异常处理组件
@ControllerAdvice
public class ExceptionController {

    @ExceptionHandler(ArithmeticException.class)
    public String handleException(Throwable ex,Model model){
        System.out.println("xxxxxxxxxxxx");
        // ex 表示控制器方法所出现的异常
        model.addAttribute("ex",ex);
        return "error";
    }
}

注解配置SpringMVC

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

目录结构

FirstInterceptor拦截器类

public class FirstInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

WebInit 初始化类

public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
    // 设置一个配置类，代替spring的配置文件
    protected Class<?>[] getRootConfigClasses() {

        return new Class[]{SpringConfig.class};
    }

    // 设置一个配置类，代替springMVC的配置文件
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }
    // 设置 springMVC 的前端控制器 DispatcherServlet 的 url-pattern
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    @Override
    // 设置当前的过滤器
    protected Filter[] getServletFilters() {
        // 创建编码过滤器
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("utf-8");
        characterEncodingFilter.setForceEncoding(true);

        // 创建处理请求方式的过滤器
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
    }
}

WebConfig类

/**
 * Description: 代替 SpringMVC 的配置文件
 * 扫描组件、视图解析器、默认的servlet、mvc的注解驱动
 * 视图控制器、文件上传解析器、拦截器、异常解析器
 */
// 将类标识为配置类
@Configuration
// 扫描组件
@ComponentScan("com.lyq.controller")
// 开启mvc注解驱动
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    // 默认的 servlet 处理静态资源
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    // 配置视图解析器
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }

    // 标识方法的返回值为一个 bean，bean的id为方法的方法名
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        return new CommonsMultipartResolver();
    }

    // 配置拦截器
    public void addInterceptors(InterceptorRegistry registry) {
        FirstInterceptor firstInterceptor = new FirstInterceptor();
        // 添加拦截器以及路径，排除某些路径
        registry.addInterceptor(firstInterceptor).addPathPatterns("/**").excludePathPatterns("/abc");
    }
    // 配置异常解析器
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver simpleMappingExceptionResolver = new SimpleMappingExceptionResolver();
        Properties properties = new Properties();
        properties.setProperty("java.lang.ArithmeticException", "error");
        simpleMappingExceptionResolver.setExceptionMappings(properties);
        simpleMappingExceptionResolver.setExceptionAttribute("ex");
        resolvers.add(simpleMappingExceptionResolver);
    }

    // 配置生成模板解析器
    @Bean
    public ITemplateResolver templateResolver(){
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("utf-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }

    // 生成模板引擎并为模板引擎注入模板解析器
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver){
        SpringTemplateEngine springTemplateEngine = new SpringTemplateEngine();
        springTemplateEngine.setTemplateResolver(templateResolver);
        return springTemplateEngine;
    }

    // 生成视图解析器并未解析器注入模板引擎
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine){
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setCharacterEncoding("utf-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }
}

Spring配置类

// 代替 spring 的配置文件
// 将类标识为配置类
@Configuration
public class SpringConfig {

}

SpringMVC 常用组件

• DispatcherServlet：前端控制器

  作用：统一处理请求和相应，整个流程控制的中心

• HandlerMapping：处理器映射器

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

• Handler：处理器

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

• HandlerAdapter：处理器适配器

  作用：通过HandlerAdapter对处理器进行执行

• ViewResolver：视图解析器

  作用：进行视图解析，得到相应视图