springboot+AOP配置多数据源

最新推荐文章于 2024-04-03 09:51:38 发布
最新推荐文章于 2024-04-03 09:51:38 发布
阅读量153 收藏
点赞数
文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wc0311/article/details/132299322
版权

项目结构图

在这里插入图片描述

application.yml

server:
  port: 8081
  servlet:
    context-path: /data

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    mysql-datasource1: ## 声明第一个数据源所需的数据
      url: jdbc:mysql://localhost:3306/t1?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&zeroDateTimeBehavior=CONVERT_TO_NULL&autoReconnect=true&failOverReadOnly=false&maxReconnects=10
      username: root
      password: jsdayth@2022
      driver-class-name: com.mysql.cj.jdbc.Driver

    mysql-datasource2: ## 声明第二个数据源所需的数据
      url: jdbc:mysql://localhost:3306/t2?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&zeroDateTimeBehavior=CONVERT_TO_NULL&autoReconnect=true&failOverReadOnly=false&maxReconnects=10
      username: root
      password: jsdayth@2022
      driver-class-name: com.mysql.cj.jdbc.Driver

    druid: ## druid数据库连接池的基本初始化属性
      initial-size: 5
      min-idle: 1
      max-active: 20
mybatis:
  mapper-locations: classpath*:com/**/xml/**/*.xml

数据源注入

package com.example.data_sourse.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    @Bean(name = "mysqlDataSource1")
    @ConfigurationProperties(prefix = "spring.datasource.mysql-datasource1")
    public DataSource dataSource1(){
        DruidDataSource build = DruidDataSourceBuilder.create().build();
        return build;
    }

    @Bean(name = "mysqlDataSource2")
    @ConfigurationProperties(prefix = "spring.datasource.mysql-datasource2")
    public DataSource dataSource2(){
        DruidDataSource build = DruidDataSourceBuilder.create().build();
        return build;
    }
}

