纯注解形式的数据源动态切换实现(基于SpringBoot)

最新推荐文章于 2024-07-19 15:19:22 发布
最新推荐文章于 2024-07-19 15:19:22 发布
阅读量786 收藏 5
点赞数 1
分类专栏： java 文章标签： 数据源切换 java 注解 aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20021569/article/details/103343983
版权

在我的博客阅读本文
有一段时间没有更新博客了，其实这段时间也有在写一些框架的使用，比如quartz的基本使用等等，后来都没有发布出来，主要还是感觉过于简单，对于博客的定位我希望能讨论一些更深层次的设计方面的东西。

最近公司有个需求，客户试用我们的产品到期了，签了正式的合同，准备迁移到生产环境，但是又想要保留测试的时候数据，因此我们开发组准备设计一个迁移程序，要考虑后期拓展与重复使用。这其中有个重要的点就是如何在一个项目中同时操作两个数据源。

今天这篇文章主要是围绕动态数据源切换的设计实现进行展开，其他关于数据迁移方面的问题也可以联系我私人进行讨论。

1. 前言

首先，对一个概念进行定义，本文所述数据源动态切换是指在一个项目工程中，代码层面能够同时操作两个数据源，共用一套数据源操作代码，并非客户端在调用的时候进行动态切换。如果您无意间搜索到这篇文章，请知悉，避免辜负您的时间。

要实现数据源的动态切换，笔者主要考虑以下几点：

  • 每种数据源要能够实现单例
  • 能够正常执行事务提交回滚
  • 数据源切换的线程安全问题
  • 符合SpringBoot整体风格，约定优于配置（convention over configuration）

2. 代码

您可以选择直接clone代码，如果对您有帮助，请一定不要吝惜你的star。

项目github地址

如果对其中有困惑，可以继续往下阅读。

3. 具体实现

我们模拟两个数据源切换，分别为masaiqi_dev和masaiqi_prod，对应测试环境和生产环境

3.1. 准备工作

3.1.1. 引入pom
<?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.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.masaiqi</groupId>
    <artifactId>datasource-exchage</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>datasource-exchage</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

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

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

        <!--日志-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>

        <!--数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.21</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>

    <build>

        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                    <include>**/*.tld</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>

        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
3.1.2. 准备两个数据源

sql如下：

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) DEFAULT NULL,
  `introduce` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
);
3.1.3. application.yml配置
datasource:
  dev:
    driverClass: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/masaiqi_dev?allowMultiQueries=true&useUnicode=true&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456
  prod:
    driverClass: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3307/masaiqi_prod?allowMultiQueries=true&useUnicode=true&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456

3.2. 定义数据源切换类型约束常量

/**
 * 数据源类型定义
 * <p>
 * 记录数据源的beanName
 *
 * @author sq.ma
 * @date 2019/11/26 下午6:09
 */
public class DataSourceType {

    public static final String DB_DEV = "DEVDataSource";

    public static final String DB_PROD = "PRODDataSource";

}

3.3. 定义数据源切换变量

/**
 * 数据源上下文环境，记录当前使用数据源
 * <p>
 * 数据源类型定义见{@link DataSourceType}
 *
 * @author sq.ma
 * @date 2019/11/26 下午6:06
 */
public class DataSourceContextHolder {

    /**
     * 数据源beanName存放容器
     */
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();

    /**
     * 设置数据源类型
     *
     * @param dbType {@link DataSourceType}
     * @return void
     * @author sq.ma
     * @date 2019/11/26 下午6:08
     */
    public static void setDBType(String dbType) {
        contextHolder.set(dbType);
    }

    /**
     * 获取数据源类型
     *
     * @param
     * @return java.lang.String {@link DataSourceType}
     * @author sq.ma
     * @date 2019/11/26 下午6:07
     */
    public static String getDBType() {
        return contextHolder.get();
    }


    /**
     * 清除数据源类型
     *
     * @param
     * @return void
     * @author sq.ma
     * @date 2019/11/26 下午6:08
     */
    public static void clearDBType() {
        contextHolder.remove();
    }
}

