devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

03—Spring MVC

作者：小舞很执着 | 2024-08-02 20:59:57

赞

踩

03—Spring MVC

概述

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

入门案例

创建一个Maven项目，在pom.xml中导入依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.  
  7.     <groupId>com.spark</groupId>
  8.     <artifactId>springmvc-start</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  10.  
  11.     <properties>
  12.         <maven.compiler.source>8</maven.compiler.source>
  13.         <maven.compiler.target>8</maven.compiler.target>
  14.     </properties>
  15.     <dependencies>
  16.         <dependency>
  17.             <groupId>org.springframework</groupId>
  18.             <artifactId>spring-webmvc</artifactId>
  19.             <version>5.2.10.RELEASE</version>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>javax.servlet</groupId>
  23.             <artifactId>javax.servlet-api</artifactId>
  24.             <version>3.1.0</version>
  25.             <scope>provided</scope>
  26.         </dependency>
  27.     </dependencies>
  28. </project>

编写表现层Controller

  1. package com.spark.controller;
  2.  
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.ResponseBody;
  6.  
  7. /**
  8.  * UserController class
  9.  * description: UserController
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/7/26
  13.  */
  14. @Controller
  15. public class UserController {
  16.     
  17.     // 提供方法的请求路径
  18.     @RequestMapping("/save")
  19.     @ResponseBody
  20.     public String saveUser(){
  21.         System.out.println("user save ...");
  22.         return "{module:save}";
  23.     }
  24. }

编写SpringMVC配置类加载Controller层注册的Bean

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5.  
  6. /**
  7.  * SpringmvcConfig class
  8.  * description: SpringMvcConfig
  9.  *
  10.  * @author Administrator
  11.  * @date 2023/7/26
  12.  */
  13. @Configuration
  14. @ComponentScan("com.spark.controller")
  15. public class SpringMvcConfig {
  16.  
  17. }

编写Servlet容器配置类加载SpringMVC配置类

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.context.WebApplicationContext;
  5. import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
  6. import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;
  7.  
  8. /**
  9.  * ServletInitConfig class
  10.  * description: ServletInitConfig
  11.  *
  12.  * @author Administrator
  13.  * @date 2023/7/26
  14.  */
  15. @Configuration
  16. public class ServletInitConfig extends AbstractDispatcherServletInitializer {
  17.  
  18.     @Override
  19.     protected WebApplicationContext createServletApplicationContext() {
  20.         AnnotationConfigWebApplicationContext atx = new AnnotationConfigWebApplicationContext();
  21.         atx.register(SpringMvcConfig.class);
  22.         return atx;
  23.     }
  24.  
  25.     @Override
  26.     protected String[] getServletMappings() {
  27.         // 所有请求
  28.         return new String[] {"/"};
  29.     }
  30.  
  31.     @Override
  32.     protected WebApplicationContext createRootApplicationContext() {
  33.         return null;
  34.     }
  35. }

配置Tomcat

打开浏览器访问 URL + Controller定义的方法请求路径查看结果

http://localhost:8082/springmvc_start/save

入门案例的工作流程

① 服务器启动初始化流程

  1. 服务器启动，执行ServletInitConfig类初始化web容器
  2. 执行createServletApplicationContext方法，创建了WebApplicationContext对象
  3. 加载SpringMVC配置类
  4. 执行@ComponentScan加载对应bean
  5. 加载UserController，每个@RequestMapping的名称对应一个具体的方法
  6. 执行getServletMappings方法，定义所有请求都通过SpringMVC 

② 发送save请求过程

  1. 发送请求
  2. Web容器发现所有请求都通过SpringMVC，将请求交由SpringMVC处理
  3. 解析请求路径/save
  4. 匹配到对应的方法save()
  5. 执行save()方法
  6. 检测到@ResponseBody直接将save()返回值作为响应体返回给请求方 

Bean加载过程 

一个完整的SpringMVC请求涉及到有表现层(Controller)、数据层(Dao)、业务层(Service)

Controller层由SpringMVC加载，业务层和数据层由Spring加载

Web容器启动后，Spring会加载到SpringMVC的bean，如何进行避免？ 

加载Spring控制的bean时排除掉SpringMVC控制的bean

方式一：Spring加载的bean设定扫描范围，并排除掉Controller包内的bean

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.FilterType;
  6.  
  7. /**
  8.  * SpringConfig class
  9.  * description: SpringConfig
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/7/26
  13.  */
  14. @Configuration
  15. // 方式一：排除掉Controller层，排除规则为注解方式
  16. @ComponentScan(value = "com.spark",
  17.         excludeFilters = @ComponentScan.Filter(
  18.                 type = FilterType.ANNOTATION
  19.         )
  20. )
  21. public class SpringConfig {
  22. }

方式二：Spring加载的bean设定扫描范围为精确范围

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.FilterType;
  6.  
  7. /**
  8.  * SpringConfig class
  9.  * description: SpringConfig
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/7/26
  13.  */
  14. @Configuration
  15. // 方式二：设定精确的扫描范围
  16. @ComponentScan({"com.spark.dao","com.spark.service"})
  17. public class SpringConfig {
  18. }

在Servlet容器配置类中注册Spring配置类

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.context.WebApplicationContext;
  5. import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
  6. import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;
  7.  
  8. /**
  9.  * ServletInitConfig class
  10.  * description: ServletInitConfig
  11.  *
  12.  * @author Administrator
  13.  * @date 2023/7/26
  14.  */
  15. @Configuration
  16. public class ServletInitConfig extends AbstractDispatcherServletInitializer {
  17.  
  18.     @Override
  19.     protected WebApplicationContext createServletApplicationContext() {
  20.         AnnotationConfigWebApplicationContext atx = new AnnotationConfigWebApplicationContext();
  21.         atx.register(SpringMvcConfig.class);
  22.         return atx;
  23.     }
  24.  
  25.     @Override
  26.     protected String[] getServletMappings() {
  27.         // 所有请求
  28.         return new String[] {"/"};
  29.     }
  30.  
  31.     @Override
  32.     protected WebApplicationContext createRootApplicationContext() {
  33.         // 注册Spring配置类
  34.         AnnotationConfigWebApplicationContext atx = new AnnotationConfigWebApplicationContext();
  35.         atx.register(SpringConfig.class);
  36.         return atx;
  37.     }
  38. }

拓展：简化开发Servlet容器配置类

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
  5.  
  6. /**
  7.  * ServletInitConfig class
  8.  * description: ServletInitConfig
  9.  *
  10.  * @author Administrator
  11.  * @date 2023/7/26
  12.  */
  13. @Configuration
  14. public class ServletInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer{
  15.  
  16.     @Override
  17.     protected Class<?>[] getRootConfigClasses() {
  18.         // 注册Spring配置类
  19.         return new Class[]{SpringConfig.class};
  20.     }
  21.  
  22.     @Override
  23.     protected Class<?>[] getServletConfigClasses() {
  24.         // 注册SpringMVC配置类
  25.         return new Class[]{SpringMvcConfig.class};
  26.     }
  27.  
  28.     @Override
  29.     protected String[] getServletMappings() {
  30.         // 所有请求
  31.         return new String[]{"/"};
  32.     }
  33. }

Postman 

Postman是一款功能强大的网页调试与发送网页Http请求的Chrome插件，常用于进行接口测试

下载地址：https://www.postman.com/downloads/ 

安装完成后，打开让选择注册用户，可以不进行注册，关闭重新打开就可以进入

启动入门案例IDEA中配置的Tomcat，输入Controller层方法配置的接口地址，查看响应结果

