【SpringBoot2】基于SpringBoot实现SSMP整合

浅浅的花香味﹌ 2024-04-07 13:21 118阅读 0赞

前言

    重头戏来了，SpringBoot之所以好用，就是它能方便快捷的整合其他技术，本文讲解一些技术的整合方式，通过这本文的学习，感受SpringBoot到底有多酷炫。本文学习如下技术的整合方式

  • 整合JUnit
  • 整合MyBatis
  • 整合MyBatis-Plus
  • 整合Druid

文章目录

  • 前言
    • 一、整合JUnit
    • 二、整合MyBatis
    • 三、整合MyBatis-Plus
    • 四、整合Druid

一、整合JUnit

    SpringBoot技术的定位用于简化开发，再具体点是简化Spring程序的开发。所以在整合任意技术的时候，如果你想直观感触到简化的效果，你必须先知道使用非SpringBoot技术时对应的整合是如何做的，然后再看基于SpringBoot的整合是如何做的，才能比对出来简化在了哪里。

我们先来看一下不使用SpringBoot技术时，Spring整合JUnit的制作方式

  1. //加载spring整合junit专用的类运行器
  2. @RunWith(SpringJUnit4ClassRunner.class)
  3. //指定对应的配置信息
  4. @ContextConfiguration(classes = SpringConfig.class)
  5. public class AccountServiceTestCase {
  7.     //注入你要测试的对象
  8.     @Autowired
  9.     private AccountService accountService;
  10.     @Test
  11.     public void testGetById(){
  13.         //执行要测试的对象对应的方法
  14.         System.out.println(accountService.findById(2));
  15.     }
  16. }

    其中核心代码是前两个注解，第一个注解@RunWith是设置Spring专用的测试类运行器，简单说就是Spring程序执行程序有自己的一套独立的运行程序的方式，不能使用JUnit提供的类运行方式了，必须指定一下，但是格式是固定的，琢磨一下，每次都指定一样的东西，这个东西写起来没有技术含量啊，第二个注解@ContextConfiguration是用来设置Spring核心配置文件或配置类的，简单说就是加载Spring的环境你要告诉Spring具体的环境配置是在哪里写的，虽然每次加载的文件都有可能不同，但是仔细想想，如果文件名是固定的，这个貌似也是一个固定格式。既然有可能是固定格式，那就有可能每次都写一样的东西，也是一个没有技术含量的内容书写

SpringBoot就抓住上述两条没有技术含量的内容书写进行开发简化，能走默认值的走默认值，能不写的就不写，具体格式如下

  1. @SpringBootTest
  2. class Springboot04JunitApplicationTests {
  4.     //注入你要测试的对象
  5.     @Autowired
  6.     private BookDao bookDao;
  7.     @Test
  8.     void contextLoads() {
  10.         //执行要测试的对象对应的方法
  11.         bookDao.save();
  12.         System.out.println("two...");
  13.     }
  14. }

看看这次简化成什么样了，一个注解就搞定了，而且还没有参数，再体会SpringBoot整合其他技术的优势在哪里，就两个字——简化。使用一个注解@SpringBootTest替换了前面两个注解。至于内部是怎么回事？和之前一样，只不过都走默认值。

    这个时候有人就问了，你加载的配置类或者配置文件是哪一个？就是我们前面启动程序使用的引导类。如果想手工指定引导类有两种方式，第一种方式使用属性的形式进行，在注解@SpringBootTest中添加classes属性指定配置类

  1. @SpringBootTest(classes = Springboot04JunitApplication.class)
  2. class Springboot04JunitApplicationTests {
  4.     //注入你要测试的对象
  5.     @Autowired
  6.     private BookDao bookDao;
  7.     @Test
  8.     void contextLoads() {
  10.         //执行要测试的对象对应的方法
  11.         bookDao.save();
  12.         System.out.println("two...");
  13.     }
  14. }

