• 猿创征文｜Spring MVC学习大总结

    Spring MVC

    1：Spring MVC入门案例

    1.1：导入相关依赖

    <groupId>com.ysjgroupId>
  <artifactId>springmvc_01_quickstartartifactId>
  <version>1.0-SNAPSHOTversion>
  <packaging>warpackaging>

  <dependencies>

    <dependency>
      <groupId>javax.servletgroupId>
      <artifactId>javax.servlet-apiartifactId>
      <version>3.1.0version>
      <scope>providedscope>
    dependency>

    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webmvcartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
  dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.mavengroupId>
        <artifactId>tomcat7-maven-pluginartifactId>
        <version>2.1version>
        <configuration>
          <port>80port>
          <path>/path>
        configuration>
      plugin>
    plugins>
  build>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    1.2：创建Spring MVC配置类

    //springmvc配置类，本质上还是一个spring配置类
@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}

    • 1
    • 2
    • 3
    • 4
    • 5

    1.3：创建并配置表现层控制的bean

    //定义表现层控制器bean
@Controller
public class UserController {

    //设置映射路径为/save，即外部访问路径
    @RequestMapping("/save")
    //设置当前操作返回结果为指定json数据（本质上是一个字符串信息）
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }

    //设置映射路径为/delete，即外部访问路径
    @RequestMapping("/delete")
    @ResponseBody
    public String delete(){
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    1.4：创建web容器配置类

    //web容器配置类
public class test extends AbstractDispatcherServletInitializer {
   //加载Spring MVC配置类，产生SpringMVC容器（本质上还是Spring容器）
    protected WebApplicationContext createServletApplicationContext() {
       //初始化WebApplicationContext对象
        AnnotationConfigWebApplicationContext webApplicationContext = new AnnotationConfigWebApplicationContext();
       //加载指定配置类
        webApplicationContext.register(SpringMvcConfig.class);
        return webApplicationContext;
    }
    //设置由SpringMVC控制器处理的请求映射路径    
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    //加载Spring配置类
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    2：bean的加载及控制

    目的:为了防止SpringMVC所管控的bean被Spring加载

    2.1：设置过滤规则

    @Configuration
//@ComponentScan({"com.itheima.service","com.itheima.dao"})
//设置spring配置类加载bean时的过滤规则，当前要求排除掉表现层对应的bean
//excludeFilters属性：设置扫描加载bean时，排除的过滤规则
//type属性：设置排除规则，当前使用按照bean定义时的注解类型进行排除
//classes属性：设置排除的具体注解类，当前设置排除@Controller定义的bean
@ComponentScan(value="com.itheima",
    excludeFilters = @ComponentScan.Filter(
        type = FilterType.ANNOTATION,
        classes = Controller.class
    )
)
public class SpringConfig {
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    2.2：小注意点

    当Spring配置类配置相应的过滤规则后，SpringMVC配置类要有以下注意点：

    • Spring中把它所需要扫描的包路径全给加好
    • 第二种：
    @Configuration  //如果加了bean声明，那么把包扫描去掉，否则Spring过滤后，SpringMVC会再次加载
//@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}

    • 1
    • 2
    • 3
    • 4

    2.3：web配置类简化开发

    原始的是继承AbstractDispatcherServletInitializer接口，并实现三个方法。

    现在简化开发继承了AbstractAnnotationConfigDispatcherServletInitializer接口，反射原理。

    例：

    //web配置类简化开发，仅设置配置类类名即可
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    2.4:测试

    现在测试要创建AnnotationConfigApplicationContext对象

    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

    • 1

    3：请求映射路径

    @Controller
//类上方配置的请求映射与方法上面配置的请求映射连接在一起，形成完整的请求映射路径
@RequestMapping("/user")
public class UserController {
    //请求路径映射
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }
    //请求路径映射
    @RequestMapping("/delete")
    @ResponseBody
    public String delete(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    4：参数传递

    4.1：普通参数

    4.1.1：请求参数名与形参名相同时
    //普通参数：请求参数与形参名称对应即可完成参数传递
@RequestMapping("/commonParam")
@ResponseBody
public String commonParam(String name ,int age){
    System.out.println("普通参数传递 name ==> "+name);
    System.out.println("普通参数传递 age ==> "+age);
    return "{'module':'common param'}";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    4.1.2：请求参数名与形参名不同时
    //普通参数：请求参数名与形参名不同时，使用@RequestParam注解关联请求参数名称与形参名称之间的关系
@RequestMapping("/commonParamDifferentName")
@ResponseBody
public String commonParamDifferentName(@RequestParam("name") String userName , int age){
    System.out.println("普通参数传递 userName ==> "+userName);
    System.out.println("普通参数传递 age ==> "+age);
    return "{'module':'common param different name'}";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    4.2：POJO参数

    4.2.1：请求参数与形参对象中的属性对应
    //POJO参数：请求参数与形参对象中的属性对应即可完成参数传递
@RequestMapping("/pojoParam")
@ResponseBody
public String pojoParam(User user){
    System.out.println("pojo参数传递 user ==> "+user);
    return "{'module':'pojo param'}";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    4.2.2：嵌套POJO参数
    //嵌套POJO参数：嵌套属性按照层次结构设定名称即可完成参数传递
@RequestMapping("/pojoContainPojoParam")
@ResponseBody
public String pojoContainPojoParam(User user){
    System.out.println("pojo嵌套pojo参数传递 user ==> "+user);
    return "{'module':'pojo contain pojo param'}";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4.3:数组参数

    //数组参数：同名请求参数可以直接映射到对应名称的形参数组对象中
@RequestMapping("/arrayParam")
@ResponseBody
public String arrayParam(String[] likes){
    System.out.println("数组参数传递 likes ==> "+ Arrays.toString(likes));
    return "{'module':'array param'}";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4.4：集合参数

    //集合参数：同名请求参数可以使用@RequestParam注解映射到对应名称的集合对象中作为数据
@RequestMapping("/listParam")
@ResponseBody
public String listParam(@RequestParam List<String> likes){
    System.out.println("集合参数传递 likes ==> "+ likes);
    return "{'module':'list param'}";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4.5：JSON参数传递

    第一步：加上依赖

    <dependency>
  <groupId>com.fasterxml.jackson.coregroupId>
  <artifactId>jackson-databindartifactId>
  <version>2.9.0version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5

    第二部：开启JSON数据转换成对象的功能（在配置文件里加上@EnableWebMvc）

    //开启json数据类型自动转换
@EnableWebMvc
public class SpringMvcConfig {
}

    • 1
    • 2
    • 3
    • 4

    第三步：使用@RequestBody（此注解一个处理器方法只能用一次）注解将外部传递的json数组数据映射到形参的集合对象中作为数据

    4.5.1：集合参数（JSON格式）
    //集合参数：json格式
//1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
//2.使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
@RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List<String> likes){
    System.out.println("list common(json)参数传递 list ==> "+likes);
    return "{'module':'list common for json param'}";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    4.5.2:POJO参数：json格式
    //POJO参数：json格式
//1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
//2.使用@RequestBody注解将外部传递的json数据映射到形参的实体类对象中，要求属性名称一一对应
@RequestMapping("/pojoParamForJson")
@ResponseBody
public String pojoParamForJson(@RequestBody User user){
    System.out.println("pojo(json)参数传递 user ==> "+user);
    return "{'module':'pojo for json param'}";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    4.5.3：集合参数：json格式
    //1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
//2.使用@RequestBody注解将外部传递的json数组数据映射到形参的保存实体类对象的集合对象中，要求属性名称一一对应
@RequestMapping("/listPojoParamForJson")
@ResponseBody
public String listPojoParamForJson(@RequestBody List<User> list){
    System.out.println("list pojo(json)参数传递 list ==> "+list);
    return "{'module':'list pojo for json param'}";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    postman：参数传递格式

    [
        {
        "name":"ysj",
        "age":15,
        "address":{
        "province":"hh",
        "city":"j"
        }
        }
  ]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    4.6：日期参数

    • 使用@DateTimeFormat注解设置日期类型数据格式，默认格式yyyy/MM/dd

      //使用@DateTimeFormat注解设置日期类型数据格式，默认格式yyyy/MM/dd
@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
                        @DateTimeFormat(pattern="yyyy-MM-dd") Date date1,
                        @DateTimeFormat(pattern="yyyy/MM/dd HH:mm:ss") Date date2){
    System.out.println("参数传递 date ==> "+date);
    System.out.println("参数传递 date1(yyyy-MM-dd) ==> "+date1);
    System.out.println("参数传递 date2(yyyy/MM/dd HH:mm:ss) ==> "+date2);
    return "{'module':'data param'}";
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11

    4.7：@RequestParam和@RequestBody的区别

    • 前者：用于url地址和form表单传参
    • 后者：用于JSON数据传参
    4.8：神奇的convert接口

    在这里插入图片描述

    5：请求与相应

    • 在方法前加上@ResponseBody可将对象数据转换为JSON数据

    • 例子

      //响应POJO对象
//返回值为实体类对象，设置返回值为实体类类型，即可实现返回对应对象的json数据，需要依赖@ResponseBody注解和@EnableWebMvc注解
@RequestMapping("/toJsonPOJO")
@ResponseBody
public User toJsonPOJO(){
    System.out.println("返回json对象数据");
    User user = new User();
    user.setName("itcast");
    user.setAge(15);
    return user;
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11

    6：REST风格

    在这里插入图片描述

    入门案例：一切尽在不言中

    @RestController //用@RestController替换@ResponseBody和@Controller,简化下呗
@RequestMapping(value = "/tests",produces = { "application/json;charset=UTF-8" })//设置类的访问地址，与类中的方法访问地址连接在一起作为访问方法的URL后面那一截
public class testController {

    @PostMapping  //保存
    public String save(@RequestBody User user){
        System.out.println("保存"+user.getName()+"成功");
        return "保存"+user.getName()+"成功";
//    return "Hello World!";
    }

    @DeleteMapping("/{id}")  //id删除
    public String delete(@PathVariable int id){
        System.out.println("删除id为"+id+"的用户成功");
        return "删除id为"+id+"的用户成功";
    }

    @PutMapping  //更新
    public String update(@RequestBody User user){
        System.out.println("更新id为" + user.getId() +"的用户成功");
        return "更新id为" + user.getId() +"的用户成功";
    }

    @GetMapping("/{id}")  //id查询
    public String selectById(@PathVariable int id){

        System.out.println(id);
        return "查询成功";
    }

    @GetMapping
    public String selectALL(){
        return "查询成功";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    7：配置静态资源放行

    假设一些资源被SpringMVC拦截了，我们可以进行如下配置让其可访问

    //设置静态资源访问过滤，当前类要声明为配置类，以被加载
@Configuration
public class SpringMvcSupport  extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        //当访问/pages/???路径的页面时，从pages/目录下查找内容
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    8：乱码问题处理

    • 后端接收前端访问数据乱码：在web配置类中重写getServletFilters()方法
    //乱码处理
@Override
protected Filter[] getServletFilters() {
    CharacterEncodingFilter filter = new CharacterEncodingFilter();
    filter.setEncoding("UTF-8");
    return new Filter[]{filter};
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 后端返回给前端数据乱码：在@RequestMapping上加上produces = { "application/json;charset=UTF-8" }
  • 相关阅读:
    mysql reset slave reset master
    【项目部署】网页无法打开，xxx.xxx.xxx.xxx目前无法处理此请求
    Spring Cloud 面试题总结
    ChromeOptions 设置WebDriver/ChromeDriver的请求头参数
    Karatsuba乘法
    【mybatis注解开发+二级缓存】
    【java表达式引擎】二、表达式引擎finexpr
    相同二叉树和镜面二叉树问题
    stm32cubemx hal学习记录：RNG
    堆排序算法
  • 原文地址：https://blog.csdn.net/qq_54217349/article/details/126752716