可能和上面的约束常量会混淆，这里主要是定义一个常量，为这个常量增加赋值，取值，置空等方法，而赋值的值只可以在上面的约束常量中进行选择。

我们通过这个变量的值的不同，对数据源进行相应的处理切换(数据源切换见下文)。

注意我们这里用的ThreadLocal这个类对String类型的常量进行了封装，ThreadLocal保证了每个线程都拥有一份独特的变量的拷贝，因而在多线程环境下，每个线程执行数据源操作时候都是线程安全的，也就实现了我们前言中的考虑：数据源切换的线程安全问题

3.4. 定义动态数据源切换路由

/**
 * 动态数据源切换
 *
 * @author sq.ma
 * @date 2019/11/26 下午6:04
 */
public class MultipleDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDBType();
    }

}

Spring为我们提供了AbstractRoutingDataSource类，用来做数据源切换。

AbstractRoutingDataSource类内部维护了一个Map变量，你可以简单理解为：

  • key：标志
  • value：数据源

不难看出，我们重写的determineCurrentLookupKey()方法主要作用就是获取这个Map变量的key，Spring会帮我们根据这个key去寻找对应的value，实现路由到不同的数据源。

3.5. 创建数据库配置类

/**
 * @author sq.ma
 * @date 2019/11/26 上午9:58
 */
@Configuration
public class DatabaseConfig {

    /**
     * dev环境配置
     */
    @Value("${datasource.dev.driverClass}")
    private String devDriverClass;

    @Value("${datasource.dev.url}")
    private String devUrl;

    @Value("${datasource.dev.username}")
    private String devUsername;

    @Value("${datasource.dev.password}")
    private String devPassword;

    /**
     * 生产环境配置
     */
    @Value("${datasource.prod.driverClass}")
    private String prodDriverClass;

    @Value("${datasource.prod.url}")
    private String prodUrl;

    @Value("${datasource.prod.username}")
    private String prodUsername;

    @Value("${datasource.prod.password}")
    private String prodPassword;

    @Bean(name = "devDataSource")
    public DruidDataSource getDevDataSource() throws SQLException {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(devUrl);
        datasource.setUsername(devUsername);
        datasource.setPassword(devPassword);
        datasource.setDriverClassName(devDriverClass);
        datasource.setFilters("stat,wall");
        return datasource;
    }

    @Bean(name = "prodDataSource")
    public DruidDataSource getProdDataSource() throws SQLException {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(prodUrl);
        datasource.setUsername(prodUsername);
        datasource.setPassword(prodPassword);
        datasource.setDriverClassName(prodDriverClass);
        datasource.setFilters("stat,wall");
        return datasource;
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory(MultipleDataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:com/masaiqi/exchage/mapper/**.xml"));
        return sessionFactory.getObject();
    }

    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(MultipleDataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * 配置动态数据源
     * <p>
     * 数据源类型见 {@link DataSourceType}
     *
     * @param devDataSource dev数据源
     * @param prodDataSource prod数据源
     * @return {@link com.masaiqi.exchage.config.MultipleDataSource}
     * @author sq.ma
     * @date 2019/11/26 下午10:07
     */
    @Bean
    public MultipleDataSource dynamicDataSource(@Qualifier("devDataSource") DruidDataSource devDataSource, @Qualifier("prodDataSource")DruidDataSource prodDataSource) {
        //配置切换的动态数据源
        Map<Object, Object> datasourceMap = new HashMap<>(2);
        datasourceMap.put(DataSourceType.DB_DEV, devDataSource);
        datasourceMap.put(DataSourceType.DB_PROD, prodDataSource);
        MultipleDataSource multipleDataSource = new MultipleDataSource();
        multipleDataSource.setTargetDataSources(datasourceMap);
        //配置默认数据源
        multipleDataSource.setDefaultTargetDataSource(devDataSource);
        return multipleDataSource;
    }

}

重点关注一下dynamicDataSource()这个方法，这个方法主要是将对应的标志-数据源的数据插入到AbstractRoutingDataSource的Map变量中，这样我们就可以根据这个key去寻找这个Map变量中对应的值，决定使用的数据源。

我们重写的determineCurrentLookupKey()方法中，有写了获取key值的方式：

return DataSourceContextHolder.getDBType();

也就是说DataSourceContextHolder中的getDBType()决定了当前使用的数据源。

3.6. 创建数据源切换注解

/**
 * 切换数据源注解
 *
 * @author sq.ma
 * @date 2019/11/27 上午10:02
 */

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DataSourceChoose {

    /**
     * 数据源名称
     * <p>
     * @see DataSourceType
     */
    String value();
}

这个注解用来识别当前方法需要使用的数据源

3.7. 创建Dao层

这一块直接贴代码了，比较简单。

UserDAO.java：

@Repository
public interface UserDAO {
    int deleteByPrimaryKey(Integer id);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Integer id);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);
}

