SSM（spring+springmvc+mybatis）整合

🕗 发布于 2024-01-10 16:58 spring mybatis java ssm

spring与SpringMvc的常用注解

一、spring常用注解：

@Component：实现bean的注入（不过获取bean需要用bean的类型来获取（即class文件））
@controller、@Service、@Repository的作用等同于@Component注解的作用，相当于其别名，只是为了更好的区分表现层，业务层，数据层的注解，web开发，提供3个@Component注解衍生注解（功能一样）取代括号里一般不用参数
- @Repository(“名称”)：dao层
- @Service(“名称”)：service层
- @Controller(“名称”)：web层（控制层）
@Configuration：用于设定当前类为核心配置类
@ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据要用数组的格式
@Scope：定义bean的作用范围
- (@Scope(“singleton”)：单实例的(单例)(默认)
- （@Scope(“prototype”)：该bean为非单例模式）
定义bean的生命周期：
- @ PostConstruct 自定义初始化（构造方法后）
- @ PreDestroy 自定义销毁（销毁前）
@Autowired：自动根据类型进行装配
@Qualifier：指定自动注入的bean的名称（需要和@Autowired集合使用）
@Value：实现简单类型注入
@PropertySource：加载properties文件（其路径仅支持单一文件配置，多文件请使用数组格式配置，不允许使用通配符*）
@Bean：表示当前方法的返回值是一个bean（配置第三方bean，使用在方法上）
@Import：将某个类配置到配置类的核心配置，此注解只能添加一次，多个数据请用数组格式

二、测试类的注解：

@RunWith()：设定类运行器。（@RunWith(SpringJUnit4ClassRunner.class)）
@ContextConfiguration()：告诉测试类环境的配置（@ContextConfiguration(classes = SpringConfig.class)）
- SpringConfig.class是spring核心配置类

三、事务方面的注解：

@Transactional：代表开始事务，通常不写在实现类上，而是写到接口上
- 在Service中，被 @Transactional 注解的方法，将支持事务。如果注解在类上，则整个类的所有方法都默认支持事务
@EnableTransactionManagement：事务总开关，即开启注解事务管理（放在SpringConfig类上方）

四、springMVC注解：

@RequestMapping：是一个用来处理请求地址映射的注解，可用于映射一个请求或一个方法，可以用在类或方法上
@ResponseBody：
- 2.1 设置当前操作的返回值类型（设置当前控制器方法响应内容为当前返回值，无需解析）
- 2.2 设置当前控制器返回值作为响应体
@RequestParam：当请求参数名和形参参数名不一样的时候，可以使用@RequestParam()绑定请求参数和形参的关系。
@RequestBody：将前端发送的请求中的请求体所包含的数据传递给请求参数，此注解一个处理器方法（其实就是方法）只能使用一次（传递json数据时使用）
@EnableWebMvc：开启SpringMVC多项辅助功能（开启自动转化json数据的支持（就是说，前端传过来的json数据自动转换为实体类的对象），放在SpringMvcConfig上方）
@PathVariable：绑定路径参数与处理器方法形参之间的关系，要求路径参数名与形参名一一对应。
@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@ExceptionHandler类型：设置指定异常的处理方案，功能等同于控制器方法，出现异常后终止原始控制器执行,并转入当前方法执行。

五、REST风格注解：

@RestController：设置当前控制器类为RESTful风格，等同于@Controller与ResponseBody两个注解组合功能
@GetMapping：查询，贴在请求映射方法上，等价于：@RequestMapping(method = RequestMethod.GET)
@PostMapping：新增/保存，贴在请求映射方法上，等价于：@RequestMapping(method = RequestMethod.POST)
@PutMapping：修改/更新，贴在请求映射方法上，等价于：@RequestMapping(method = RequestMethod.PUT)
@DeleteMapping：删除，贴在请求映射方法上，等价于：@RequestMapping(method = RequestMethod.DELETE)

ssm整合（注解式）

整合流程

创建工程
- 创建一个maven工程
- 在pom.xml文件中导入对应的依赖
- 添加web框架------------------------------------》如何添加web框架
ssm的配置的整合（使用配置类代替原始的配置文件操作）
- spring
  - SpringConfig（spring的核心配置类）
- Mybatis
  - MybatisConfig（mybatis的配置类）
  - JdbcConfig（jdbc的数据处理类）
  - jdbc.properties（数据库的配置文件，数据库连接四要素）
- SpringMvC
  - ServletConfig（Web项目入口配置类）
  - SpringMvcConfig（SpringMVC的核心配置类）
功能的实现
- 实体类
- 整合类（Result）
- mapper层（接口+自动代理）
- service（接口+实现类）
- controller（表现层）

在这里插入图片描述

配置类

一、添加依赖

注意：记得设置项目的打包方式：war

<?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>com.knife</groupId>
    <artifactId>ssm</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

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

        <!--        这个依赖包含Spring MVC框架相关的所有类。-->
        <!--spring-context依赖为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <!--        基于spring测试所使用的依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <!--        这个依赖对Spring对JDBC数据访问进行封装的所有类。-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.31</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

        <!--        -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

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

    </dependencies>

</project>

二、按照上图创建项目包结构

config目录存放的是相关的配置类
controller层下放的是Controller类
mapper层下存放的是Mapper接口，因为使用的是Mapper接口代理方式，所以没有实现类包
pojo层下是存放实体类
service存的是Service接口，impl存放的是Service实现类
resources:存入的是配置文件，如Jdbc.properties
web：目录可以存放静态资源
test/java:存放的是测试类

三、创建JdbcConfig配置类

public class JdbcConfig {
    @Value("${jdbc.driver}")  //简单类型注入，即把jdbc.driver的值赋值给变量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;
    }


    //配置事务管理器，mybatis使用的是jdbc事务
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        ds.setDataSource(dataSource);
        return ds;
    }
}

