SpringBoot2.x系列教程27--SpringBoot中以AOP方式配置多个数据源
前言
在上一章节中，壹哥 通过分包的方式，带大家实现了在一个项目中同时配置多个数据源的功能。之前我给大家讲过，配置多数据源的方式有2种，所以接下来我会通过AOP切面配置的方式，带领大家实现第2种多数据源配置的方式，该方式是在前面案例的基础上进行编写的。
一. 实现过程
1. 创建Web项目
我们按照之前的经验，创建一个SpringBoot的Web程序，具体过程略，各位可以参考下图创建项目。
2. 添加依赖包
在pom.xml文件中添加几个核心依赖包。
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.10</version> </dependency> 复制代码
3. 创建application.yml配置文件
在该配置文件中，要进行两个数据库的配置，本案例中我们使用默认的HikariDataSource数据源。
spring: main: allow-bean-definition-overriding: true datasource: #第1个数据库信息 ds1: url: jdbc:mysql://localhost:3306/db1?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC username: root password: syc driverClassName: com.mysql.jdbc.Driver #第2个数据库信息 ds2: url: jdbc:mysql://localhost:3306/db4?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC username: root password: syc driverClassName: com.mysql.jdbc.Driver type: com.zaxxer.hikari.HikariDataSource #type: com.alibaba.druid.pool.DruidDataSource jpa: database: mysql show-sql: true hibernate: ddl-auto: update naming: physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl database-platform: org.hibernate.dialect.MySQL5Dialect 复制代码
4. 创建数据库配置类
4.1 第一个数据库配置类
这里我们先编写第一个数据库配置类，读取ds1中的数据库信息。
package com.yyg.boot.config.properties; import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description db1数据源配置类 */ @ConfigurationProperties(prefix = "spring.datasource.ds1") @Component("ds1Properties") @Data public class Ds1Properties { private String url; private String username; private String password; private String driverClassName; } 复制代码4.2 第2个数据库配置类
然后再编写第2个数据库配置类，读取ds2中的数据库信息。
package com.yyg.boot.config.properties; import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description db4数据源配置类 */ @ConfigurationProperties(prefix = "spring.datasource.ds2") @Component("ds2Properties") @Data public class Ds2Properties { private String url; private String username; private String password; private String driverClassName; } 复制代码5. 注册数据源
接下来我们在一个类中同时注册2个数据源就可以了，注意我们就是在这个配置类中分别关联加载2个数据源。
package com.yyg.boot.config; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import javax.sql.DataSource; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description 数据源的配置类 */ @Configuration public class DataSourceRegisterConfig { /** * 主数据源配置 ds1数据源 */ @Primary @Bean(name = "ds1Properties") @ConfigurationProperties(prefix = "spring.datasource.ds1") public DataSourceProperties ds1DataSourceProperties() { return new DataSourceProperties(); } /** * 主数据源 ds1数据源 */ @Primary @Bean(name = "ds1DataSource") public DataSource ds1DataSource(@Qualifier("ds1Properties") DataSourceProperties dataSourceProperties) { //HikariDataSource","org.apache.tomcat.jdbc.pool.DataSource", "org.apache.commons.dbcp2.BasicDataSource return dataSourceProperties.initializeDataSourceBuilder().build(); } /** * 第二个ds2数据源配置 */ @Bean(name = "ds2Properties") @ConfigurationProperties(prefix = "spring.datasource.ds2") public DataSourceProperties ds2DataSourceProperties() { return new DataSourceProperties(); } /** * 第二个ds2数据源 */ @Bean("ds2DataSource") public DataSource ds2DataSource(@Qualifier("ds2Properties") DataSourceProperties dataSourceProperties) { return dataSourceProperties.initializeDataSourceBuilder().build(); } } 复制代码6. 配置数据源、连接工厂、事务管理器、扫描dao目录
配置完2个数据源之后，我们还要利用事务管理器分别关联2个数据源。这里要注意合理的使用@Primary注解！
6.1 配置第一个数据源管理器
在这个数据源管理器中关联第1个数据源。
package com.yyg.boot.config; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import org.springframework.data.jpa.repository.config.EnableJpaRepositories; import org.springframework.orm.jpa.JpaTransactionManager; import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.EnableTransactionManagement; import javax.sql.DataSource; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description 配置数据源、连接工厂、事务管理器、dao目录 */ @Configuration @EnableTransactionManagement @EnableJpaRepositories( entityManagerFactoryRef = "managerFactory1", // 配置连接工厂 transactionManagerRef = "transactionManager1", // 配置事物管理器 basePackages = {"com.yyg.boot.dao.db01"} // 设置dao所在位置 ) public class ManagerFactory01Config { /** * 配置数据源,连接第1个数据源 */ @Autowired @Qualifier("ds1DataSource") private DataSource ds1DataSource; @Primary @Bean(name = "managerFactory1") public LocalContainerEntityManagerFactoryBean buildEntityManagerFactory1(EntityManagerFactoryBuilder builder) { return builder // 设置数据源 .dataSource(ds1DataSource) //设置实体类所在位置.扫描所有带有 @Entity 注解的类 .packages("com.yyg.boot.entity") // Spring会将EntityManagerFactory注入到Repository之中.有了 EntityManagerFactory之后, // Repository就能用它来创建 EntityManager 了,然后 EntityManager 就可以针对数据库执行操作 .persistenceUnit("ds1PersistenceUnit") .build(); } /** * 配置事务管理器 */ @Bean(name = "transactionManager1") public PlatformTransactionManager transactionManagerDatabase1(EntityManagerFactoryBuilder builder) { return new JpaTransactionManager(buildEntityManagerFactory1(builder).getObject()); } } 复制代码6.2 配置第2个数据源管理器
在这个数据源管理器中关联第2个数据源。
package com.yyg.boot.config; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import org.springframework.data.jpa.repository.config.EnableJpaRepositories; import org.springframework.orm.jpa.JpaTransactionManager; import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.EnableTransactionManagement; import javax.sql.DataSource; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description 配置数据源、连接工厂、事务管理器、dao目录 */ @Configuration @EnableTransactionManagement @EnableJpaRepositories( entityManagerFactoryRef = "managerFactory2", // 配置连接工厂 transactionManagerRef = "transactionManager2", // 配置事物管理器 basePackages = {"com.yyg.boot.dao.db02"} // 设置dao所在位置 ) public class ManagerFactory02Config { /** * 配置数据源,连接第2个数据源 */ @Autowired @Qualifier("ds2DataSource") private DataSource ds2DataSource; @Bean(name = "managerFactory2") public LocalContainerEntityManagerFactoryBean buildEntityManagerFactory2(EntityManagerFactoryBuilder builder) { return builder // 设置数据源 .dataSource(ds2DataSource) //设置实体类所在位置.扫描所有带有 @Entity 注解的类 .packages("com.yyg.boot.entity") // Spring会将EntityManagerFactory注入到Repository之中.有了 EntityManagerFactory之后, // Repository就能用它来创建 EntityManager 了,然后 EntityManager 就可以针对数据库执行操作 .persistenceUnit("ds2PersistenceUnit") .build(); } /** * 配置事务管理器 */ @Bean(name = "transactionManager2") public PlatformTransactionManager transactionManagerDatabase1(EntityManagerFactoryBuilder builder) { return new JpaTransactionManager(buildEntityManagerFactory2(builder).getObject()); } } 复制代码7. 创建数据源类型
这里我利用ThreadLocal来确保线程的安全性，这样每个线程之间就不会相互影响。
package com.yyg.boot.datasource; import lombok.extern.slf4j.Slf4j; /** * @Author 一一哥Sun * @Date Created in 2020/4/7 * @Description 数据源类型 */ @Slf4j public class DataSourceType { public enum SourceType { /** * 用户数据源 */ DS_USER, /** * 商品数据源 */ DS_SHOP } /** * 使用ThreadLocal保证线程安全 */ private static final ThreadLocal<SourceType> TYPES = new ThreadLocal<>(); /** * 往当前线程里设置数据源类型 */ public static void setDataSourceType(SourceType dataSourceType) { if (dataSourceType == null) { throw new NullPointerException(); } log.warn("[设置当前数据源为]：" + dataSourceType); TYPES.set(dataSourceType); } /** * 获取数据源类型 */ public static SourceType getDataSourceType() { SourceType dataSourceType = TYPES.get() == null ? SourceType.DS_USER : TYPES.get(); log.warn("[当前数据源的类型为]：" + dataSourceType); return dataSourceType; } /** * 清空数据类型 */ public static void removeDataSourceType() { TYPES.remove(); } } 复制代码8. 定义动态数据源
定义一个动态数据源,继承AbstractRoutingDataSource 抽象类，并重写determineCurrentLookupKey()方法。
AbstractRoutingDataSource这个类是实现多数据源的关键，作用是动态切换数据源。
在该类中有一个targetDataSources集合，该集合是AbstractRoutingDataSource的一个map类型的属性，其中key表示每个数据源的名字，value为每个数据源。
然后根据determineCurrentLookupKey()这个方法获取当前数据源在map中的key值，然后determineTargetDataSource（）方法中动态获取当前数据源，如果当前数据源不存且默认数据源也不存在时就会抛出异常。
package com.yyg.boot.datasource; import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource; /** * @Author 一一哥Sun * @Date Created in 2020/4/7 * @Description 动态切换数据源 */ public class DynamicDataSource extends AbstractRoutingDataSource { @Override protected Object determineCurrentLookupKey() { return DataSourceType.getDataSourceType(); } } 复制代码9. 配置多个数据源
在这里进行多数据源配置。
package com.yyg.boot.datasource; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.jdbc.DataSourceBuilder; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import javax.sql.DataSource; import java.util.HashMap; import java.util.Map; /** * @Author 一一哥Sun * @Date Created in 2020/4/7 * @Description 多数据源配置 */ @Configuration public class DynamicDataSourceConfig { @Bean(name = "dynamicDataSource") public DynamicDataSource dynamicDataSource(@Qualifier("ds1DataSource") DataSource ds1DataSource, @Qualifier("ds2DataSource") DataSource ds2DataSource) { Map<Object, Object> targetDataSource = new HashMap<>(); targetDataSource.put(DataSourceType.SourceType.DS_SHOP, ds1DataSource); targetDataSource.put(DataSourceType.SourceType.DS_USER, ds2DataSource); DynamicDataSource dataSource = new DynamicDataSource(); dataSource.setTargetDataSources(targetDataSource); dataSource.setDefaultTargetDataSource(ds2DataSource); return dataSource; } } 复制代码10. 定义AOP切面
在这里编写AOP切面类，通@Before注解配置前置通知方法。
package com.yyg.boot.datasource; import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; /** * @Author 一一哥Sun * @Date Created in 2020/4/7 * @Description Description */ @Aspect @Component @Slf4j public class DataSourceAop { @Before("execution(* com.yyg.boot.service.impl.GoodsServiceImpl.*(..))") public void setDataSource01() { log.warn("db01商品数据源"); DataSourceType.setDataSourceType(DataSourceType.SourceType.DS_SHOP); } @Before("execution(* com.yyg.boot.service.impl.UserServiceImpl.*(..))") public void setDataSource02() { log.warn("db02用户数据源"); DataSourceType.setDataSourceType(DataSourceType.SourceType.DS_USER); } } 复制代码11. 创建Entity实体类
11.1 Goods商品类
封装一个商品信息的实体类。
package com.yyg.boot.entity; import lombok.Data; import javax.persistence.*; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description db1中的商品表 */ @Entity @Table(name = "goods") @Data public class Goods { @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id; private String name; } 复制代码11.2 User用户类
封装用户信息的实体类。
package com.yyg.boot.entity; import lombok.Data; import javax.persistence.*; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description db4中的用户表 */ @Entity @Table(name = "user") @Data public class User { @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id; private String username; private String birthday; private String sex; private String address; } 复制代码12. 创建Dao层代码
12.1 GoodsRepository类
编写操作Goods商品信息的数据库Dao层接口。
package com.yyg.boot.dao.db01; import com.yyg.boot.entity.Goods; import com.yyg.boot.entity.User; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaSpecificationExecutor; import org.springframework.stereotype.Repository; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description Description */ @Repository public interface GoodsRepository extends JpaRepository<Goods, Long>,JpaSpecificationExecutor<User> { } 复制代码12.2 UserRepository类
编写操作User用户信息的数据库Dao层接口。
package com.yyg.boot.dao.db02; import com.yyg.boot.entity.User; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.JpaSpecificationExecutor; import org.springframework.stereotype.Repository; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description Description */ @Repository public interface UserRepository extends JpaRepository<User, Long>,JpaSpecificationExecutor<User> { } 复制代码13. 创建Service代码
13.1 UserServiceImpl实现类
编写UserServiceImpl实现类，调用UserRepository进行数据库操作。
package com.yyg.boot.service.impl; import com.yyg.boot.dao.db02.UserRepository; import com.yyg.boot.entity.User; import com.yyg.boot.service.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.List; /** * @Author 一一哥Sun * @Date Created in 2020/4/7 * @Description Description */ @Service public class UserServiceImpl implements UserService { @Autowired private UserRepository userRepository; @Override public List<User> findAll() { return userRepository.findAll(); } } 复制代码13.2 GoodsServiceImpl实现类
编写GoodsServiceImpl实现类，调用GoodsRepository进行数据库操作。
package com.yyg.boot.service.impl; import com.yyg.boot.dao.db01.GoodsRepository; import com.yyg.boot.dao.db02.UserRepository; import com.yyg.boot.entity.Goods; import com.yyg.boot.entity.User; import com.yyg.boot.service.GoodsService; import com.yyg.boot.service.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.List; /** * @Author 一一哥Sun * @Date Created in 2020/4/7 * @Description Description */ @Service public class GoodsServiceImpl implements GoodsService { @Autowired private GoodsRepository goodsRepository; @Override public List<Goods> findAll() { return goodsRepository.findAll(); } } 复制代码14. 创建Controller接口
然后我们再创建一个Controller类，在这里定义几个接口，方便后面进行测试。
package com.yyg.boot.web; import com.yyg.boot.entity.Goods; import com.yyg.boot.entity.User; import com.yyg.boot.service.GoodsService; import com.yyg.boot.service.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; import java.util.List; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description Description */ @RestController public class GoodsController { @Autowired private UserService userService; @Autowired private GoodsService goodsService; @GetMapping(value = "/users") public List<User> users() { return userService.findAll(); } @GetMapping(value = "/goods") public List<Goods> goods() { return goodsService.findAll(); } } 复制代码15. 创建入口类
最后编写一个项目入口类，启动项目。
Java
复制代码
package com.yyg.boot; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; /** * @Author 一一哥Sun * @Date Created in 2020/4/3 * @Description Description */ @SpringBootApplication public class DataSourceApplication { public static void main(String[] args){ SpringApplication.run(DataSourceApplication.class,args); } } 复制代码16. 项目结构
最后我们可以看看项目的代码结构，各位可以参考下图创建。
17. 运行测试
17.1 测试商品数据库
我们把项目启动起来，先首先测试一下goods接口，这里查询的是db1数据库里的数据。
这里对应的是db1数据库里的数据。
17.2 测试用户数据库
然后我们再测试一下users接口，这里查询的是db4数据库里的数据。
这里对应的是db4数据库里的数据。
结语
至此，壹哥 就带各位在Spring Boot中，利用AOP切面技术实现了在一个项目中同时配置2个数据源的功能，其实你也可以以此类推，配置3个，4个乃至更多的数据源！
利用AOP切面技术配置多数据源稍微复杂一点，但是相对于分包法会更灵活。
今日小作业：
利用AOP切面技术，把学生信息管理系统中的多数据源功能进行改造。
作者：一一哥Sun
链接：https://juejin.cn/post/7168607952977264647