第二种方式回归原始配置方式，仍然使用@ContextConfiguration注解进行，效果是一样的

  1. @SpringBootTest
  2. @ContextConfiguration(classes = Springboot04JunitApplication.class)
  3. class Springboot04JunitApplicationTests {
  5.     //注入你要测试的对象
  6.     @Autowired
  7.     private BookDao bookDao;
  8.     @Test
  9.     void contextLoads() {
  11.         //执行要测试的对象对应的方法
  12.         bookDao.save();
  13.         System.out.println("two...");
  14.     }
  15. }

温馨提示:

    使用SpringBoot整合JUnit需要保障导入test对应的starter，由于初始化项目时此项是默认导入的，所以此处没有提及，其实和之前学习的内容一样，用什么技术导入对应的starter即可。

总结

  1. 导入测试对应的starter
  2. 测试类使用@SpringBootTest修饰
  3. 使用自动装配的形式添加要测试的对象
  4. 测试类如果存在于引导类所在包或子包中无需指定引导类
  5. 测试类如果不存在于引导类所在的包或子包中需要通过classes属性指定引导类

二、整合MyBatis

    整合完JUnit下面再来说一下整合MyBatis，这个技术是大部分公司都要使用的技术，务必掌握。如果对Spring整合MyBatis不熟悉的小伙伴好好复习一下，下面列举出原始整合的全部内容，以配置类的形式为例进行

  • 导入坐标，MyBatis坐标不能少，Spring整合MyBatis还有自己专用的坐标，此外Spring进行数据库操作的jdbc坐标是必须的，剩下还有mysql驱动坐标，本例中使用了Druid数据源，这个倒是可以不要

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>com.alibaba</groupId>
    4.         <artifactId>druid</artifactId>
    5.         <version>1.1.16</version>
    6.     </dependency>
    7.     <dependency>
    8.         <groupId>org.mybatis</groupId>
    9.         <artifactId>mybatis</artifactId>
    10.         <version>3.5.6</version>
    11.     </dependency>
    12.     <dependency>
    13.         <groupId>mysql</groupId>
    14.         <artifactId>mysql-connector-java</artifactId>
    15.         <version>5.1.47</version>
    16.     </dependency>
    17.     <!--1.导入mybatis与spring整合的jar包-->
    18.     <dependency>
    19.         <groupId>org.mybatis</groupId>
    20.         <artifactId>mybatis-spring</artifactId>
    21.         <version>1.3.0</version>
    22.     </dependency>
    23.     <!--导入spring操作数据库必选的包-->
    24.     <dependency>
    25.         <groupId>org.springframework</groupId>
    26.         <artifactId>spring-jdbc</artifactId>
    27.         <version>5.2.10.RELEASE</version>
    28.     </dependency>
    29. </dependencies>

  • Spring核心配置

    1. @Configuration
    2. @ComponentScan("com.itheima")
    3. @PropertySource("jdbc.properties")
    4. public class SpringConfig {
    6. }

  • MyBatis要交给Spring接管的bean

    1. //定义mybatis专用的配置类
    2. @Configuration
    3. public class MyBatisConfig {
    5. //    定义创建SqlSessionFactory对应的bean
    6.     @Bean
    7.     public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
    9.         //SqlSessionFactoryBean是由mybatis-spring包提供的，专用于整合用的对象
    10.         SqlSessionFactoryBean sfb = new SqlSessionFactoryBean();
    11.         //设置数据源替代原始配置中的environments的配置
    12.         sfb.setDataSource(dataSource);
    13.         //设置类型别名替代原始配置中的typeAliases的配置
    14.         sfb.setTypeAliasesPackage("com.itheima.domain");
    15.         return sfb;
    16.     }
    17. //    定义加载所有的映射配置
    18.     @Bean
    19.     public MapperScannerConfigurer mapperScannerConfigurer(){
    21.         MapperScannerConfigurer msc = new MapperScannerConfigurer();
    22.         msc.setBasePackage("com.itheima.dao");
    23.         return msc;
    24.     }
    26. }

  • 数据源对应的bean，此处使用Druid数据源

    1. @Configuration
    2. public class JdbcConfig {
    4.     @Value("${jdbc.driver}")
    5.     private String driver;
    6.     @Value("${jdbc.url}")
    7.     private String url;
    8.     @Value("${jdbc.username}")
    9.     private String userName;
    10.     @Value("${jdbc.password}")
    11.     private String password;
    13.     @Bean("dataSource")
    14.     public DataSource dataSource(){
    16.         DruidDataSource ds = new DruidDataSource();
    17.         ds.setDriverClassName(driver);
    18.         ds.setUrl(url);
    19.         ds.setUsername(userName);
    20.         ds.setPassword(password);
    21.         return ds;
    22.     }
    23. }

  • 数据库连接信息（properties格式）

    1. jdbc.driver=com.mysql.jdbc.Driver
    2. jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
    3. jdbc.username=root
    4. jdbc.password=root