四、编写SpringConfig(spring的核心配置类）

@Configuration //设定当前类为**核心配置类**
@ComponentScan({"com.knife.service"})//加载他要控制的那些bean
@PropertySource("classpath:jdbc.properties") //加载properties文件
@Import({JdbcConfig.class,MyBatisConfig.class}) //将某个类配置到 配置类的核心配置
@EnableTransactionManagement//开启注解式事务驱动
public class SpringConfig {
}

五、创建MybatisConfig配置类

public class MyBatisConfig {

    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("com.knife.pojo");
        return factoryBean;
    }

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

}

六、创建jdbc.properties

在resources下提供jdbc.properties,设置数据库连接四要素

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db
jdbc.username=root
jdbc.password=dadao

七、创建SpringMVC配置类

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

八、创建Web项目入口配置类

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
//加载Spring配置类
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }
 //加载SpringMVC配置类
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

 //设置SpringMVC请求地址拦截规则
//    springmvc设定拦截所有的请求，把也页面的请求也给拦截了（表示所有的访问都会经过springmvc中）
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }



//设置post请求中文乱码过滤器
//    处理表单提交中文过滤器的
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();//字符过滤器
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

这里springMVC被设定拦截所有的请求，自然也会拦截静态资源的请求，当我们请求静态资源的时候，所有的访问都会经过springmvc中，发现无法找到资源。

功能模块的实现

实现数据库的增删改查

数据库的创建

create database ssm_db character set utf8;
use ssm_db;
create table tbl_book(
  id int primary key auto_increment,
  type varchar(20),
  name varchar(50),
  description varchar(255)
)