导入依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>data_sourse</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>data_sourse</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>8</java.version>
        <mysql.jdbc.version>8.0.11</mysql.jdbc.version>
    </properties>
    <dependencies>
        
        <!--web依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>


        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.9</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.jdbc.version}</version>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>com.fasterxml.jackson.core</groupId>
                    <artifactId>jackson-annotations</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.8</version>
        </dependency>

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

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.16</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <!--修改maven-compiler-plugin版本-->
            <!--修改maven-compiler-plugin版本-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
            </plugin>

        </plugins>

        <resources>
            <!--idea默认不编译 src\main\java下的xml文件-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>

            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*</include>
                </includes>
            </resource>

            <resource>
                <directory>lib</directory>
                <targetPath>/BOOT-INF/lib/</targetPath>
                <includes>
                    <include>**/*.jar</include>
                </includes>
            </resource>
        </resources>

    </build>

</project>

开启AOP支持

package com.example.data_sourse;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
@EnableAspectJAutoProxy //开启Spring Boot对AOP的支持
//@ComponentScan({"com.example.data_sourse"})
@ComponentScan(basePackages = {
        "com.example.data_sourse.**.controller",
        "com.example.data_sourse.**.model",
        "com.example.data_sourse.**.service",
        "com.example.data_sourse.*",
})
@MapperScan({"com.example.data_sourse.mapper"})
//@MapperScan({"com.example.*.mapper","com.example.*.*.mapper"})
public class DataSourseApplication {

    public static void main(String[] args) {
        SpringApplication.run(DataSourseApplication.class, args);
    }

}

定义枚举来表示数据源的标识

package com.example.data_sourse.transfer.enums;

public enum DataSourceType {

    MYSQL_DATASOURCE1,

    MYSQL_DATASOURCE2,
}

继承AbstractRoutingDataSource类

package com.example.data_sourse.config;

import cn.hutool.json.JSONUtil;
import com.example.data_sourse.transfer.enums.DataSourceType;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Slf4j
@Primary
@Component
public class DataSourceManagement extends AbstractRoutingDataSource {

    public static ThreadLocal<String> flag = new ThreadLocal<>();

    @Resource
    private DataSource mysqlDataSource1;

    @Resource
    private DataSource mysqlDataSource2;

    public DataSourceManagement(){
        flag.set(DataSourceType.MYSQL_DATASOURCE1.name());
    }

    @Override
    protected Object determineCurrentLookupKey() {
        log.info("determineCurrentLookupKey====>flag:{}",flag);
        String f_lag = flag.get();
        log.info("determineCurrentLookupKey====>f_lag:{}",f_lag);
        return f_lag;
    }

    @Override
    public void afterPropertiesSet() {
        log.info("afterPropertiesSet====>:{}",JSONUtil.toJsonStr(mysqlDataSource1));
        log.info("afterPropertiesSet====>:{}",JSONUtil.toJsonStr(mysqlDataSource2));
        Map<Object,Object> targetDataSource = new ConcurrentHashMap<>();
        targetDataSource.put(DataSourceType.MYSQL_DATASOURCE1.name(),mysqlDataSource1);
        targetDataSource.put(DataSourceType.MYSQL_DATASOURCE2.name(),mysqlDataSource2);
        // 将第一个数据源设置为默认数据源
        super.setDefaultTargetDataSource(mysqlDataSource1);
        // 将map对象赋值给AbstrictRoutingDataSource内部的Map对象中。
        super.setTargetDataSources(targetDataSource);
        super.afterPropertiesSet();
    }
}

自定义注解

package com.example.data_sourse.anno;

import com.example.data_sourse.transfer.enums.DataSourceType;

import java.lang.annotation.*;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface TargetDataSource {

    DataSourceType value() default DataSourceType.MYSQL_DATASOURCE1;
}

定义注解的实现类

package com.example.data_sourse.aop;

import cn.hutool.json.JSONUtil;
import com.example.data_sourse.anno.TargetDataSource;
import com.example.data_sourse.config.DataSourceManagement;
import com.example.data_sourse.transfer.enums.DataSourceType;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Component
@Aspect
@Slf4j
public class TargetDataSourceAspect {

    @Before("@within(com.example.data_sourse.anno.TargetDataSource) || @annotation(com.example.data_sourse.anno.TargetDataSource)")
    public void beforeNoticeUpdateDataSource(JoinPoint joinPoint){

        TargetDataSource annotation = null;

        Class<?> target = joinPoint.getTarget().getClass();

        // 判断类上是否标注着注解
        if (target.isAnnotationPresent(TargetDataSource.class)){

            annotation = target.getAnnotation(TargetDataSource.class);

            log.info("类上标注了注解:{}", annotation);

            log.info("类上标注了注解");

        }else {

            Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();

            // 判断方法上是否存在注解，如果方法上都没有则报错
            if (method.isAnnotationPresent(TargetDataSource.class)){

                annotation = method.getAnnotation(TargetDataSource.class);

                log.info("方法上标注了注解:{}", annotation);

                log.info("方法上标注了注解");

            }else {

                throw new RuntimeException("@TargetDataSource注解只能用于类或者方法上, 错误出现在:【" +
                        target.toString() +" " + method.toString() + "】;");

            }
        }

        log.info("获取注解数据:{}", JSONUtil.toJsonStr(annotation.value().name()));

        // 切换数据源
        DataSourceManagement.flag.set(annotation.value().name());

    }
}

在有的博客中也会使用@Around环绕通知的方式，但是环绕通知需要执行joinPoint.process()方法来调用目标对象的方法，最后返回执行的值，不然得不到所需要的数据。
我这里使用了@Before前置通知，效果是一样的，因为@Around就会包含@Before。

 @Around("@within(TargetDataSource) || @annotation(TargetDataSource)")
    public Object beforeNoticeUpdateDataSource(ProceedingJoinPoint joinPoint){
       	// 省略逻辑代码
       	Object result = null;
       	try {
            result = joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return result;
    }

使用

package com.example.data_sourse.controller;

import com.example.data_sourse.anno.TargetDataSource;
import com.example.data_sourse.service.UserService;
import com.example.data_sourse.transfer.enums.DataSourceType;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;

@Slf4j
@RestController
// 将注解标注在类上，表示本类中所有的方法都是使用数据源1
//@TargetDataSource(value = DataSourceType.MYSQL_DATASOURCE1)
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 数据源1
     */
    @GetMapping(value = "/user_list_a")
    @TargetDataSource(value = DataSourceType.MYSQL_DATASOURCE1)
    public List<Map<String,Object>> showUserLista(){
        log.info("user_list_a数据源：{}",DataSourceType.MYSQL_DATASOURCE1.name());
        List<Map<String,Object>> list = userService.list();
        return list;
    }

    /**
     * 数据源2
     */
    @GetMapping(value = "/user_list_b")
    @TargetDataSource(value = DataSourceType.MYSQL_DATASOURCE2)
    public List<Map<String,Object>> showUserListb(){
        log.info("user_list_b数据源：{}",DataSourceType.MYSQL_DATASOURCE2.name());
        List<Map<String,Object>> list = userService.list();
        return list;
    }

    /**
     * 默认数据源
     */
    @GetMapping(value = "/user_list_c")
    public List<Map<String,Object>> showUserListc(){
        List<Map<String,Object>> list = userService.list();
        return list;
    }

}
王的加特林
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【SpringBoot笔记46】SpringBoot多数据源配置（方式三：基于AOP动态切换需要使用哪个数据源）
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
06-08 186
在SpringBoot应用开发中，一般情况下，都是只会配置一个数据源信息，之后整个工程都是对当前数据源进行增删改查的操作。但是，在实际开发里面，也有可能会遇到多数据源的情况，例如：当前工程中除了需要访问自己应用的数据库，还需要直接连接第三方系统的数据库进行业务处理，这种情况下，就需要进行多数据源的配置。SpringBoot考虑到了这一点，所以它是支持多数据源的配置的，下面介绍一下如何配置多数据源，并且在代码中动态切换使用的数据源。
SpringBoot+MyBatis使用AOP+注解实现多数据源
牧小七的博客
10-17 265
一个应用程序需要链接多个数据库，比如读写分离架构下的读库和写库。创建数据库：ds1 插入数据： 创建数据库：ds2 插入数据：
springboot配置多数据源AOP
Addison
08-21 171
整理springboot配置多数据源，由AOP实现 先看pom.xml，springboot版本2.1.4 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-s...
【SpringBoot应用篇】【AOP+注解】SpringBoot集成Mybatis实现多数据源配置+跨数据源事务
输入技术、输出想法
11-26 3894
开发中经常有这样的需要:。微服务环境下可以实现一个服务读取一个数据库，另一个服务写库。但是在实际应用中有时也需要在一个服务中读写不同的数据库。可以在一个SpringBoot单体项目中配置多个数据源解决读写库分离。
SpingBoot+AOP实现自定义多数据源
weixin_38545056的博客
03-05 496
如何使用SpringBoot+AOP实现自定义多数据源？
搞定SpringBoot多数据源(2)：动态数据源
masson32的专栏
01-17 810
使用动态数据源对多个数据库进行操作，灵活，简洁。
springboot+jpa配置多数据源.zip
12-06
首先，`springboot+jpa配置多数据源.zip`这个压缩包可能包含了一个示例项目，用于演示如何在Spring Boot中集成JPA并配置多个数据源。JPA是Java平台上的ORM（Object-Relational Mapping）标准，它简化了与关系型...
springboot+mybatis配置多数据源，通过注解自动切换
04-11
Spring Boot结合MyBatis框架提供了方便的方式来配置和管理多个数据库连接，实现数据源的动态切换。本文将详细探讨如何在Spring Boot项目中配置多数据源，并利用注解自动切换，以及实现简单的读写分离和负载均衡。 ...
springboot-AOP实现多数据源动态切换（Druid连接池）
12-25
通过SpringAop实现多数据源的动态切换 并采用Druid连接池，可扩展继续增加数据库配置。
Springboot+Mybatis+Druid多数据源配置
01-14
本教程将围绕"Springboot+Mybatis+Druid多数据源配置"这一主题，详细介绍如何实现这一功能。 首先，Spring Boot简化了Spring应用的初始化和配置。在多数据源场景下，我们可以通过Spring Boot的@...
spring boot AOP注解方式实现多数据源
06-19
spring boot AOP注解方式实现多数据源整合(从零开始搭建框架到配置多数据源实践小例子)
详解springboot+mybatis多数据源最简解决方案
08-30
在上面的代码中，我们使用了@Configuration注解来配置数据源，并使用@Primary注解来指定主库。我们还使用了@Bean注解来定义数据源、SqlSessionFactory和TransactionManager。 使用SpringBoot框架来实现多数据源解决...
爆破专栏丨SpringBoot2.x系列教程之SpringBoot中以AOP方式配置多个数据源
关注我！带你一路 "狂飙" 到底！
12-21 565
前言 在上一章节中，壹哥通过分包的方式，带大家实现了在一个项目中同时配置多个数据源的功能。之前我给大家讲过，配置多数据源的方式有2种，所以接下来我会通过AOP切面配置的方式，带领大家实现第2种多数据源配置的方式，该方式是在前面案例的基础上进行编写的。 一. 实现过程 1. 创建Web项目 我们按照之前的经验，创建一个SpringBoot的Web程序，具体过程略，各位可以参考下图创建项目。 2. 添加依赖包 在pom.xml文件中添加几个核心依赖包。 <dependency>
SpringBoot2.1.5+Druid实现多数据源AOP动态切换
qq_39835384的博客
05-30 5015
应用场景: 项目需要同时连接多个不同的数据库A, B，并且它们都需要读写操作 项目技术选项： SpringBoot_ssm 数据库：MySQL 、SQL server 看网上有很多类似笔记，但有些繁琐，这里简单说明，记个笔记。 以此记录： 依赖 这里仅仅展示部份关键依赖 <dependency> <groupId>org.mybati...
SpringBoot+MyBatisPlus+AOP实现多数据源切换(经典)
gb4215287的博客
10-15 444
SpringBoot+MyBatisPlus+AOP实现多数据源切换
Spring boot多数据源实现动态切换
热门推荐
老男孩的架构路
08-02 1万+
日常的业务开发项目中只会配置一套数据源，如果需要获取其他系统的数据往往是通过调用接口，或者是通过第三方工具比如kettle将数据同步到自己的数据库中进行访问。但是也会有需要在项目中引用多数据源的场景。自研数据迁移系统，至少需要新、老两套数据源，从老库读取数据写入新库自研读写分离中间件，系统流量增加，单库响应效率降低，引入读写分离方案，写入数据是一个数据源，读取数据是另一个数据源目标数据源，即项目启动的时候设置的需要通过AbstractRoutingDataSource管理的数据源。方法。...
FastReport设计报表简单使用
ChengR666的博客
09-29 1177
网上FastReport教程较少，之前也没有接触，简单记录下设计过程。 新建空报表，点击设置报表栏。 新建数据区，数据首，数据尾，每个数据区根据匹配的数据源行数显示，数据首根数据尾一般进行表头跟合计显示。 右击数据区，编辑-为每个数据区选中数据源。 程序开发一般利用代码绑定数据源，进行设计、打印。 ...
Springboot 多数据源动态切换 以AOP切点方式实现
最新发布
2401_83739411的博客
04-03 458
在这个部分总结了2019年到目前为止Java常见面试问题，取其面试核心编写成这份文档笔记，从中分析面试官的心理，摸清面试官的“套路”，可以说搞定90%以上的Java中高级面试没一点难度。本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）
SpringBoot+Dynamic多数据源动态切换
06-13
首先，Spring Boot可以通过配置多个数据源来实现多数据源的切换。其次，可以使用AOP技术，在方法执行前动态切换数据源。以下是一些关键的代码片段： 1. 在application.properties文件中配置多个数据源 ``` spring....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值