SpringMVC 是一种基于JAVA实现MVC模型的轻量级Web框架

SpringMVC简介

开发流程

导入坐标
初始化SpringMVC环境

import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringMvcConfig {
}

创建SpringMVC控制器类(等同于Servlet功能)

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

@Controller
public class UserController {
    @RequestMapping("/save")
    public String save(){
        System.out.println("save,,,");
        return "1";
    }
}

设定SpringMVC加载对应的bean

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.blog.controller")
public class SpringMvcConfig {
}

初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC请求拦截的路径

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;

/**
 * AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类
 * 1. createServletApplicationContext()方法，创建Servlet容器时，加载SpringMVC对应的bean并放入
 * WebApplicationContext对象范围中，而WebApplicationContext的作用范围为ServletContext范围
 * 即整个web容器范围
 * 2. getServletMappings()方法，设定SpringMVC对应的请求映射路径，设置为/表示拦截所有请求，任意请求都将
 * 转入到SpringMVC进行处理
 * 3. createRootApplicationContext()方法，如果创建servlet容器时需要加载非SpringMVC对应的bean，使用
 * 当前方法进行，使用方式同createServletApplicationContext()
 */

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
//    加载配置类
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return (WebApplicationContext) ctx;
    }
//    哪些类通过SpringMVC处理
    @Override
    protected String[] getServletMappings() {
//        所有
        return new String[]{"/"};
    }

    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

6.设定请求方法的返回值为字符串类型，并返回自定义json数据

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

@Controller
public class UserController {
    @RequestMapping("/save")
//    返回字符串不做页面地址处理，直接返回响应体
    @ResponseBody
    public String save(){
        System.out.println("save,,,");
        return "1";
    }
}

工作流程

bean加载控制

设置地址

解决地址冲突问题，设置前缀

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

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/save")
//    返回字符串不做页面地址处理，直接返回响应体
    @ResponseBody
    public String save(){
        System.out.println("save,,,");
        return "1";
    }
}

get请求和post请求

使用注解区分请求类型

@GetMapping,@PostMapping,@DeleteMapping,@RequestMapping

解决POST请求中文乱码问题

import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
import javax.servlet.Filter;
public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

//    POST请求中文处理乱码
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

配置资源路径

配置静态资源的路径，可以通过地址访问资源

import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
//        当访问/pages/？？？？时，走/pages目录下的内容
        registry.addResourceHandler("/pages/**","/pages/");
    }

    @Override
    protected void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowCredentials(true)
                .allowedMethods("POST", "GET", "PUT", "OPTIONS", "DELETE")
                .allowedOrigins("*");
    }
}

传参

普通传参(同名不同名)

//同名的参数会直接对应赋值
//不同名使用@RequestParam进行联系
@RequestMapping("/save1")
@ResponseBody
public String save1(@RequestParam("name") String username, String age){
    System.out.println(username+age);
    return "1";
}

POJO类传参

@RequestMapping("/save3")
@ResponseBody
public String save3(User user){
    System.out.println(user);
    return "1";
}

POJO类嵌套传参

数组传参

与数组同名的参数都会放入数组

集合传参

@RequestMapping("/save4")
@ResponseBody
public String save4(@RequestParam List<String> hobby){
    System.out.println(hobby);
    return "1";
}

json传参

导入坐标
在配置类SpringMvcConfig中加入注解@EnableWebMvc
在形参前加@RequestBody

集合类型，数组类型，POJO类型,POJO嵌套类型(只需要加@RequestBody)

@Controller
@RequestMapping("/json")
public class JsonController {
    @RequestMapping("/jsonByList")
    @ResponseBody
    public String jsonByList(@RequestBody List<String> hobby){
        System.out.println(hobby);
        return "1";
    }
}

日期类型传参

默认日期传参 yyyy/MM/dd
使用@DateTimeFormat注解

@RequestMapping("/date2")
@ResponseBody
public String date2(Date date,
                    @DateTimeFormat(pattern = "yyyy-MM-dd") Date date1,
                    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date date2){
    System.out.println(date);
    System.out.println(date1);
    System.out.println(date2);
    return "1";
}

返回数据封装，便于与前端交互

Result.class

package com.blog.vo;