insert  into `tbl_book`(`id`,`type`,`name`,`description`) values (1,'计算机理论','Spring实战 第五版','Spring入门经典教程，深入理解Spring原理技术内幕'),(2,'计算机理论','Spring 5核心原理与30个类手写实践','十年沉淀之作，手写Spring精华思想'),(3,'计算机理论','Spring 5设计模式','深入Spring源码刨析Spring源码中蕴含的10大设计模式'),(4,'计算机理论','Spring MVC+Mybatis开发从入门到项目实战','全方位解析面向Web应用的轻量级框架，带你成为Spring MVC开发高手'),(5,'计算机理论','轻量级Java Web企业应用实战','源码级刨析Spring框架，适合已掌握Java基础的读者'),(6,'计算机理论','Java核心技术 卷Ⅰ 基础知识(原书第11版)','Core Java第11版，Jolt大奖获奖作品，针对Java SE9、10、11全面更新'),(7,'计算机理论','深入理解Java虚拟机','5个纬度全面刨析JVM,大厂面试知识点全覆盖'),(8,'计算机理论','Java编程思想(第4版)','Java学习必读经典，殿堂级著作！赢得了全球程序员的广泛赞誉'),(9,'计算机理论','零基础学Java(全彩版)','零基础自学编程的入门图书，由浅入深，详解Java语言的编程思想和核心技术'),(10,'市场营销','直播就这么做:主播高效沟通实战指南','李子柒、李佳奇、薇娅成长为网红的秘密都在书中'),(11,'市场营销','直播销讲实战一本通','和秋叶一起学系列网络营销书籍'),(12,'市场营销','直播带货:淘宝、天猫直播从新手到高手','一本教你如何玩转直播的书，10堂课轻松实现带货月入3W+');

实体类

public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", type='" + type + '\'' +
                ", name='" + name + '\'' +
                ", description='" + description + '\'' +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

结果封装类

封装类的实现可以参考一下这个：表现层（controller）与前端数据传输协议定义
result

package com.knife.controller;

public class Result {
    private Object data;
    private Integer code;
    private String msg;

    public Result() {
    }

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

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

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Integer getCode() {
        return code;
    }

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

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

code


public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;

    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;

    public static final Integer SYSTEM_ERR = 50001;
    public static final Integer SYSTEM_TIMEOUT_ERR = 50002;
    public static final Integer SYSTEM_UNKNOW_ERR = 59999;

    public static final Integer BUSINESS_ERR = 60002;



}

控制层

@RestController
@RequestMapping("/books")
public class BookController {

    @Autowired
    private BookService bookService;

    @PostMapping
    public Result save(@RequestBody Book book) {
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK:Code.SAVE_ERR,flag);
    }

    @PutMapping
    public Result update(@RequestBody Book book) {
        boolean flag = bookService.update(book);
        return new Result(flag ? Code.UPDATE_OK:Code.UPDATE_ERR,flag);
    }

    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
        boolean flag = bookService.delete(id);
        return new Result(flag ? Code.DELETE_OK:Code.DELETE_ERR,flag);
    }

    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        Book book = bookService.getById(id);
        Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
        String msg = book != null ? "" : "数据查询失败，请重试！";
        return new Result(code,book,msg);
    }

    @GetMapping
    public Result getAll() {
        List<Book> bookList = bookService.getAll();
        Integer code = bookList != null ? Code.GET_OK : Code.GET_ERR;
        String msg = bookList != null ? "" : "数据查询失败，请重试！";
        return new Result(code,bookList,msg);
    }
}

业务层

业务层接口

@Transactional
public interface BookService {

    /**
     * 保存
     * @param book
     * @return
     */
    public boolean save(Book book);

    /**
     * 修改
     * @param book
     * @return
     */
    public boolean update(Book book);

    /**
     * 按id删除
     * @param id
     * @return
     */
    public boolean delete(Integer id);

    /**
     * 按id查询
     * @param id
     * @return
     */
    public Book getById(Integer id);

    /**
     * 查询全部
     * @return
     */
    public List<Book> getAll();
}

业务层

@Service
public class BookServiceImpl implements BookService {

    @Autowired
    private BookMapper bookMapper;//这里并不是报错，只是spring自动代理还没有加载到对应的bean

    public boolean save(Book book) {
        return bookMapper.save(book)>0;
    }

    public boolean update(Book book) {
        return bookMapper.update(book) > 0;
    }

    public boolean delete(Integer id) {
        return bookMapper.delete(id) > 0;
    }

    public Book getById(Integer id) {
        return bookMapper.getById(id);
    }