UserDAO.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.masaiqi.exchage.dao.UserDAO">
  <resultMap id="BaseResultMap" type="com.masaiqi.exchage.entity.User">
    <id column="id" jdbcType="INTEGER" property="id" />
    <result column="name" jdbcType="VARCHAR" property="name" />
    <result column="introduce" jdbcType="VARCHAR" property="introduce" />
  </resultMap>
  <sql id="Base_Column_List">
    id, `name`, introduce
  </sql>
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from user
    where id = #{id,jdbcType=INTEGER}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
    delete from user
    where id = #{id,jdbcType=INTEGER}
  </delete>
  <insert id="insert" keyColumn="id" keyProperty="id" parameterType="com.masaiqi.exchage.entity.User" useGeneratedKeys="true">
    insert into user (`name`, introduce)
    values (#{name,jdbcType=VARCHAR}, #{introduce,jdbcType=VARCHAR})
  </insert>
  <insert id="insertSelective" keyColumn="id" keyProperty="id" parameterType="com.masaiqi.exchage.entity.User" useGeneratedKeys="true">
    insert into user
    <trim prefix="(" suffix=")" suffixOverrides=",">
      <if test="name != null">
        `name`,
      </if>
      <if test="introduce != null">
        introduce,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
      <if test="name != null">
        #{name,jdbcType=VARCHAR},
      </if>
      <if test="introduce != null">
        #{introduce,jdbcType=VARCHAR},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.masaiqi.exchage.entity.User">
    update user
    <set>
      <if test="name != null">
        `name` = #{name,jdbcType=VARCHAR},
      </if>
      <if test="introduce != null">
        introduce = #{introduce,jdbcType=VARCHAR},
      </if>
    </set>
    where id = #{id,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.masaiqi.exchage.entity.User">
    update user
    set `name` = #{name,jdbcType=VARCHAR},
      introduce = #{introduce,jdbcType=VARCHAR}
    where id = #{id,jdbcType=INTEGER}
  </update>
</mapper>

3.8. 创建service模拟主业务

/**
 * @author sq.ma
 * @date 2019/12/1 下午4:06
 */
@Service
public class MainServiceImpl implements MainService {

    @Autowired
    private UserDAO userDAO;

    @Override
    @Transactional(rollbackFor = Exception.class)
    @DataSourceChoose(DataSourceType.DB_DEV)
    public void doJobDev() {
        User user = User.builder()
                .introduce("我是dev数据源来的~")
                .name("dec")
                .build();
        userDAO.insert(user);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    @DataSourceChoose(DataSourceType.DB_PROD)
    public void doJobProd() {
        User user = User.builder()
                .introduce("我是prod数据源来的~")
                .name("prod")
                .build();
        userDAO.insert(user);
    }
}

3.9. 创建AOP切入类

上文中我们创建了数据源切换注解，这里我们通过AOP进行动态代理，读取数据源注解，进行数据源切换，其实也就是重新设置DataSourceContextHolder.getDBType()的值。

/**
 * 数据源切换aop
 * <p>
 * 解析数据源切换注解 {@link DataSourceChoose}
 * <p>
 * 注意@Order(1) 设置执行顺序，否则如果事务注解先处理，会导致切换数据源失效
 *
 * @author sq.ma
 * @date 2019/11/27 上午9:42
 */
@Aspect
@Component
@Order(1)
public class DataSourceAOP {

    @Pointcut("execution( * com.masaiqi.exchage.service..*.*(..))")
    public void service(){
    }

    @Before("service()")
    public void dataSourceExchange(JoinPoint joinPoint) throws NoSuchMethodException {
        Object target = joinPoint.getTarget();
        String methodName = joinPoint.getSignature().getName();
        Class[] parameterTypes = ((MethodSignature) joinPoint.getSignature()).getMethod().getParameterTypes();
        Class clazz = target.getClass() ;
        Method m = clazz.getMethod(methodName, parameterTypes);
        if (m != null && m.isAnnotationPresent(DataSourceChoose.class)) {
            DataSourceChoose data = m.getAnnotation(DataSourceChoose.class);
            String dataSourceName = data.value();
            DataSourceContextHolder.setDBType(dataSourceName);
        }
    }


}

这里一定要注意@Order(1)这个注解，提高这个代理的优先级，如果不指定的话，@Transactional注解的事务代理会优先于数据源切换，会直接导致数据源切换失败，这一点很关键也很重要，这是我们对于能够正常执行事务提交回滚的思考。

当然，也不一定要指定为1，我们可以看一下源码：

在springBoot中，我们已经不需要写入@EnableTransactionManagement注解来开启事务，springBoot会自动帮我们配置，也就是org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration这个类：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ JdbcTemplate.class, PlatformTransactionManager.class })
@AutoConfigureOrder(Ordered.LOWEST_PRECEDENCE)
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceTransactionManagerAutoConfiguration {

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnSingleCandidate(DataSource.class)
	static class DataSourceTransactionManagerConfiguration {

		@Bean
		@ConditionalOnMissingBean(PlatformTransactionManager.class)
		DataSourceTransactionManager transactionManager(DataSource dataSource,
				ObjectProvider<TransactionManagerCustomizers> transactionManagerCustomizers) {
			DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);
			transactionManagerCustomizers.ifAvailable((customizers) -> customizers.customize(transactionManager));
			return transactionManager;
		}

	}

}