上述格式基本上是最简格式了，要写的东西还真不少。下面看看SpringBoot整合MyBaits格式

步骤①：创建模块

28bc55ea47ed4c82a264d77696caa6c2.png

步骤②：勾选要使用的技术，MyBatis，由于要操作数据库，还要勾选对应数据库

1c41256c9c0a422387210af6264640be.png

或者手工导入对应技术的starter，和对应数据库的坐标

  1. <dependencies>
  2.     <!--1.导入对应的starter-->
  3.     <dependency>
  4.         <groupId>org.mybatis.spring.boot</groupId>
  5.         <artifactId>mybatis-spring-boot-starter</artifactId>
  6.         <version>2.2.0</version>
  7.     </dependency>
  9.     <dependency>
  10.         <groupId>mysql</groupId>
  11.         <artifactId>mysql-connector-java</artifactId>
  12.         <scope>runtime</scope>
  13.     </dependency>
  14. </dependencies>

步骤③：配置数据源相关信息，没有这个信息你连接哪个数据库都不知道

  1. #2.配置相关信息
  2. spring:
  3.   datasource:
  4.     driver-class-name: com.mysql.cj.jdbc.Driver
  5.     url: jdbc:mysql://localhost:3306/ssm_db
  6.     username: root
  7.     password: root

SpringBoot把配置中所有可能出现的通用配置都简化了。下面写一个MyBatis程序运行需要的Dao（或者Mapper）就可以运行了

实体类

  1. public class Book {
  3.     private Integer id;
  4.     private String type;
  5.     private String name;
  6.     private String description;
  7. }

映射接口（Dao）

  1. @Mapper
  2. public interface BookDao {
  4.     @Select("select * from tbl_book where id = #{id}")
  5.     public Book getById(Integer id);
  6. }

测试类

  1. @SpringBootTest
  2. class Springboot05MybatisApplicationTests {
  4.     @Autowired
  5.     private BookDao bookDao;
  6.     @Test
  7.     void contextLoads() {
  9.         System.out.println(bookDao.getById(1));
  10.     }
  11. }

注意：
    当前使用的SpringBoot版本是2.5.4，对应的坐标设置中Mysql驱动使用的是8x版本。使用SpringBoot2.4.3（不含）之前版本会出现一个小BUG，就是MySQL驱动升级到8以后要求强制配置时区，如果不设置会出问题。解决方案很简单，驱动url上面添加上对应设置就行了

  1. #2.配置相关信息
  2. spring:
  3.   datasource:
  4.     driver-class-name: com.mysql.cj.jdbc.Driver
  5.     url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
  6.     username: root
  7.     password: root

    这里设置的UTC是全球标准时间，你也可以理解为是英国时间，中国处在东八区，需要在这个基础上加上8小时，这样才能和中国地区的时间对应的，也可以修改配置为Asia/Shanghai，同样可以解决这个问题。

  1. #2.配置相关信息
  2. spring:
  3.   datasource:
  4.     driver-class-name: com.mysql.cj.jdbc.Driver
  5.     url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai
  6.     username: root
  7.     password: root

    如果不想每次都设置这个东西，也可以去修改mysql中的配置文件mysql.ini，在mysqld项中添加default-time-zone=+8:00也可以解决这个问题。其实方式方法很多，这里就说这么多吧。

    此外在运行程序时还会给出一个提示，说数据库驱动过时的警告，根据提示修改配置即可，弃用com.mysql.jdbc.Driver，换用com.mysql.cj.jdbc.Driver。前面的例子中已经更换了驱动了，在此说明一下。

  1. Loading class `com.mysql.jdbc.Driver'. This is deprecated. 
  2. The new driver class is `com.mysql.cj.jdbc.Driver'. 
  3. The driver is automatically registered via the SPI 
  4. and manual loading of the driver class is generally unnecessary.