    public List<Book> getAll() {
        return bookMapper.getAll();
    }
}

数据层（mapper）

public interface BookMapper {

    @Insert("insert into tbl_book (type,name,description) values(#{type},#{name},#{description})")
    public int save(Book book);

    @Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
    public int update(Book book);

    @Delete("delete from tbl_book where id = #{id}")
    public int delete(Integer id);

    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);

    @Select("select * from tbl_book")
    public List<Book> getAll();
}

到这里ssm的整合就算基本完成了，只是单纯后端的实现，并没有使用到前端。

单元测试

对于业务层的测试：Spring整合Junit的知识点进行单元测试:其实和普通的单元测试差别就在于使用了@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)两个注解，这样测试的时候会通过spring内部。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class BookServiceTest {

// 业务层对象，通过 @Autowired自动注入
    @Autowired
    private BookService bookService;

    @Test
    public void testGetById(){
        Book book = bookService.getById(1);
        System.out.println(book);
    }

    @Test
    public void testGetAll(){
        List<Book> all = bookService.getAll();
        System.out.println(all);
    }

}

对于控制层的测试：使用postman测试即可（实在不行可以直接搜索每个方法对应的访问路径）。
查询全部的测试：直接输入路径然后访问
在这里插入图片描述

对异常进行统一处理

异常的种类及出现异常的原因:
- 框架内部抛出的异常：因使用不合规导致
- 数据层抛出的异常：因外部服务器故障导致（例如：服务器访问超时）
- 业务层抛出的异常：因业务逻辑书写错误导致（例如：遍历业务书写操作，导致索引异常等）
- 表现层抛出的异常：因数据收集、校验等规则导致（例如：不匹配的数据类型间导致异常）
- 工具类抛出的异常：因工具类书写不严谨不够健壮导致（例如：必要释放的连接长期未释放等）
思考问题：
- 1. 各个层级均出现异常，异常处理代码书写在哪一层?
  - 所有的异常均抛出到表现层进行处理
- 1. 异常的种类很多，表现层如何将所有的异常都处理到呢?
  - 异常分类
- 1. 表现层处理异常，每个方法中单独书写，代码书写量巨大且意义不强，如何解决?
  - AOP
问题解决：
- 使用异常处理器:
  - 集中的、统一的处理项目中出现的异常。

异常处理器的使用

在前面的ssm整合的基础下，创建异常处理器类（可以放在controller层下，因为SpringMvcController配置类把controller层下的所有类到扫描到了@ComponentScan(“com.knife.controller”)，你也可以自己创建一个异常处理器包，然后把包的路径添加到@ComponentScan里确保SpringMvcConfig能够扫描到异常处理器类。

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public void doException(Exception ex){
      System.out.println("嘿嘿,异常你哪里跑！")
    }
}

使用之后，如果项目出现异常就会跑到异常处理器里面，执行里面对应的方法。

异常分类

因为异常的种类有很多，如果每一个异常都对应一个@ExceptionHandler，那得写多少个方法来处理各自的异常，所以我们在处理异常之前，需要对异常进行一个分类:
- 一、业务异常（BusinessException）
  - 1. 规范的用户行为产生的异常
    - 例子：用户在页面输入内容的时候未按照指定格式进行数据填写，如在年龄框输入的是字符串
  - 1. 不规范的用户行为操作产生的异常
    - 例子：如用户故意传递错误数据
- 二、系统异常（SystemException）
  - 1. 项目运行过程中可预计但无法避免的异常
    - 例子：比如数据库或服务器宕机
- 三、其他异常（Exception）
  - 编程人员未预期到的异常，如:用到的文件不存在

异常解决方案

业务异常（BusinessException）
- 发送对应消息传递给用户，提醒规范操作
  - 大家常见的就是提示用户名已存在或密码格式不正确等
系统异常（SystemException）
- 发送固定消息传递给用户，安抚用户
  - 系统繁忙，请稍后再试
  - 系统正在维护升级，请稍后再试
  - 系统出问题，请联系系统管理员等