请求与响应 

设置请求路径 

团队多人开发，每个人设置不同的请求路径，有可能会出现冲突，当多人的请求路径相同时，项目启动会出现错误。

通常会在请求路径前设置模块名作为请求路径前缀来解决问题

设置请求路径使用@RequestMapping注解，该注解可以用在类或方法上，前缀一般设置在Controller类上

  1. package com.spark.controller;
  2.  
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.ResponseBody;
  6.  
  7. /**
  8.  * UserController class
  9.  * description: UserController
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/7/26
  13.  */
  14. @Controller
  15. // 设置前缀，一般使用模块名
  16. @RequestMapping("/user")
  17. public class UserController {
  18.  
  19.     // 提供方法的请求路径
  20.     @RequestMapping("/save")
  21.     @ResponseBody
  22.     public String saveUser(){
  23.         System.out.println("user save ...");
  24.         return "{module:save}";
  25.     }
  26. }

请求方式GET和POST 

创建一个新的Maven项目，在Controller层添加一个方法用于展示请求传递的参数

  1. package com.spark.controller;
  2.  
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.ResponseBody;
  6.  
  7. /**
  8.  * UserController class
  9.  * description: UserController
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/7/26
  13.  */
  14. @Controller
  15. // 设置前缀，一般使用模块名
  16. @RequestMapping("/user")
  17. public class UserController {
  18.     
  19.     // 接收请求参数
  20.     @RequestMapping("/commonParams")
  21.     @ResponseBody
  22.     public String commonParams(String name,int age){
  23.         System.out.println("普通参数name===>"+name);
  24.         System.out.println("普通参数age===>"+age);
  25.         return "{module:commonParams}";
  26.     }
  27. }

① GET请求传参

普通参数：URL地址传参，地址参数名与形参变量名相同，定义形参即可接收参数

② POST请求传参

普通参数：使用form表单进行传参，表单参数名与形参变量名相同，定义形参即可接收参数

传递中文会出现乱码问题，需要在Servlet容器配置类中添加过滤器配置，处理中文乱码

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.filter.CharacterEncodingFilter;
  5. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
  6.  
  7. import javax.servlet.Filter;
  8.  
  9. /**
  10.  * ServletInitConfig class
  11.  * description: ServletInitConfig
  12.  *
  13.  * @author Administrator
  14.  * @date 2023/7/26
  15.  */
  16. @Configuration
  17. public class ServletInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer{
  18.  
  19.     @Override
  20.     protected Class<?>[] getRootConfigClasses() {
  21.         // 注册Spring配置类
  22.         return new Class[]{SpringConfig.class};
  23.     }
  24.  
  25.     @Override
  26.     protected Class<?>[] getServletConfigClasses() {
  27.         // 注册SpringMVC配置类
  28.         return new Class[]{SpringMvcConfig.class};
  29.     }
  30.  
  31.     @Override
  32.     protected String[] getServletMappings() {
  33.         // 所有请求
  34.         return new String[]{"/"};
  35.     }
  36. 	
  37.     // 添加过滤器配置
  38.     @Override
  39.     protected Filter[] getServletFilters() {
  40.         CharacterEncodingFilter filter = new CharacterEncodingFilter();
  41.         // 设置字符编码
  42.         filter.setEncoding("UTF-8");
  43.         return new Filter[]{filter};
  44.     }
  45. }

五种请求参数  

① 普通参数传递

普通参数传递要求形参与传参的参数名一致，如果不一致，需要使用@RequestParam注解指定传参的参数名

举例：形参列表的参数名为userName，传参的参数名为name

  1. // 接收请求参数
  2. @RequestMapping("/commonParams")
  3. @ResponseBody
  4. // 将传参的name属性值赋值给形参的userName
  5. public String commonParams(@RequestParam("name") String userName){
  6.     System.out.println("普通参数userName===>"+userName);
  7.     return "{module:commonParams}";
  8. }

② POJO类型参数传递

POJO参数传递要求请求参数名与形参对象属性名相同，定义POJO类型参数即可接收参数，将请求参数封装为实体类

  1. package com.spark.entity;
  2.  
  3. /**
  4.  * UserEntity class
  5.  * description: UserEntity
  6.  *
  7.  * @author Administrator
  8.  * @date 2023/7/30
  9.  */
  10. public class UserEntity {
  11.     
  12.     private String userName;
  13.     
  14.     private int age;
  15.  
  16.     public String getUserName() {
  17.         return userName;
  18.     }
  19.  
  20.     public void setUserName(String userName) {
  21.         this.userName = userName;
  22.     }
  23.  
  24.     public int getAge() {
  25.         return age;
  26.     }
  27.  
  28.     public void setAge(int age) {
  29.         this.age = age;
  30.     }
  31.  
  32.     @Override
  33.     public String toString() {
  34.         return "UserEntity{" +
  35.                 "userName='" + userName + '\'' +
  36.                 ", age=" + age +
  37.                 '}';
  38.     }
  39. }

Controller层定义方法

  1. // 接收POJO参数
  2. @RequestMapping("/pojoParams")
  3. @ResponseBody
  4. public String pojoParams(UserEntity user){
  5.     System.out.println("user:::"+user);
  6.     return "{module:pojoParams}";
  7. }

③ 嵌套POJO类型参数传递

当实体类中包含其他实体类情况下，请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套POJO属性参数

添加Address实体类

  1. package com.spark.entity;
  2.  
  3. /**
  4.  * AddressEntity class
  5.  * description: AddressEntity
  6.  *
  7.  * @author Administrator
  8.  * @date 2023/7/30
  9.  */
  10. public class AddressEntity {
  11.     
  12.     private String city;
  13.  
  14.     public String getCity() {
  15.         return city;
  16.     }
  17.  
  18.     public void setCity(String city) {
  19.         this.city = city;
  20.     }
  21.  
  22.     @Override
  23.     public String toString() {
  24.         return "AddressEntity{" +
  25.                 "city='" + city + '\'' +
  26.                 '}';
  27.     }
  28. }

UserEntity实体类中添加AddressEntity实体类

  1. package com.spark.entity;
  2.  
  3. /**
  4.  * UserEntity class
  5.  * description: UserEntity
  6.  *
  7.  * @author Administrator
  8.  * @date 2023/7/30
  9.  */
  10. public class UserEntity {
  11.  
  12.     private String userName;
  13.  
  14.     private int age;
  15.  
  16.     private AddressEntity address;
  17.  
  18.     public String getUserName() {
  19.         return userName;
  20.     }
  21.  
  22.     public void setUserName(String userName) {
  23.         this.userName = userName;
  24.     }
  25.  
  26.     public int getAge() {
  27.         return age;
  28.     }
  29.  
  30.     public void setAge(int age) {
  31.         this.age = age;
  32.     }
  33.  
  34.     public AddressEntity getAddress() {
  35.         return address;
  36.     }
  37.  
  38.     public void setAddress(AddressEntity address) {
  39.         this.address = address;
  40.     }
  41.  
  42.     @Override
  43.     public String toString() {
  44.         return "UserEntity{" +
  45.                 "userName='" + userName + '\'' +
  46.                 ", age=" + age +
  47.                 ", address=" + address +
  48.                 '}';
  49.     }
  50. }

Controller层定义方法

  1. // 接收嵌套POJO参数
  2. @RequestMapping("/pojoNestParams")
  3. @ResponseBody
  4. public String pojoNestParams(UserEntity user){
  5.     System.out.println("user:::"+user);
  6.     return "{module:pojoParams}";
  7. }

④ 数组类型参数传递