import lombok.Data;

@Data
public class Result {
    //描述统一格式中的数据
    private Object data;
    //描述统一格式中的编码，用于区分操作，可以简化配置0或1表示成功失败
    private Integer code;
    //描述统一格式中的消息，可选属性
    private String msg;

    public Result() {
    }

    public Result(Integer code, String msg,Object data) {
        this.data = data;
        this.code = code;
        this.msg = msg;
    }
}

code.class

package com.blog.vo;

//状态码
public class Code {
      public static final Integer SAVE_OK = 200;
      public static final Integer DELETE_OK = 200;
      public static final Integer UPDATE_OK = 200;
      public static final Integer GET_OK = 200;
 
      public static final Integer SAVE_ERR = 20010;
      public static final Integer DELETE_ERR = 20020;
      public static final Integer UPDATE_ERR = 20030;
      public static final Integer GET_ERR = 20040;
}

项目异常处理

异常处理器

自定义异常类

package com.blog.exception;

public class SystemException extends RuntimeException{
    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public SystemException(Integer code,String msg){
        super(msg);
        this.code = code;
    }
    public SystemException(Integer code,String msg,Throwable cause){
        super(msg,cause);
        this.code = code;
    }
}

编写异常处理类，要在SpringMvcConfig.java中的@ComponentScan中声明controller

@ComponentScan({"com.blog.controller", "com.blog.config"})

在controller层编写ProjectExceptionAdvice.java，声明各种异常的处理方式

@RestControllerAdvice
public class ProjectExceptionAdvice {
    @ExceptionHandler(SystemException.class)
    public Result doException(SystemException ex){
        //记录日志
        //通知运维
        //给开发发邮件
        return new Result(ex.getCode(),ex.getMessage(),null);
    }

    @ExceptionHandler(BusinessException.class)
    public Result doException(BusinessException ex){
        return new Result(ex.getCode(),ex.getMessage(),null);
    }

    @ExceptionHandler(Exception.class)
    public Result doException(Exception ex){
        return new Result(Code.SYSTEM_UNKNOW_ERR,"系统繁忙，请稍后再试！",null);
    }
}

拦截器

编写拦截器类 token拦截

package com.blog.controller.interceptor;

import com.blog.utils.JWTUtils;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

/**
 * 此处拦截器
 */
@Component
public class TokenInterceptor implements HandlerInterceptor {

    /**
     * 拦截器和过滤器的区别
     * 1.拦截器针对访问控制器进行拦截
     * 及 @RequestMapping(value = {"/test"})
     * 简而言说就是访问方法的url
     * 应用：可以作为权限的判断，
     * 2.过滤器则是针对全局的请求
     * 包括：css/js/html/jpg/png/git/...
     * 及静态文件
     */

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("token拦截...");
        response.setCharacterEncoding("utf-8");
        // 获取请求头
        String token = request.getHeader("token");
        System.out.println(token);
        //如果已经登录，不拦截
        if (null != token) {
            //验证token是否正确
            boolean result = JWTUtils.verify(token);
            System.out.println("是否通过拦截器:" + result);
            if (!result) {
                return false;
            }
            return true;
        }
        return true;
    }

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

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

配置拦截器 SpringMvcConfig.java

@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(projectInterceptor).addPathPatterns("/**");
    registry.addInterceptor(TokenInterceptor)
            .addPathPatterns("/**")
            .excludePathPatterns("/login");
}

REST风格

设定http请求动作（动词）@RequestMapping(value = "/save",method = RequestMethod.POST)
设定请求参数（路径变量）@RequestMapping(value = "/save/{id}",method = RequestMethod.POST)；路径变量需要加上@PathVariable注解

注解