- 发送特定消息给运维人员，提醒维护
  - 可以发送短信、邮箱或者是公司内部通信软件
- 记录日志
  - 发消息和记录日志对用户来说是不可见的，属于后台程序
其他异常（Exception）
- 发送固定消息传递给用户，安抚用户
- 发送特定消息给编程人员，提醒维护（纳入预期范围内）
  - 一般是程序没有考虑全，比如未做非空校验等
- 记录日志

异常解决方案的实现

在这里插入图片描述

思路:

1.先通过自定义异常，完成BusinessException和SystemException的定义

2.将其他异常包装成自定义异常类型

3.在异常处理器类中对不同的异常进行处理

步骤1:自定义异常类

SystemException：

//自定义异常处理器，用于封装异常信息，对异常进行分类
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 message) {
        super(message);
        this.code = code;
    }

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

}

BusinessException :

//自定义异常处理器，用于封装异常信息，对异常进行分类
public class BusinessException extends RuntimeException{
    private Integer code;

    public Integer getCode() {
        return code;
    }

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

    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
    }

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

}

说明:
- 让自定义异常类继承RuntimeException的好处是，后期在抛出这两个异常的时候，就不用在try…catch…或throws了
- 自定义异常类中添加code属性的原因是为了更好的区分异常是来自哪个业务的

步骤2:将其他异常抛出的时候使用自定义异常

具体的包装方式有：
- 方式一:try{}catch(){}在catch中重新throw我们自定义异常即可。
- 方式二:直接throw自定义异常即可

public Book getById(Integer id) {
//方式一
    //模拟业务异常，包装成自定义异常
    if(id == 1){
        throw new BusinessException(Code.BUSINESS_ERR,"请不要使用你的技术挑战我的耐性!");
    }
// 方式二
    //模拟系统异常，将可能出现的异常进行包装，转换成自定义异常
    try{
        int i = 1/0;
    }catch (Exception e){
        throw new SystemException(Code.SYSTEM_TIMEOUT_ERR,"服务器访问超时，请重试!",e);
    }



    return bookDao.getById(id);
}

code类需要使用到的常量，上面已经定义好了。不同的状态码代表着不同的意义，根据自己的需求设计即可。

步骤3:在异常处理器类中处理自定义异常

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //@ExceptionHandler用于设置当前处理器类对应的异常类型
    @ExceptionHandler(SystemException.class)
    public Result doSystemException(SystemException ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(ex.getCode(),null,ex.getMessage());
    }

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

    //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public Result doOtherException(Exception ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex对象发送给开发人员
        return new Result(Code.SYSTEM_UNKNOW_ERR,null,"系统繁忙，请稍后再试！");
    }
}

在这里插入图片描述

前后台协议联调

在这里插入图片描述
配置静态资源访问映射：

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {

    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
//        addResourceHandler（） 添加的是访问路径
//        addResourceLocations（）添加的是映射后的真实路径，映射的真实路径末尾必须加 / ,不然映射不到
//        就是说把访问路径映射到本地路径
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
  
}

在SpringMvcConfig中扫描SpringMvcSupport

@Configuration
@ComponentScan({"com.itheima.controller","com.itheima.config"})
@EnableWebMvc
public class SpringMvcConfig {
}

addResourceHandlers方法（配置静态资源处理）

addResourceHandlers方法（配置静态资源处理）是SpringMVC框架提供的一种配置静态资源的方式。它可以将指定的资源路径映射到一个或多个URL路径上，并指定资源的缓存策略、版本号以及是否允许目录列表等选项。

具体使用方法如下：

@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**")
                .addResourceLocations("classpath:/static/")
                .setCacheControl(CacheControl.maxAge(1, TimeUnit.HOURS))
                .resourceChain(true)
                .addResolver(new VersionResourceResolver().addContentVersionStrategy("/**"));
    }
}

上述代码中，我们创建了一个WebConfig类，并实现了WebMvcConfigurer接口。在该类中，我们重写了addResourceHandlers方法，并在其中进行了静态资源的配置。