@AutoConfigureOrder(Ordered.LOWEST_PRECEDENCE)这个注解，定义了优先级，这个常量的值我们也可以看到：

这个值是int类型的最大值，也就是说，事务的优先级是很低的，你定义的值只要在这个前面就可以。

其实这也是SpringBoot约定大于配置的体现，如果你没有设置，他会默认开启事务并给定一个极低等优先级，这是约定。当然你也可以自己在通过EnableTransactionManagement注解主动开启事务，传参给定一个值，作为事务切入的优先级。

在上文中,你会发现我们在数据源配置的时候，也设置了默认的数据源，也就是说，即使用户不使用注解，我们也有默认的数据源去执行，用户可以选择使用注解指定数据源，这是我们对于约定大于配置的思考。

4. 测试总结

/**
 * 配置一个在SpringBoot项目启动后跟随启动的类
 *
 * @author sq.ma
 * @date 2019/12/1 下午3:52
 */
@Component
public class CommandRun implements CommandLineRunner {

    @Autowired
    private MainService mainService;

    @Override
    public void run(String... args) throws Exception {
        mainService.doJobDev();
        mainService.doJobProd();
        mainService.doJobDev();
        mainService.doJobProd();
    }

}

CommandLineRunner接口主要是帮助我们在springBoot项目启动后执行一段代码，这里我们交替两个数据源进行插入。

结果：

可以看到，数据都按照我们设置的，插入到了数据库中。

查看控制台：

两个数据源尽管交替执行，仍然只初始化了一次(单例)，这是我们对于每种数据源要能够实现单例的思考。当然，这其实是Spring的IOC容器的@Bean注解，默认只会创建一个实例帮了忙。