1. @ComponentScan("com.blog.controller") ：扫描注解
2. @Controller : 类注解；SpringMVC控制器类定义上方；设定SpringMVC的核心控制器bean
3. @RequestMapping ：方法注解；SpringMVC控制器方法定义上方；设置当前控制器方法请求访问路径
4. @ResponseBody ：方法注解；SpringMVC控制器方法定义上方；设置当前控制器方法响应内容为当前返回值，无需解析
5. @ComponentScan ：类注解；SpringMVC控制器类定义上方；设置需要扫描的范围
6. @RequestParam ：形参注解；SpringMVC控制器方法形参定义前面；绑定请求参数与处理器方法形参之间的关系；参数：required，defaultValue
7. @Responsebody ：方法注解；SpringMVC控制器方法定义上方；设置当前控制器方法响应内容为当前返回值，无需解析
8. @GetMapping,@PostMapping,@PutMapping,@DeleteMapping ：方法注解；基于SpringMVC的RESTful开发控制器方法定义上方；设置当前控制器方法请求访问路径与请求动作，每种对应一个请求动作
9. @RestController ：类注解；基于SpringMVC的RESTful开发控制器类定义上方；设置当前控制器类为REStful风格，等同于@Controller与@ResponseBody两个注解组合功能
10. @PathVariable ：配置路径参数
11. @Data ：配置
12. @RestControllerAdvice ：类注解；Rest风格开发的控制器增强类定义上方；为Rest风格开发的控制器做增强；此注解自带@ResponseBody，和@Component，具备对应的功能
13. @ExceptionHandler ：方法注解；专用于异常处理的控制器方法上方；设置指定异常的处理方案，功能等同于控制器方法，出现异常后终止控制器执行，并转入当前方法执行；此类方法可以根据处理的异常不同，制作多个方法分别处理对应的异常

SSM整合

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>SpringMVC</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.12.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.14.1</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.3.7</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.3.7</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.11</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.7</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.26</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.9</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
      </plugin>
    </plugins>
  </build>
</project>

配置整合

JdbcConfig.class

package com.blog.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

MybatisConfig.class

package com.blog.config;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("com.blog.domain");
        return factoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.blog.dao");
        return msc;
    }

}

ServletConfig.class

package com.blog.config;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;

import javax.annotation.processing.Filer;
import javax.servlet.Filter;

/**
 * AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类
 * 1. createServletApplicationContext()方法，创建Servlet容器时，加载SpringMVC对应的bean并放入
 * WebApplicationContext对象范围中，而WebApplicationContext的作用范围为ServletContext范围
 * 即整个web容器范围
 * 2. getServletMappings()方法，设定SpringMVC对应的请求映射路径，设置为/表示拦截所有请求，任意请求都将
 * 转入到SpringMVC进行处理
 * 3. createRootApplicationContext()方法，如果创建servlet容器时需要加载非SpringMVC对应的bean，使用
 * 当前方法进行，使用方式同createServletApplicationContext()
 */
//public class ServletConfig extends AbstractDispatcherServletInitializer {
////    加载配置类
//    @Override
//    protected WebApplicationContext createServletApplicationContext() {
//        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
//        ctx.register(SpringMvcConfig.class);
//        return (WebApplicationContext) ctx;
//    }
////    哪些类通过SpringMVC处理
//    @Override
//    protected String[] getServletMappings() {
////        所有
//        return new String[]{"/"};
//    }
//
//    @Override
//    protected WebApplicationContext createRootApplicationContext() {
//        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
//        ctx.register(SpringConfig.class);
//        return (WebApplicationContext) ctx;
//    }
//}
public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

//    POST请求中文处理乱码
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

SpringConfig.class

package com.blog.config;

import org.springframework.context.annotation.*;
import org.springframework.stereotype.Controller;

@Configuration
@ComponentScan({"com.blog.service"})
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MyBatisConfig.class})
//@ComponentScan(value = "com.blog",
//        excludeFilters = @ComponentScan.Filter(
//                type = FilterType.ANNOTATION,
//                classes = Controller.class
//        )
//)
public class SpringConfig {
}

SpringMvcConfig.class

package com.blog.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
@ComponentScan({"com.blog.controller", "com.blog.config"})
//开启json数据转对象
@EnableWebMvc
public class SpringMvcConfig {
}

SpringMvcSupport.class

package com.blog.config;

import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
//        当访问/pages/？？？？时，走/pages目录下的内容
        registry.addResourceHandler("/pages/**","/pages/");
    }

    @Override
    protected void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowCredentials(true)
                .allowedMethods("POST", "GET", "PUT", "OPTIONS", "DELETE")
                .allowedOrigins("*");
    }
}

SSM框架初体验