在addResourceHandlers方法中，我们通过registry对象调用addResourceHandler方法来添加一个处理器。在这个方法中，我们可以指定资源的URL路径，例如/static/**，表示所有以/static/开头的URL路径都会被映射到静态资源上。

接着，我们使用addResourceLocations方法指定了静态资源的位置，这里我们使用了classpath:/static/，表示静态资源位于项目的classpath下的static目录。

然后，我们使用setCacheControl方法设置了资源的缓存策略，这里我们设置了缓存时间为1小时。

接下来，我们使用resourceChain方法开启了资源链，这样可以支持版本号的处理。

最后，我们使用addResolver方法添加了一个资源解析器，这里我们使用了VersionResourceResolver，并通过addContentVersionStrategy方法指定了版本号的策略。

通过以上配置，我们可以将静态资源映射到指定的URL路径上，并进行缓存策略和版本号的配置。

拦截器（追加功能）

拦截器的概念

在这里插入图片描述

上图讲解：
- (1)浏览器发送一个请求会先到Tomcat的web服务器
- (2)Tomcat服务器接收到请求以后，会去判断请求的是静态资源还是动态资源
- (3)如果是静态资源，会直接到Tomcat的项目部署目录下去直接访问
- (4)如果是动态资源，就需要交给项目的后台代码进行处理
- (5)在找到具体的方法之前，我们可以去配置过滤器(可以配置多个)，按照顺序进行执行
- (6)然后进入到到中央处理器(SpringMVC中的内容)，SpringMVC会根据配置的规则进行拦截
- (7)如果满足规则，则进行处理，找到其对应的controller类中的方法进行执行,完成后返回结果
- (8)如果不满足规则，则不进行处理
需求：需要在每个Controller方法执行的前后添加业务
- 实现：使用拦截器
拦截器（Interceptor）是一种动态拦截方法调用的机制，在SpringMVC中动态拦截控制器方法的执行
- 作用:
  - 在指定的方法调用前后执行预先设定的代码
  - 阻止原始方法的执行
总结：拦截器就是用来做增强
拦截器和过滤器在作用和执行顺序上也很相似
- 所以这个时候，就有一个问题需要思考:拦截器和过滤器之间的区别是什么?
  - 归属不同：Filter属于Servlet技术，Interceptor属于SpringMVC技术
  - 拦截内容不同：Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强

拦截器的开发（在ssm整合基础上添加拦截器）

在这里插入图片描述

步骤：
- 1. 创建拦截器类
- 1. 配置拦截器
- 1. SpringMVC添加SpringMvcSupport包扫描

步骤1：创建拦截器类：（可以创建多个拦截器类，然后在配置的时候使用。）

@Component
//定义拦截器类，实现HandlerInterceptor接口
//注意当前类必须受Spring容器控制
public class ProjectInterceptor implements HandlerInterceptor {
    @Override
    //原始方法调用前执行的内容
    //返回值类型可以拦截控制的执行，true放行，false终止
//    前置方法
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String contentType = request.getHeader("Content-Type");
        HandlerMethod hm = (HandlerMethod)handler;
        System.out.println("preHandle..."+contentType);
        return true;
        //用false可以终止原始操作的运行，拦截器中的`preHandler`方法，
        // 如果返回true,则代表放行，会执行原始Controller类中要请求的方法，
        // 如果返回false，则代表拦截，后面的就不会再执行了。

//        请求参数说明：
//                  * request:请求对象：使用request对象可以获取请求数据中的内容，如获取请求头的`Content-Type`
//                * response:响应对象：使用handler参数，可以获取方法的相关信息
//                * handler:被调用的处理器对象，本质上是一个方法对象，对反射中的Method对象进行了再包装
    }

    @Override
    //原始方法调用后执行的内容
//    后置方法
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
    }

    @Override
    //原始方法调用完成后执行的内容
//    完成后方法
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");

//        ex:如果处理器执行过程中出现异常对象，可以针对异常情况进行单独处理
//
//        因为现在已经有全局异常处理器类，所以该参数的使用率也不高。
    }
}

注意：拦截器类要被SpringMVC容器扫描到。
步骤2：配置拦截器：


@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
//        addResourceHandler（） 添加的是访问路径
//        addResourceLocations（）添加的是映射后的真实路径，映射的真实路径末尾必须加 / ,不然映射不到
//        就是说把访问路径映射到本地路径
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        //配置拦截器（你访问哪个请求的时候，需要拦截）
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
    }
}

步骤3:SpringMVC添加SpringMvcSupport包扫描

@Configuration
@ComponentScan({"com.itheima.controller","com.itheima.config"})
@EnableWebMvc
public class SpringMvcConfig{
   
}

在这里插入图片描述

原文地址：https://blog.csdn.net/weixin_64044840/article/details/135321189

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：k8s的集群调度---下
下一篇：17. 从零用Rust编写正反向代理, Rust中一些功能的实现

反向代理模块
反向代理是指以代理服务器来接收客户端的请求，然后将请求转发给内部网络上的服务器，将从服务器上得到的结果返回给客户端，此时代理服务器对外表现为一个反向代理服务器。不适用代理的情况下，外网不能访问企业内网
阅读更多2024-11-18
C++：模板（2）
带你再次了解模板的奥妙
阅读更多2024-11-18
使用python自制桌面宠物,好玩!——枫原万叶桌宠，可以直接打包成exe去跟朋友炫耀。。。
使用python自制桌面宠物,好玩!——枫原万叶桌宠，可以直接打包成exe去跟朋友炫耀。。。
阅读更多2024-11-18
K210学习总结
本人用的是01科技的K210模块，感觉非常棒。
阅读更多2024-11-18
C/C++：指针数组与数组指针
指针数组：数组中的每个元素都是指针。，表示一个数组，数组内有 5 个指针，每个指针指向int类型的数据。数组指针：一个指向数组的指针。，表示一个指向含有 5 个int类型元素的数组的指针。
阅读更多2024-11-18
【Android】setLayoutParams Sometimes Not Working
【代码】【Android】setLayoutParams Sometimes Not Working。
阅读更多2024-11-18
sql数据库增删改数据（DML）
【代码】sql数据库增删改数据（DML）
阅读更多2024-11-18
【Linux】内核中申请内存的方法
都是用于内核空间申请内存都是以字节为单位进行分配所分配的内存，在虚拟地址上连续kzalloc是强制清零的kmalloc操作kmalloc和kzalloc分配的内存大小有限制（128KB），而vmall
阅读更多2024-11-18
【C++ 算法进阶】算法提升十六
据说著名犹太历史学家Josephus（弗拉维奥·约瑟夫斯）有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决
阅读更多2024-11-18
构建SSH僵尸网络
第一种：终端控制：python your_script.py --host IP1 IP2 --user user1 user2 --password password1 password2。# 为每
阅读更多2024-11-18

SSM（spring+springmvc+mybatis）整合

spring与SpringMvc的常用注解

一、spring常用注解：

二、测试类的注解：

三、事务方面的注解：

四、springMVC注解：

五、REST风格注解：

ssm整合（注解式）

整合流程

配置类

一、添加依赖

二、按照上图创建项目包结构

三、创建JdbcConfig配置类

四、编写SpringConfig(spring的核心配置类）

五、创建MybatisConfig配置类

六、创建jdbc.properties

七、创建SpringMVC配置类

八、创建Web项目入口配置类

功能模块的实现

数据库的创建

实体类

结果封装类

控制层

业务层

数据层（mapper）

单元测试

对异常进行统一处理

异常处理器的使用

异常分类

异常解决方案

异常解决方案的实现

步骤1:自定义异常类

步骤2:将其他异常抛出的时候使用自定义异常

步骤3:在异常处理器类中处理自定义异常

前后台协议联调

addResourceHandlers方法（配置静态资源处理）

拦截器（追加功能）

拦截器的概念

拦截器的开发（在ssm整合基础上添加拦截器）

相关文章