总结

  1. 整合操作需要勾选MyBatis技术，也就是导入MyBatis对应的starter
  2. 数据库连接相关信息转换成配置
  3. 数据库SQL映射需要添加@Mapper被容器识别到

  4. MySQL 8.X驱动强制要求设置时区

    • 修改url，添加serverTimezone设定
    • 修改MySQL数据库配置
  5. 驱动类过时，提醒更换为com.mysql.cj.jdbc.Driver

三、整合MyBatis-Plus

    做完了两种技术的整合了，我们做这个整合究竟哪些是核心？总结下来就两句话

  • 导入对应技术的starter坐标
  • 根据对应技术的要求做配置

接下来在MyBatis的基础上再升级一下，整合MyBaitsPlus（简称MP），国人开发的技术，符合中国人开发习惯

步骤①：导入对应的starter

  1. <dependency>
  2.     <groupId>com.baomidou</groupId>
  3.     <artifactId>mybatis-plus-boot-starter</artifactId>
  4.     <version>3.4.3</version>
  5. </dependency>

关于这个坐标，此处要说明一点，之前我们看的starter都是spring-boot-starter-？？？，也就是说都是下面的格式

  1. Spring-boot-start-***

而MyBatis与MyBatisPlus这两个坐标的名字书写比较特殊，是第三方技术名称在前，boot和starter在后。此处简单提一下命名规范


























starter所属 命名规则 示例
官方提供 spring-boot-starter-技术名称 spring-boot-starter-web
spring-boot-starter-test
第三方提供 第三方技术名称-spring-boot-starter mybatis-spring-boot-starter
druid-spring-boot-starter
第三方提供 第三方技术名称-boot-starter（第三方技术名称过长，简化命名） mybatis-plus-boot-starter

温馨提示:

    有些小伙伴在创建项目时想通过勾选的形式找到这个名字，别翻了，没有。截止目前，SpringBoot官网还未收录此坐标，而我们Idea创建模块时读取的是SpringBoot官网的Spring Initializr，所以也没有。如果换用阿里云的url创建项目可以找到对应的坐标。

步骤②：配置数据源相关信息

  1. #2.配置相关信息
  2. spring:
  3.   datasource:
  4.     driver-class-name: com.mysql.cj.jdbc.Driver
  5.     url: jdbc:mysql://localhost:3306/ssm_db
  6.     username: root
  7.     password: root

剩下的就是写MyBaitsPlus的程序了

映射接口（Dao）

  1. @Mapper
  2. public interface BookDao extends BaseMapper<Book> {
  4. }

核心在于Dao接口继承了一个BaseMapper的接口，这个接口中帮助开发者预定了若干个常用的API接口，简化了通用API接口的开发工作。

a278f62395184b9d8b272fa9a081f8f2.png

下面就可以写一个测试类进行测试了，此处省略。

温馨提示:

    目前数据库的表名定义规则是tbl_模块名称，为了能和实体类相对应，需要做一个配置，相关知识各位小伙伴可以到MyBatisPlus课程中去学习，此处仅给出解决方案。配置application.yml文件，添加如下配置即可，设置所有表名的通用前缀名

  1. mybatis-plus:
  2.   global-config:
  3.     db-config:
  4.       table-prefix: tbl_        #设置所有表的通用前缀名称为tbl_

总结

  1. 手工添加MyBatis-Plus对应的starter
  2. 数据层接口使用BaseMapper简化开发
  3. 需要使用的第三方技术无法通过勾选确定时，需要手工添加坐标