沙琪玛～
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程安全问题的原因及解决方案
qq_64421953的博客
03-25 3304
线程安全问题：简单来说，就是在多线程的调度下，导致出现了一些随机性，随机性使代码出现 了一些bug =>线程不安全 造成线程不安全的原因有哪些呢？ 1）抢占式执行，调度过程随机（也是万恶之源，无法解决） 2）多个线程同时修改同一个变量（可以适当调整代码结构，避免这种情况） 3）针对变量的操作，不是原子的（加锁，synchronized) 4)内存可见性，一个线程频繁读，一个线程写（使用volatile） 5）指令重排序（使用synchronized) 解决方法： 1）使用synchro
SpringBoot+aop实现多数据源动态切换
热门推荐
青衫烟雨客的专栏
08-10 1万+
SpringBoot+aop实现多数据源动态切换 一、多数据源动态切换原理 项目中我们经常会遇到多数据源的问题，尤其是数据同步或定时任务等项目更是如此；又例如：读写分离数据库配置的系统。 1、多数据源设置： 1）静态数据源切换： 一般情况下，我们可以配置多个数据源，然后为每个数据源写一套对应的sessionFactory和dao层代码(以hibernate为例，...
SpringBoot 实现动态切换数据源
最新发布
qq_28865843的博客
07-19 1131
上述提到了ThreadLocal和AbstractRoutingDataSource，我们来对其进行简单介绍下。ThreadLocal：想必大家必不会陌生，全称：thread local variable。主要是为解决多线程时由于并发而产生数据不一致问题。ThreadLocal为每个线程提供变量副本，确保每个线程在某一时间访问到的不是同一个对象，这样做到了隔离性，增加了内存，但大大减少了线程同步时的性能消耗，减少了线程并发控制的复杂程度。ThreadLocal作用：在一个线程中共享，不同线程间隔离。
真正意义的Spring动态切换数据源
batt1234的博客
03-16 619
写这篇博文的目的，是因为网上虽有林林总总的各种spring动态切换数据源教程，但是都不太满足我的需求，大部分教程都能实现切换数据源，但是在我看来，都没有真正意义的实现动态切换，举个例子，许多教程使用@DataSource(value="xxx")来切换数据源，我并不太认同这种方式。 我所理解的动态切换数据源，不仅仅是使用@DataSource(value="xxx")切换数据源，...
SpringBoot 优雅实现动态数据源切换配置
Java笔记虾
06-15 475
点击关注公众号，利用碎片时间学习前言随着应用用户数量的增加，相应的并发请求的数量也会跟着不断增加，慢慢地，单个数据库已经没有办法满足我们频繁的数据库操作请求了，在某些场景下，我们可能会需要配置多个数据源，使用多个数据源(例如实现数据库的读写分离)来缓解系统的压力等。同样的，Springboot官方提供了相应的实现来帮助开发者们配置多数据源，一般分为两种方式(目前我所了解到...
基于springboot的mysql实现动态切换数据源
weixiaohuai的博客
02-25 2027
一、概述 在项目中的某些场景中，需要对数据库进行一些优化。常用的有如下的实现方法：读写分离、引入缓存技术、主从复制、分库分表等。今天我们来简单介绍一些如何在程序中实现动态切换数据源，可能某台服务器性能比较好，让流量多的方法执行切换到此数据源去操作等等。 当然这种思想也可以扩展实现为读写分离，主库(主数据源)只负责写操作，从库(从数据源)只负责读操作，前提是数据库之间需要提前搭建好主从复制环境。 接下来，我们就将总结一下如何在代码层面动态切换不同的数据源。 二、动态切换数据源具体实现 主要有以下几个
SpringBoot配置多数据源实现动态切换数据源
06-29
本文将深入探讨如何在SpringBoot项目中配置多数据源，并实现数据源的动态切换，帮助你理解和掌握这一核心技能。 首先，我们理解"多数据源"的概念。在SpringBoot应用中，多数据源意味着系统能够连接并操作多个不同的...
springboot-AOP实现多数据源动态切换（Druid连接池）
12-25
- **动态数据源切换逻辑**：核心逻辑是在AOP切面的Advice中实现。当一个需要切换数据源的方法被调用时，通过反射或其他机制获取该方法上标注的数据源信息，然后根据这些信息从数据源池中获取对应的数据源，并将其...
基于 SpringBoot 多数据源 动态数据源 主从分离 快速启动器 支持分布式事务
01-05
基于 SpringBoot 多数据源 动态数据源 主从分离 快速启动器 支持分布式事务。一个基于springboot的快速集成多数据源的启动器。支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。支持数据库...
SpringBoot 基于注解，实现多数据源切换.zip
10-30
本项目是：SpringBoot 基于注解，实现多数据源切换（辅助用到：Druid连接池 + 事务 + MyBatis 等），项目下载后只需要修改一下.yml文件中的 MySQL 的URL连接，即可成功启动，欢迎大家下载
spring boot多数据源(AOP注解动态切换）
07-20
spring boot整合druid连接池，采用注解方式实现多数据源动态切换 jdk版本1.8 spring boot版本1.5.14
Android-MagicThread-安卓端纯注解使用的线程切换框架
08-13
MagicThread - 安卓端、纯注解使用的线程切换框架
SpringBoot动态切换数据源
qq_37634156的博客
08-24 4433
这里需要注意如果SpringBoot版本是2.0之后的版本，需要把【url】和【driverClassName】写成【jdbc-url】和【driver-class-name】，否则会报错【jdbcUrl is required with driverClassName.】自定义数据源枚举类，这里配置了两个数据源，则创建两个枚举。 3、注入数据源 生成bean。单一数据源与Mybatis整合时将DataSource数据源作为参数构建【SqlSessionFactory】，而多个数据源的话只需要将作为
Spring Boot多数据源配置并通过注解实现动态切换数据源
huangjhai的博客
07-31 5960
Spring Boot提供了AbstractRoutingDataSource 根据用户定义的规则选择使用的数据源，这样我们可以在每次数据库操作前设置使用的数据源，实现可动态路由的数据源，从而实现读写分离的功能。
SpringBoot 注解配置动态数据源
u011618818的博客
05-12 1324
概述 在项目中有时会需要根据情况来使用不同的数据源 实现方式 一、配置数据源 spring: datasource: master: password: root url: jdbc:mysql://localhost:3306/evid_yunyan?characterEncoding=utf-8&autoReconnect=true&failOverReadOnly=false&serverTimezone=Asia/Shanghai
springboot 基于注解实现多数据源切换
Vincent2014Linux
05-09 1964
1 背景 业务开发中，后端通常需要操作多个数据库（可能同类型，也可能不同类型）中的数据，比如主、从数据库的切换场景通常就是同类型切换。但实际需求中，也有可能需要不同类型数据库之间的切换。不论是否同类型，其背后原理一致，只需在配置文件中修改数据库驱动，相关配置类中修改。springboot 提供的AbstractRoutingDataSource实现多数据源动态切换的核心逻辑是：通过AOP的方式在程序运行时，把数据源通过 AbstractRoutingDataSource 动态织入到程序中，灵活地进行数据源切
springboot+AOP实现动态修改注解并切换数据源
LZX的博客
05-08 2949
项目结构 情景描述 异源数据，在一个工程中处理后，传入不同数据库中保存。 类似下图所想完成 pom.xml 不耍流氓，贴pom。有的没的都导了。 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.o...
spring boot动态切换数据源
人生就像一场戏
01-06 2252
1、添加maven依赖 <?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/x
SpringBoot AOP 实现多数据源切换详细教程
4. 编写AOP切面：创建一个切面类，使用`@Aspect`注解，并在`@Around`通知中处理数据源切换。这里要解析注解，根据注解信息决定使用主数据源还是从数据源。 5. 应用注解：在Service层需要切换数据源的方法上添加...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值