请求参数名与形参对象属性名相同且请求参数为多个，定义数组类型形参即可接收参数

Controller层定义方法

  1. // 接收数组类型参数
  2. @RequestMapping("/arrayParams")
  3. @ResponseBody
  4. public String arrayParams(String [] likes){
  5.     System.out.println(Arrays.toString(likes));
  6.     return "{module:arrayParams}";
  7. }

⑤ 集合参数传递

请求参数名与形参集合对象名相同且请求参数为多个，@RequestParam绑定参数关系

Controller层定义方法

  1. // 接收集合类型参数
  2. @RequestMapping("/listParams")
  3. @ResponseBody
  4. public String listParams(@RequestParam List<String>likes){
  5.     System.out.println(likes);
  6.     return "{module:listParams}";
  7. }

集合类型参数加@RequestParam原因是因为系统会默认将List看做为引用数据类型，会去调用其构造方法去初始化，List类型为接口没有构造方法

json数据传递 

在项目中数据传递一般是使用的是json对象和json数组。

① 实现json对象传递

pom.xml中引入依赖

  1. <dependency>
  2.     <groupId>com.fasterxml.jackson.core</groupId>
  3.     <artifactId>jackson-databind</artifactId>
  4.     <version>2.9.0</version>
  5. </dependency>

在SpringMVC配置类中开启json转换为实体

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
  6.  
  7. /**
  8.  * SpringmvcConfig class
  9.  * description: SpringMvcConfig
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/7/26
  13.  */
  14. @Configuration
  15. @ComponentScan("com.spark.controller")
  16. @EnableWebMvc
  17. public class SpringMvcConfig {
  18.  
  19. }

Controller层定义方法

  1. // 接收json类型参数
  2. @RequestMapping("/jsonParams")
  3. @ResponseBody
  4. public String jsonParams(@RequestBody UserEntity user){
  5.     System.out.println(user);
  6.     return "{module:jsonParams}";
  7. }

@RequestBody将请求中请求体包含的数据传递给请求参数，此注解一个处理器方法只能用一次

Postman发送请求

② json数组参数传递 

Controller层定义方法

  1. // 接收json类型参数
  2. @RequestMapping("/jsonArrayParams")
  3. @ResponseBody
  4. public String jsonArrayParams(@RequestBody List<UserEntity> users){
  5.     System.out.println(users);
  6.     return "{module:jsonArrayParams}";
  7. }

Postman发送请求

@RequestParam和@RequestBody

区别

  • @RequestParam用于接收url地址传参，表单传参
  • @RequestBody用于接收json数据  

应用

  • 后期开发中，发送json格式数据为主，@RequestBody应用较广
  • 如果发送非json数据，选用@RequestParam接收请求参数 

日期型参数传递 

日期类型基于系统不同格式也不尽相同

接收形参时，根据不同的日期格式设置不同的接收方式

  1. // 接收日期类型参数
  2. @RequestMapping("/dateParams")
  3. @ResponseBody
  4. public String dateParams(Date date, 
  5.                          @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date date2){
  6.     System.out.println("Date:"+date);
  7.     System.out.println("Date2:"+date2);
  8.     return "{module:dateParams}";
  9. }

@DateTimeFormat设置日期类型数据格式 

Rest风格 

概述 

REST表现形式状态转换

传统风格资源描述形式

  • http://localhost/user/getById?id=1
  • http://localhost/user/saveUser

REST风格描述形式

  • http://localhost/user/1
  • http://localhost/user 

优点：隐藏资源的访问行为，无法通过地址得知对资源是何种操作，书写简化

按照REST风格访问资源时使用行为动作区分对资源进行了何种操作，常用的有四种

  • GET(查询)
  • POST(新增/保存)
  • PUT(修改/更新)
  • DELETE(删除) 

根据REST风格对资源进行访问称为RestFul

入门案例 

使用REST风格约定请求动作，编写表现层Controller

  1. package com.spark.controller;
  2.  
  3. import com.spark.entity.UserEntity;
  4. import org.springframework.stereotype.Controller;
  5. import org.springframework.web.bind.annotation.RequestBody;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.ResponseBody;
  8.  
  9. /**
  10.  * RestController class
  11.  * description: RestController
  12.  *
  13.  * @author Administrator
  14.  * @date 2023/7/31
  15.  */
  16. @Controller
  17. @RequestMapping("/users")
  18. public class RestController {
  19.     
  20.     // 约定save方法的请求动作为POST
  21.     @RequestMapping(value = "/save",method = RequestMethod.POST)
  22.     @ResponseBody
  23.     public String save(@RequestBody UserEntity user){
  24.         System.out.println(user);
  25.         return "{module:save}";
  26.     }
  27.     // 约定delete方法的请求动作为DELETE
  28.     @RequestMapping(value = "/delete",method = RequestMethod.DELETE)
  29.     @ResponseBody
  30.     public String delete(Integer id){
  31.         System.out.println("user id===>"+id);
  32.         return "{module:delete}";
  33.     }
  34. }

当规定了行为动作后，使用其他方式访问接口会报请求方式不支持异常 

地址传参，使用DELETE方式访问却报404

使用路径传参时，方法的形参列表需要使用@PathVariable表明值从url获取

改写delete方法

  1. // 约定delete方法的请求动作为DELETE
  2. // url指定参数名
  3. @RequestMapping(value = "/delete/{id}",method = RequestMethod.DELETE)
  4. @ResponseBody
  5. // 使用@PathVariable注解表明参数从url获取
  6. public String delete(@PathVariable Integer id){
  7.     System.out.println("user id===>"+id);
  8.     return "{module:delete}";
  9. }

简化开发 

@RestController注解是@Controller和@ResponseBody的复合注解，以后在表现层只需要使用@RestController注解就可以管理该类并且方法结果都可以原样返回

@RequestMapping中的method属性指明行为动作，也可以使用具体的注解进行简化开发

  • @GetMapping
  • @PostMapping
  • @PutMapping
  • @DeleteMapping 
  1. package com.spark.controller;
  2.  
  3. import org.springframework.web.bind.annotation.*;
  4.  
  5. /**
  6.  * RestController class
  7.  * description: RestController
  8.  *
  9.  * @author Administrator
  10.  * @date 2023/7/31
  11.  */
  12. @RestController
  13. @RequestMapping("/books")
  14. public class RestfulController {
  15.     
  16.     @GetMapping("/allBooks")
  17.     public String getAllBooks() {
  18.         return "{module:getAllBooks}";
  19.     }
  20.     @PostMapping("/saveBooks")
  21.     public String saveBooks(){
  22.         return "{module:saveBooks}";
  23.     }
  24.     @PutMapping("/updateBook")
  25.     public String updateBook(){
  26.         return "{module:updateBook}";
  27.     }
  28.     @DeleteMapping("/deleteBook")
  29.     public String deleteBook(){
  30.         return "{module:deleteBook}";
  31.     }
  32. }

SSM整合 

整合配置 