四、整合Druid

    使用SpringBoot整合了3个技术了，发现套路基本相同，导入对应的starter，然后做配置。下面再整合一个技术，继续深入强化此思想。

    前面整合MyBatis和MyBatisPlus的时候，使用的数据源对象都是SpringBoot默认的数据源对象，下面我们手工控制一下，自己指定了一个数据源对象，Druid。

在没有指定数据源时，我们的配置如下：

  1. #2.配置相关信息
  2. spring:
  3.   datasource:
  4.     driver-class-name: com.mysql.cj.jdbc.Driver
  5.     url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai
  6.     username: root
  7.     password: root

此时虽然没有指定数据源，但是根据SpringBoot的德行，肯定帮我们选了一个它认为最好的数据源对象，这就是HiKari。通过启动日志可以查看到对应的身影。

  1. 2021-11-29 09:39:15.202  INFO 12260 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
  2. 2021-11-29 09:39:15.208  WARN 12260 --- [           main] com.zaxxer.hikari.util.DriverDataSource  : Registered driver with driverClassName=com.mysql.jdbc.Driver was not found, trying direct instantiation.
  3. 2021-11-29 09:39:15.551  INFO 12260 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.

上述信息中每一行都有HiKari的身影，如果需要更换数据源，其实只需要两步即可。

  1. 导入对应的技术坐标

  2. 配置使用指定的数据源类型

    下面就切换一下数据源对象

步骤①：导入对应的坐标（注意，是坐标，此处不是starter）

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>com.alibaba</groupId>
  4.         <artifactId>druid</artifactId>
  5.         <version>1.1.16</version>
  6.     </dependency>
  7. </dependencies>

步骤②：修改配置，在数据源配置中有一个type属性，专用于指定数据源类型

  1. spring:
  2.   datasource:
  3.     driver-class-name: com.mysql.cj.jdbc.Driver
  4.     url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
  5.     username: root
  6.     password: root
  7.     type: com.alibaba.druid.pool.DruidDataSource

    这里其实要提出一个问题的，目前的数据源配置格式是一个通用格式，不管你换什么数据源都可以用这种形式进行配置。但是新的问题又来了，如果对数据源进行个性化的配置，例如配置数据源对应的连接数量，这个时候就有新的问题了。每个数据源技术对应的配置名称都一样吗？肯定不是啊，各个厂商不可能提前商量好都写一样的名字啊，怎么办？就要使用专用的配置格式了。这个时候上面这种通用格式就不能使用了，怎么办？按照SpringBoot整合其他技术的通用规则来套，导入对应的starter，进行相应的配置即可。

步骤①：导入对应的starter

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>com.alibaba</groupId>
  4.         <artifactId>druid-spring-boot-starter</artifactId>
  5.         <version>1.2.6</version>
  6.     </dependency>
  7. </dependencies>

步骤②：修改配置

  1. spring:
  2.   datasource:
  3.     druid:
  4.       driver-class-name: com.mysql.cj.jdbc.Driver
  5.       url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
  6.       username: root
  7.       password: root

    注意观察，配置项中，在datasource下面并不是直接配置url这些属性的，而是先配置了一个druid节点，然后再配置的url这些东西。言外之意，url这个属性是druid下面的属性，那你能想到什么？除了这4个常规配置外，还有druid专用的其他配置。通过提示功能可以打开druid相关的配置查阅

d8b688079b6c4574824cbb2130b27e68.png

与druid相关的配置超过200条以上，如果想做druid相关的配置，使用这种格式就可以了，这里就不展开描述了，太多了。

这是我们做的第4个技术的整合方案，还是那两句话：导入对应starter，使用对应配置。

总结

  1. 整合Druid需要导入Druid对应的starter
  2. 根据Druid提供的配置方式进行配置

  3. 整合第三方技术通用方式

    • 导入对应的starter
    • 根据提供的配置格式，配置非默认值对应的配置项

本次学习就到这里，感谢观看，希望本篇文章对你有所帮助！

发表评论

表情：
评论列表 （有 0 条评论，118人围观）

还没有评论，来说两句吧...

相关阅读