使用web模版创建一个Maven项目，在pom.xml中引入依赖

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework</groupId>
  4.         <artifactId>spring-webmvc</artifactId>
  5.         <version>5.2.10.RELEASE</version>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>org.springframework</groupId>
  9.         <artifactId>spring-test</artifactId>
  10.         <version>5.2.10.RELEASE</version>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>org.springframework</groupId>
  14.         <artifactId>spring-jdbc</artifactId>
  15.         <version>5.2.10.RELEASE</version>
  16.     </dependency>
  17.     <dependency>
  18.         <groupId>org.mybatis</groupId>
  19.         <artifactId>mybatis-spring</artifactId>
  20.         <version>2.0.6</version>
  21.     </dependency>
  22.     <dependency>
  23.         <groupId>org.mybatis</groupId>
  24.         <artifactId>mybatis</artifactId>
  25.         <version>3.5.6</version>
  26.     </dependency>
  27.     <dependency>
  28.         <groupId>com.alibaba</groupId>
  29.         <artifactId>druid</artifactId>
  30.         <version>1.2.8</version>
  31.     </dependency>
  32.     <dependency>
  33.         <groupId>mysql</groupId>
  34.         <artifactId>mysql-connector-java</artifactId>
  35.         <version>5.1.49</version>
  36.     </dependency>
  37.     <dependency>
  38.         <groupId>com.fasterxml.jackson.core</groupId>
  39.         <artifactId>jackson-core</artifactId>
  40.         <version>2.13.1</version>
  41.     </dependency>
  42.     <dependency>
  43.       <groupId>com.fasterxml.jackson.core</groupId>
  44.       <artifactId>jackson-databind</artifactId>
  45.       <version>2.13.1</version>
  46.     </dependency>
  47.     <dependency>
  48.       <groupId>com.fasterxml.jackson.core</groupId>
  49.       <artifactId>jackson-annotations</artifactId>
  50.       <version>2.13.1</version>
  51.     </dependency>
  52.     <dependency>
  53.         <groupId>javax.servlet</groupId>
  54.         <artifactId>javax.servlet-api</artifactId>
  55.         <version>3.1.0</version>
  56.         <scope>provided</scope>
  57.     </dependency>
  58.     <dependency>
  59.         <groupId>junit</groupId>
  60.         <artifactId>junit</artifactId>
  61.         <version>4.12</version>
  62.     </dependency>
  63. </dependencies>

resources目录下新建jdbc.properties文件，写入MySQL连接信息

  1. jdbc.driver = com.mysql.jdbc.Driver
  2. jdbc.url = jdbc:mysql://localhost:3306/ssm_db
  3. jdbc.username = root
  4. jdbc.password = root

编写JDBC配置类

  1. package com.spark.config;
  2.  
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.context.annotation.Bean;
  6.  
  7. import javax.sql.DataSource;
  8.  
  9. /**
  10.  * JdbcConfig class
  11.  * description: JdbcConfig
  12.  *
  13.  * @author Administrator
  14.  * @date 2023/8/3
  15.  */
  16. public class JdbcConfig {
  17.  
  18.     @Value("${jdbc.driver}")
  19.     private String driver;
  20.     @Value("${jdbc.url}")
  21.     private String url;
  22.     @Value("${jdbc.username}")
  23.     private String username;
  24.     @Value("${jdbc.password}")
  25.     private String password;
  26.  
  27.     // 注册数据源
  28.     @Bean
  29.     public DataSource getDataSource(){
  30.         DruidDataSource dataSource = new DruidDataSource();
  31.         dataSource.setDriverClassName(driver);
  32.         dataSource.setUrl(url);
  33.         dataSource.setUsername(username);
  34.         dataSource.setPassword(password);
  35.         return dataSource;
  36.     }
  37. }

编写Mybatis配置类

  1. package com.spark.config;
  2.  
  3. import org.mybatis.spring.SqlSessionFactoryBean;
  4. import org.mybatis.spring.mapper.MapperScannerConfigurer;
  5. import org.springframework.context.annotation.Bean;
  6.  
  7. import javax.sql.DataSource;
  8.  
  9. /**
  10.  * MybatisConfig class
  11.  * description: MybatisConfig
  12.  *
  13.  * @author Administrator
  14.  * @date 2023/8/3
  15.  */
  16. public class MybatisConfig {
  17.  
  18.     // 获取SqlSessionFactory
  19.     @Bean
  20.     public SqlSessionFactoryBean getSqlSessionFactoryBean(DataSource dataSource) {
  21.         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
  22.         sqlSessionFactoryBean.setDataSource(dataSource);
  23.         // 扫描entity包
  24.         sqlSessionFactoryBean.setTypeAliasesPackage("com.spark.entity");
  25.         return sqlSessionFactoryBean;
  26.     }
  27.  
  28.     // 映射dao
  29.     @Bean
  30.     public MapperScannerConfigurer mapperScannerConfigurer(){
  31.         MapperScannerConfigurer configurer = new MapperScannerConfigurer();
  32.         configurer.setBasePackage("com.spark.dao");
  33.         return configurer;
  34.     }
  35. }

编写Spring和SpringMVC配置类

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.Import;
  6. import org.springframework.context.annotation.PropertySource;
  7.  
  8. /**
  9.  * SpringConfig class
  10.  * description: SpringConfig
  11.  *
  12.  * @author Administrator
  13.  * @date 2023/8/3
  14.  */
  15. @Configuration
  16. @PropertySource({"classpath:jdbc.properties"})
  17. @Import({JdbcConfig.class,MybatisConfig.class})
  18. @ComponentScan({"com.spark.service","com.spark.dao"})
  19. public class SpringConfig {
  20. }

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
  6.  
  7. /**
  8.  * SpringMvcConfig class
  9.  * description: SpringMvcConfig
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/8/3
  13.  */
  14. @Configuration
  15. @ComponentScan("com.spark.controller")
  16. @EnableWebMvc
  17. public class SpringMvcConfig {
  18. }

编写Servlet容器配置

  1. package com.spark.config;
  2.  
  3. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
  4.  
  5. /**
  6.  * ServletConfig class
  7.  * description: ServletConfig
  8.  *
  9.  * @author Administrator
  10.  * @date 2023/8/3
  11.  */
  12. public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
  13.     @Override
  14.     protected Class<?>[] getRootConfigClasses() {
  15.         return new Class[]{SpringConfig.class};
  16.     }
  17.  
  18.     @Override
  19.     protected Class<?>[] getServletConfigClasses() {
  20.         return new Class[]{SpringMvcConfig.class};
  21.     }
  22.  
  23.     @Override
  24.     protected String[] getServletMappings() {
  25.         return new String[]{"/"};
  26.     }
  27. }

功能模块开发 

数据库创建数据表，并写入数据

  1. DROP TABLE IF EXISTS `books`;
  2. CREATE TABLE `books`  (
  3.   `id` int(11) NOT NULL AUTO_INCREMENT,
  4.   `type` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  5.   `name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  6.   `description` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  7.   PRIMARY KEY (`id`) USING BTREE
  8. ) ENGINE = InnoDB AUTO_INCREMENT = 13 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
  9.  
  10. INSERT INTO `books` VALUES (1, '计算机理论', 'Spring实战 第5版', 'Spring入门经典教程，深入理解Spring原理技术内幕');
  11. INSERT INTO `books` VALUES (2, '计算机理论', 'Spring 5核心原理与30个类手写实战', '十年沉淀之作，手写Spring精华思想');
  12. INSERT INTO `books` VALUES (3, '计算机理论', 'Spring 5 设计模式', '深入Spring源码剖析Spring源码中蕴含的10大设计模式');
  13. INSERT INTO `books` VALUES (4, '计算机理论', 'Spring MVC+MyBatis开发从入门到项目实战', '全方位解析面向Web应用的轻量级框架，带你成为Spring MVC开发高手');
  14. INSERT INTO `books` VALUES (5, '计算机理论', '轻量级Java Web企业应用实战', '源码级剖析Spring框架，适合已掌握Java基础的读者');
  15. INSERT INTO `books` VALUES (6, '计算机理论', 'Java核心技术 卷I 基础知识（原书第11版）', 'Core Java 第11版，Jolt大奖获奖作品，针对Java SE9、10、11全面更新');
  16. INSERT INTO `books` VALUES (7, '计算机理论', '深入理解Java虚拟机', '5个维度全面剖析JVM，大厂面试知识点全覆盖');
  17. INSERT INTO `books` VALUES (8, '计算机理论', 'Java编程思想（第4版）', 'Java学习必读经典,殿堂级著作！赢得了全球程序员的广泛赞誉');
  18. INSERT INTO `books` VALUES (9, '计算机理论', '零基础学Java（全彩版）', '零基础自学编程的入门图书，由浅入深，详解Java语言的编程思想和核心技术');
  19. INSERT INTO `books` VALUES (10, '市场营销', '直播就该这么做：主播高效沟通实战指南', '李子柒、李佳琦、薇娅成长为网红的秘密都在书中');
  20. INSERT INTO `books` VALUES (11, '市场营销', '直播销讲实战一本通', '和秋叶一起学系列网络营销书籍');
  21. INSERT INTO `books` VALUES (12, '市场营销', '直播带货：淘宝、天猫直播从新手到高手', '一本教你如何玩转直播的书，10堂课轻松实现带货月入3W+');

创建实体类，并编写Dao 

  1. package com.spark.entity;
  2.  
  3. /**
  4.  * Book class
  5.  * description: Book
  6.  *
  7.  * @author Administrator
  8.  * @date 2023/8/3
  9.  */
  10. public class Book {
  11.  
  12.     private Integer id;
  13.  
  14.     private String type;
  15.  
  16.     private String name;
  17.  
  18.     private String description;
  19.  
  20.     public Integer getId() {
  21.         return id;
  22.     }
  23.  
  24.     public void setId(Integer id) {
  25.         this.id = id;
  26.     }
  27.  
  28.     public String getType() {
  29.         return type;
  30.     }
  31.  
  32.     public void setType(String type) {
  33.         this.type = type;
  34.     }
  35.  
  36.     public String getName() {
  37.         return name;
  38.     }
  39.  
  40.     public void setName(String name) {
  41.         this.name = name;
  42.     }
  43.  
  44.     public String getDescription() {
  45.         return description;
  46.     }
  47.  
  48.     public void setDescription(String description) {
  49.         this.description = description;
  50.     }
  51.  
  52.     @Override
  53.     public String toString() {
  54.         return "Book{" +
  55.                 "id=" + id +
  56.                 ", type='" + type + '\'' +
  57.                 ", name='" + name + '\'' +
  58.                 ", description='" + description + '\'' +
  59.                 '}';
  60.     }
  61. }
  1. package com.spark.dao;
  2.  
  3. import com.spark.entity.Book;
  4. import org.apache.ibatis.annotations.Delete;
  5. import org.apache.ibatis.annotations.Insert;
  6. import org.apache.ibatis.annotations.Select;
  7. import org.apache.ibatis.annotations.Update;
  8.  
  9. import java.util.List;
  10.  
  11. /**
  12.  * BookDao class
  13.  * description: BookDao
  14.  *
  15.  * @author Administrator
  16.  * @date 2023/8/3
  17.  */
  18. public interface BookDao {
  19.  
  20.     @Insert("insert into books(`type`,`name`,`description`) values(#{type},#{name},#{description})")
  21.     int save(Book book);
  22.     @Update("update books set type=#{type}, name=#{name}, description=#{description} where id = #{id}")
  23.     int update(Book book);
  24.     @Delete("delete from books where id = #{id}")
  25.     int delete(Integer id);
  26.     @Select("select * from books where id = #{id}")
  27.     Book getById(Integer id);
  28.     @Select("select * from books")
  29.     List<Book> getAll();
  30. }

定义业务层接口方法并编写实现类

  1. package com.spark.service;
  2.  
  3. import com.spark.entity.Book;
  4.  
  5. import java.util.List;
  6.  
  7. /**
  8.  * BookService class
  9.  * description: BookService
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/8/3
  13.  */
  14. public interface BookService {
  15.  
  16.     boolean addBook(Book book);
  17.     boolean updateBook(Book book);
  18.     boolean deleteBook(Integer id);
  19.     Book selectById(Integer id);
  20.     List<Book> selectAll();
  21. }
  1. package com.spark.service.impl;
  2.  
  3. import com.spark.dao.BookDao;
  4. import com.spark.entity.Book;
  5. import com.spark.service.BookService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  8.  
  9. import java.util.List;
  10.  
  11. /**
  12.  * BookServiceImpl class
  13.  * description: BookServiceImpl
  14.  *
  15.  * @author Administrator
  16.  * @date 2023/8/3
  17.  */
  18. @Service
  19. public class BookServiceImpl implements BookService {
  20.  
  21.     @Autowired
  22.     BookDao bookDao;
  23.  
  24.     @Override
  25.     public boolean addBook(Book book) {
  26.         return bookDao.save(book) > 0;
  27.     }
  28.  
  29.     @Override
  30.     public boolean updateBook(Book book) {
  31.         return bookDao.update(book) > 0;
  32.     }
  33.  
  34.     @Override
  35.     public boolean deleteBook(Integer id) {
  36.         return bookDao.delete(id) > 0;
  37.     }
  38.  
  39.     @Override
  40.     public Book selectById(Integer id) {
  41.         return bookDao.getById(id);
  42.     }
  43.  
  44.     @Override
  45.     public List<Book> selectAll() {
  46.         return bookDao.getAll();
  47.     }
  48. }

编写表现层Controller

  1. package com.spark.controller;
  2.  
  3. import com.spark.entity.Book;
  4. import com.spark.service.BookService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.*;
  7.  
  8. import java.util.List;
  9.  
  10. /**
  11.  * BookController class
  12.  * description: BookController
  13.  *
  14.  * @author Administrator
  15.  * @date 2023/8/3
  16.  */
  17. @RestController
  18. @RequestMapping("/books")
  19. public class BookController {
  20.  
  21.     @Autowired
  22.     private BookService bookService;
  23.  
  24.     @PostMapping("/addBook")
  25.     public String addBook(@RequestBody Book book){
  26.         if(bookService.addBook(book)){
  27.             return "添加成功";
  28.         }else{
  29.             return "添加失败";
  30.         }
  31.     }
  32.     @PutMapping("/updateBook")
  33.     public String updateBook(@RequestBody Book book){
  34.         if(bookService.updateBook(book)){
  35.             return "更新成功";
  36.         }else{
  37.             return "更新失败";
  38.         }
  39.     }
  40.     @DeleteMapping("/deleteBook")
  41.     public String deleteBook(Integer id){
  42.         if(bookService.deleteBook(id)){
  43.             return "删除成功";
  44.         }else{
  45.             return "删除失败";
  46.         }
  47.     }
  48.     @GetMapping("/getById")
  49.     public Book selectById(Integer id){
  50.         return bookService.selectById(id);
  51.     }
  52.     @GetMapping("/getAll")
  53.     public List<Book> selectAll(){
  54.         return bookService.selectAll();
  55.     }
  56.  
  57. }

接口测试

编写测试类

  1. package com.spark;
  2.  
  3. import com.spark.config.SpringConfig;
  4. import com.spark.entity.Book;
  5. import com.spark.service.BookService;
  6. import org.junit.Test;
  7. import org.junit.runner.RunWith;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.test.context.ContextConfiguration;
  10. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  11.  
  12. /**
  13.  * BookServiceTest class
  14.  * description: BookServiceTest
  15.  *
  16.  * @author Administrator
  17.  * @date 2023/8/5
  18.  */
  19. @RunWith(SpringJUnit4ClassRunner.class)
  20. @ContextConfiguration(classes = SpringConfig.class)
  21. public class BookServiceTest {
  22.  
  23.     @Autowired
  24.     BookService bookService;
  25.  
  26.     @Test
  27.     public void testBookInsert(){
  28.         Book book = new Book();
  29.         book.setName("Java从入门到放弃");
  30.         book.setType("计算机");
  31.         book.setDescription("Java从入门到放弃");
  32.         bookService.addBook(book);
  33.     }
  34.  
  35.     @Test
  36.     public void testBookUpdate(){
  37.         Book book = new Book();
  38.         book.setName("Java从入门到放弃 第二版");
  39.         book.setType("计算机");
  40.         book.setDescription("Java从入门到放弃第二版");
  41.         book.setId(13);
  42.         bookService.updateBook(book);
  43.     }
  44.  
  45.     @Test
  46.     public void testBookDelete(){
  47.         bookService.deleteBook(13);
  48.     }
  49.  
  50.     @Test
  51.     public void testBookSelectById(){
  52.         System.out.println(bookService.selectById(1));
  53.     }
  54.  
  55.     @Test
  56.     public void testBookSelectAll(){
  57.         System.out.println(bookService.selectAll());
  58.     }
  59. }

拓展：开启事务

Spring配置类中使用注解开启事务管理

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.Import;
  6. import org.springframework.context.annotation.PropertySource;
  7. import org.springframework.transaction.annotation.EnableTransactionManagement;
  8.  
  9. /**
  10.  * SpringConfig class
  11.  * description: SpringConfig
  12.  *
  13.  * @author Administrator
  14.  * @date 2023/8/3
  15.  */
  16. @Configuration
  17. @PropertySource({"classpath:jdbc.properties"})
  18. @Import({JdbcConfig.class,MybatisConfig.class})
  19. @ComponentScan({"com.spark.service","com.spark.dao"})
  20. // 开启事务
  21. @EnableTransactionManagement
  22. public class SpringConfig {
  23. }

在Jdbc配置类中获取事务管理对象

  1. package com.spark.config;
  2.  
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  7.  
  8. import javax.sql.DataSource;
  9.  
  10. /**
  11.  * JdbcConfig class
  12.  * description: JdbcConfig
  13.  *
  14.  * @author Administrator
  15.  * @date 2023/8/3
  16.  */
  17. public class JdbcConfig {
  18.  
  19.     @Value("${jdbc.driver}")
  20.     private String driver;
  21.     @Value("${jdbc.url}")
  22.     private String url;
  23.     @Value("${jdbc.username}")
  24.     private String username;
  25.     @Value("${jdbc.password}")
  26.     private String password;
  27.  
  28.     // 注册数据源
  29.     @Bean
  30.     public DataSource getDataSource(){
  31.         DruidDataSource dataSource = new DruidDataSource();
  32.         dataSource.setDriverClassName(driver);
  33.         dataSource.setUrl(url);
  34.         dataSource.setUsername(username);
  35.         dataSource.setPassword(password);
  36.         return dataSource;
  37.     }
  38.  
  39.     // 数据源事务管理对象
  40.     @Bean
  41.     public DataSourceTransactionManager transactionManager(DataSource dataSource){
  42.         DataSourceTransactionManager ds = new DataSourceTransactionManager();
  43.         ds.setDataSource(dataSource);
  44.         return ds;
  45.     }
  46. }

在业务层使用事务管理注解

  1. package com.spark.service;
  2.  
  3. import com.spark.entity.Book;
  4. import org.springframework.transaction.annotation.Transactional;
  5.  
  6. import java.util.List;
  7.  
  8. /**
  9.  * BookService class
  10.  * description: BookService
  11.  *
  12.  * @author Administrator
  13.  * @date 2023/8/3
  14.  */
  15. @Transactional
  16. public interface BookService {
  17.  
  18.     boolean addBook(Book book);
  19.     boolean updateBook(Book book);
  20.     boolean deleteBook(Integer id);
  21.     Book selectById(Integer id);
  22.     List<Book> selectAll();
  23. }

表现层与前端数据传输

由于数据传输可能会有多种格式，前端需要分别去解析数据，因此与前端交互时一般需要统一格式。创建结果模型类，封装数据到data属性中，封装操作结果到code属性中，封装特殊消息到message(msg)属性中

  1. public class Result{
  2.     private String code;
  3.     private String msg;
  4.     private Object data;
  5. }

Result类字段并不固定，可以根据需要自行增减，提供若干个构造方法，方便操作 

定义统一结果类

  1. package com.spark.util;
  2.  
  3. /**
  4.  * Result class
  5.  * description: Result
  6.  *
  7.  * @author Administrator
  8.  * @date 2023/8/5
  9.  */
  10. public class Result {
  11.     
  12.     private String code;
  13.     
  14.     private String msg;
  15.     
  16.     private Object data;
  17.  
  18.     public Result(String code, String msg, Object data) {
  19.         this.code = code;
  20.         this.msg = msg;
  21.         this.data = data;
  22.     }
  23.  
  24.     public String getCode() {
  25.         return code;
  26.     }
  27.  
  28.     public void setCode(String code) {
  29.         this.code = code;
  30.     }
  31.  
  32.     public String getMsg() {
  33.         return msg;
  34.     }
  35.  
  36.     public void setMsg(String msg) {
  37.         this.msg = msg;
  38.     }
  39.  
  40.     public Object getData() {
  41.         return data;
  42.     }
  43.  
  44.     public void setData(Object data) {
  45.         this.data = data;
  46.     }
  47. }

定义结果类所需的常量

  1. package com.spark.common;
  2.  
  3. /**
  4.  * RestCommonContent class
  5.  * description: RestCommonContent
  6.  *
  7.  * @author Administrator
  8.  * @date 2023/8/5
  9.  */
  10. public class RestCommonContent {
  11.  
  12.     // 定义响应编码和响应信息
  13.     public static final String RESPONSE_SUCCESS = "操作成功!";
  14.     public static final String RESPONSE_ERROR = "操作失败!";
  15.     public static final String RESPONSE_SUCCESS_CODE = "200";
  16.     public static final String RESPONSE_ERROR_CODE = "9999";
  17.     public static final String SELECT_SUCCESS = "查询成功!";
  18.     public static final String SELECT_ERROR = "数据不存在,查询失败!";
  19.     
  20.     // 定义数据常量
  21.     public static final String CONTENT_EMPTY = "";
  22.     public static final String CONTENT_NULL = null;
  23.     
  24. }

 改写表现层Controller

  1. package com.spark.controller;
  2.  
  3. import com.spark.common.RestCommonContent;
  4. import com.spark.entity.Book;
  5. import com.spark.service.BookService;
  6. import com.spark.util.Result;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.util.ObjectUtils;
  9. import org.springframework.web.bind.annotation.*;
  10.  
  11. import java.util.List;
  12.  
  13. /**
  14.  * BookController class
  15.  * description: BookController
  16.  *
  17.  * @author Administrator
  18.  * @date 2023/8/3
  19.  */
  20. @RestController
  21. @RequestMapping("/books")
  22. public class BookController {
  23.  
  24.     @Autowired
  25.     private BookService bookService;
  26.  
  27.     @PostMapping("/addBook")
  28.     public Result addBook(@RequestBody Book book){
  29.         if(bookService.addBook(book)){
  30.             return new Result(RestCommonContent.RESPONSE_SUCCESS_CODE,
  31.                     RestCommonContent.RESPONSE_SUCCESS,
  32.                     true);
  33.         }else{
  34.             return new Result(RestCommonContent.RESPONSE_ERROR_CODE,
  35.                     RestCommonContent.RESPONSE_ERROR,
  36.                     false);
  37.         }
  38.     }
  39.     @PutMapping("/updateBook")
  40.     public Result updateBook(@RequestBody Book book){
  41.         if(bookService.updateBook(book)){
  42.             return new Result(RestCommonContent.RESPONSE_SUCCESS_CODE,
  43.                     RestCommonContent.RESPONSE_SUCCESS,
  44.                     true);
  45.         }else{
  46.             return new Result(RestCommonContent.RESPONSE_ERROR_CODE,
  47.                     RestCommonContent.RESPONSE_ERROR,
  48.                     false);
  49.         }
  50.     }
  51.     @DeleteMapping("/deleteBook")
  52.     public Result deleteBook(Integer id){
  53.         if(bookService.deleteBook(id)){
  54.             return new Result(RestCommonContent.RESPONSE_SUCCESS_CODE,
  55.                     RestCommonContent.RESPONSE_SUCCESS,
  56.                     true);
  57.         }else{
  58.             return new Result(RestCommonContent.RESPONSE_ERROR_CODE,
  59.                     RestCommonContent.RESPONSE_ERROR,
  60.                     false);
  61.         }
  62.     }
  63.     @GetMapping("/getById")
  64.     public Result selectById(Integer id){
  65.         Book book = bookService.selectById(id);
  66.         if(ObjectUtils.isEmpty(book)){
  67.             return new Result(RestCommonContent.RESPONSE_ERROR_CODE,
  68.                     RestCommonContent.SELECT_ERROR,
  69.                     RestCommonContent.CONTENT_EMPTY);
  70.         }
  71.         return new Result(RestCommonContent.RESPONSE_SUCCESS_CODE,
  72.                 RestCommonContent.SELECT_SUCCESS,
  73.                 book);
  74.     }
  75.     @GetMapping("/getAll")
  76.     public Result selectAll(){
  77.         List<Book> books = bookService.selectAll();
  78.         if(ObjectUtils.isEmpty(books)){
  79.             return new Result(RestCommonContent.RESPONSE_SUCCESS_CODE,
  80.                     RestCommonContent.SELECT_SUCCESS,
  81.                     RestCommonContent.CONTENT_EMPTY);
  82.         }
  83.         return new Result(RestCommonContent.RESPONSE_SUCCESS_CODE,
  84.                 RestCommonContent.SELECT_SUCCESS,
  85.                 books);
  86.     }
  87.  
  88. }

异常处理器

开发中避免不了会遇到异常现象，如果不做处理，前端页面获取错误信息时拿到的是错误页面，无法进行解析，此时需要对异常进行统一处理

出现异常现象的常见位置与常见诱因如下

  • 框架内部抛出的异常，使用不合规导致
  • 数据层抛出的异常，外部服务器故障导致（例如服务器访问超时）
  • 业务层抛出的异常，业务逻辑书写错误导致（例如空指针异常等）
  • 表现层抛出的异常，数据收集、校验等规则导致（例如不匹配的数据类型间导致异常）
  • 工具类抛出的异常，因工具类书写不严谨不够健壮导致（例如必要释放的连接长期未释放等）

Spring提供了异常处理器，集中的、统一的处理项目中出现的异常

  1. @RestControllerAdvice
  2. public class ProjectExceptionAdvice{
  3.     @ExceptionHandler(Exception.class)
  4.     public Result doException(Exception ex){
  5. 		// 处理异常返回结果
  6.     }
  7. }

@ExceptionHandler专用于异常处理的控制器方法上方，设置指定异常的处理方案，功能等同于控制器方法，出现异常后终止原始控制器执行，并转入当前方法执行

项目异常分类

业务异常(BusinessException)

  • 不规范的用户行为产生的异常 

系统异常(SystemException)

  • 项目运行过程中可预计且无法避免的异常 

其他异常(Exception)

  • 编程人员未预期的异常 

项目异常处理

编写业务异常类和系统异常类

  1. package com.spark.exception;
  2.  
  3. /**
  4.  * BusinessException class
  5.  * description: BusinessException
  6.  *
  7.  * @author Administrator
  8.  * @date 2023/8/5
  9.  */
  10. public class BusinessException extends RuntimeException{
  11.     
  12.     private String code; // 错误编码
  13.     
  14.     private String tranCode; // 交易码(接口号)
  15.     
  16.  
  17.     public BusinessException(String code, String message, String tranCode) {
  18.         super(message);
  19.         this.code = code;
  20.         this.tranCode = tranCode;
  21.     }
  22.  
  23.     public BusinessException(String code,String message, String tranCode, Throwable cause) {
  24.         super(message, cause);
  25.         this.code = code;
  26.         this.tranCode = tranCode;
  27.     }
  28.  
  29.     public String getCode() {
  30.         return code;
  31.     }
  32.  
  33.     public void setCode(String code) {
  34.         this.code = code;
  35.     }
  36.  
  37.     public String getTranCode() {
  38.         return tranCode;
  39.     }
  40.  
  41.     public void setTranCode(String tranCode) {
  42.         this.tranCode = tranCode;
  43.     }
  44. }
  1. package com.spark.exception;
  2.  
  3. /**
  4.  * SystemException class
  5.  * description: SystemException
  6.  *
  7.  * @author Administrator
  8.  * @date 2023/8/5
  9.  */
  10. public class SystemException extends RuntimeException {
  11.  
  12.     private String code; // 错误编码
  13.  
  14.     private String tranCode; // 交易码(接口号)
  15.  
  16.  
  17.     public SystemException(String code, String message, String tranCode) {
  18.         super(message);
  19.         this.code = code;
  20.         this.tranCode = tranCode;
  21.     }
  22.  
  23.     public SystemException(String code,String message, String tranCode, Throwable cause) {
  24.         super(message, cause);
  25.         this.code = code;
  26.         this.tranCode = tranCode;
  27.     }
  28.  
  29.     public String getCode() {
  30.         return code;
  31.     }
  32.  
  33.     public void setCode(String code) {
  34.         this.code = code;
  35.     }
  36.  
  37.     public String getTranCode() {
  38.         return tranCode;
  39.     }
  40.  
  41.     public void setTranCode(String tranCode) {
  42.         this.tranCode = tranCode;
  43.     }
  44. }

自定义异常错误编码和错误信息 

  1. package com.spark.common;
  2.  
  3. /**
  4.  * ExceptionContent class
  5.  * description: ExceptionContent
  6.  *
  7.  * @author Administrator
  8.  * @date 2023/8/5
  9.  */
  10. public class ExceptionContent {
  11.  
  12.     public static final String BUSINESS_ERROR_CODE = "50001";
  13.     public static final String BUSINESS_DATA_ERROR = "数据有误，请检查您的数据格式是否正确！";
  14.     public static final String BUSINESS_ERROR_MSG = "操作有误，请联系管理员!";
  15.     
  16.     public static final String SYSTEM_ERROR_CODE = "50002";
  17.     public static final String SYSTEM_ERROR_MSG = "服务器异常，请您稍后重试!";
  18.     
  19.     public static final String SYSTEM_UNKNOWN_ERROR_CODE = "50003";
  20.     public static final String SYSTEM_UNKNOWN_MSG = "系统繁忙，请联系管理员!";
  21. }

改写业务层根据id查询Book方法，处理异常

  1. @Override
  2. public Book selectById(Integer id) {
  3.     if(id<=0){
  4.         throw new BusinessException(ExceptionContent.BUSINESS_ERROR_CODE,
  5.                                     ExceptionContent.BUSINESS_DATA_ERROR,
  6.                                     "BK1004",
  7.                                     new Throwable(ExceptionContent.BUSINESS_DATA_ERROR));
  8.     }
  9.     return bookDao.getById(id);
  10. }

编写异常处理器统一处理异常

  1. package com.spark.exception;
  2.  
  3. import com.spark.common.ExceptionContent;
  4. import com.spark.util.Result;
  5. import org.springframework.web.bind.annotation.ExceptionHandler;
  6. import org.springframework.web.bind.annotation.RestControllerAdvice;
  7.  
  8. /**
  9.  * ProjectExceptionAdvice class
  10.  * description: ProjectExceptionAdvice
  11.  *
  12.  * @author Administrator
  13.  * @date 2023/8/5
  14.  */
  15. @RestControllerAdvice
  16. public class ProjectExceptionAdvice {
  17.  
  18.     // 处理业务异常
  19.     @ExceptionHandler
  20.     public Result doBusinessException(BusinessException ex){
  21.         // 记录日志
  22.         System.out.println(ex.getTranCode() + "出现异常");
  23.         return new Result(ex.getCode(),ex.getMessage(),null);
  24.     }
  25.  
  26.     // 处理系统异常
  27.     @ExceptionHandler
  28.     public Result doSystemException(SystemException sy){
  29.         // 记录日志
  30.         System.out.println(sy.getTranCode() + "出现异常");
  31.         return new Result(sy.getCode(),sy.getMessage(),null);
  32.     }
  33.     
  34.     // 处理其他未知异常
  35.     @ExceptionHandler
  36.     public Result doException(Exception ex){
  37.         // 记录日志
  38.         System.out.println("出现未知异常");
  39.         System.out.println("异常信息如下:");
  40.         System.out.println(ex.getMessage());
  41.         return new Result(ExceptionContent.SYSTEM_UNKNOWN_ERROR_CODE,
  42.                 ExceptionContent.SYSTEM_UNKNOWN_MSG,
  43.                 null);
  44.     }
  45. }

前后台联调 

由于后台Servlet容器配置里面是拦截一切请求，前端代码在项目的webapp目录下，Tomcat启动后，去访问前端页面会被拦截，因此需要对前端资源进行放行

编写SpringMVC资源放行配置类

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
  5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
  6.  
  7. /**
  8.  * SpringMvcSupportConfig class
  9.  * description: SpringMvcSupportConfig
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/8/5
  13.  */
  14. @Configuration
  15. public class SpringMvcSupportConfig extends WebMvcConfigurationSupport {
  16.  
  17.     @Override
  18.     protected void addResourceHandlers(ResourceHandlerRegistry registry) {
  19.         registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
  20.         registry.addResourceHandler("/css/**").addResourceLocations("/css/");
  21.         registry.addResourceHandler("/js/**").addResourceLocations("/js/");
  22.         registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
  23.     }
  24. }

在SpringMVC配置类中扫描config包

  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
  6.  
  7. /**
  8.  * SpringMvcConfig class
  9.  * description: SpringMvcConfig
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/8/3
  13.  */
  14. @Configuration
  15. @ComponentScan({"com.spark.controller","com.spark.config"})
  16. @EnableWebMvc
  17. public class SpringMvcConfig {
  18. }

 拦截器

概述 

拦截器是一种动态拦截方法调用的机制，在SpringMVC中动态拦截控制器方法的执行

作用：在指定的方法调用前后执行预先设定的代码；阻止原始方法的执行

拦截器和过滤器的区别

  • 归属不同。Filter属于Servlet技术，Inteceptor属于SpringMVC技术
  • 拦截内容不同。Filter对所有访问进行增强，Inteceptor仅对SpringMVC的访问进行增强 

入门案例 

编写拦截器

  1. package com.spark.interceptor;
  2.  
  3. import org.springframework.stereotype.Component;
  4. import org.springframework.web.servlet.HandlerInterceptor;
  5. import org.springframework.web.servlet.ModelAndView;
  6.  
  7. import javax.servlet.http.HttpServletRequest;
  8. import javax.servlet.http.HttpServletResponse;
  9.  
  10. /**
  11.  * ProjectInteceptor class
  12.  * description: ProjectInteceptor
  13.  *
  14.  * @author Administrator
  15.  * @date 2023/8/7
  16.  */
  17. @Component
  18. public class ProjectInteceptor implements HandlerInterceptor {
  19.  
  20.     @Override
  21.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  22.         System.out.println("原始方法执行前执行...");
  23.         return true;
  24.     }
  25.  
  26.     @Override
  27.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
  28.         System.out.println("原始方法执行后执行...");
  29.     }
  30.  
  31.     @Override
  32.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  33.         System.out.println("postHandle执行后执行...");
  34.     }
  35. }

SpringMVC配置类中添加拦截器并扫描

  1. package com.spark.config;
  2.  
  3. import com.spark.interceptor.ProjectInteceptor;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  7. import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
  8. import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
  9.  
  10. /**
  11.  * SpringMvcSupportConfig class
  12.  * description: SpringMvcSupportConfig
  13.  *
  14.  * @author Administrator
  15.  * @date 2023/8/5
  16.  */
  17. @Configuration
  18. public class SpringMvcSupportConfig extends WebMvcConfigurationSupport {
  19.  
  20.     @Autowired
  21.     ProjectInteceptor projectInteceptor;
  22.  
  23.     @Override
  24.     protected void addResourceHandlers(ResourceHandlerRegistry registry) {
  25.         registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
  26.         registry.addResourceHandler("/css/**").addResourceLocations("/css/");
  27.         registry.addResourceHandler("/js/**").addResourceLocations("/js/");
  28.         registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
  29.     }
  30. 	
  31.     // 添加拦截器
  32.     @Override
  33.     public void addInterceptors(InterceptorRegistry registry) {
  34.         registry.addInterceptor(projectInteceptor).addPathPatterns("/books/*","/books");
  35.     }
  36. }
  1. package com.spark.config;
  2.  
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
  6.  
  7. /**
  8.  * SpringMvcConfig class
  9.  * description: SpringMvcConfig
  10.  *
  11.  * @author Administrator
  12.  * @date 2023/8/3
  13.  */
  14. @Configuration
  15. @ComponentScan({"com.spark.controller","com.spark.config","com.spark.interceptor"})
  16. @EnableWebMvc
  17. public class SpringMvcConfig{
  18.  
  19. }

拦截器链 

当配置多个拦截器时，形成拦截器链

多拦截器执行顺序

  • 当配置多个拦截器时，形成拦截器链
  • 拦截器链的运行顺序参照拦截器添加顺序为准
  • 当拦截器中出现对原始处理器的拦截，后面的拦截器均终止执行
  • 当拦截器运行中断，仅运行配置在前面的拦截器的afterCompletion操作 

preHandle方法按照拦截器配置顺序执行，postHandle和afterCompletion方法按照配置顺序倒序执行 

工作流程

  1. 用户发送请求至前端控制器DispatcherServlet
  2. DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle
  3. 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet
  4. DispatcherServlet调用HandlerAdapter处理器适配器
  5. HandlerAdapter经过适配调用具体处理器（Handler，也叫后端控制器）
  6. Handler执行完毕后返回ModelAndView
  7. HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet
  8. DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析
  9. ViewResolver解析后返回具体View
  10. DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）
  11. DispatcherServlet响应用户 
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小舞很执着/article/detail/919916
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号