SpringBoot+MyBatisPlus+Druid从单数据源到多数据源动态切换2-基于AbstractRoutingDataSource实现多数据源

已于 2022-05-11 14:26:09 修改
阅读量821 收藏 3
点赞数
分类专栏： SpringBoot MyBatisPlus 文章标签： spring boot 数据库
于 2022-05-07 18:03:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gefeng1209/article/details/124624335
版权

系列文章

1. SpringBoot+MyBatisPlus+Druid从单数据源到多数据源动态切换1-单数据源

2. SpringBoot+MyBatisPlus+Druid从单数据源到多数据源动态切换2-基于AbstractRoutingDataSource实现多数据源

3. SpringBoot+MyBatisPlus+Druid从单数据源到多数据源动态切换3-基于dynamic-datasource实现多数据源 

文章目录

1.application.yml中spring.datasource.druid下添加多数据源配置

# 单数据源配置
spring:
  datasource:
#    type: com.alibaba.druid.pool.DruidDataSource
#    driver-class-name: com.mysql.cj.jdbc.Driver
    druid:
      #主库数据源
      master:
        url: jdbc:mysql://localhost:3306/db-master?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: root
      #从库数据源
      slave:
        # 从数据源开关/默认关闭
        enabled: true
        url: jdbc:mysql://localhost:3306/db-slave?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: root
      # 初始连接数
      initialSize: 5
      # 最小连接池数量
      minIdle: 10
      # 最大连接池数量
      maxActive: 20
      # 配置获取连接等待超时的时间
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 300000
      # 配置一个连接在池中最大生存的时间，单位是毫秒
      maxEvictableIdleTimeMillis: 900000
      # 配置检测连接是否有效
      validationQuery: SELECT 1 FROM DUAL
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      # 用于采集web-jdbc关联监控的数据
      webStatFilter:
        enabled: true
      # 用于展示Druid的统计信息（提供监控信息展示的html页面+提供监控信息的JSON Api）
      statViewServlet:
        enabled: true
        # 设置ip白名单（逗号隔开），不填则允许所有访问
        allow:
        # ip黑名单（优先于allow）
        deny:
        # 监控页面的url
        url-pattern: /druid/*
        # 控制台管理用户名和密码
        login-username: ruoyi
        login-password: 123456
      filter:
        # 用于统计监控信息
        stat:
          enabled: true
          # 慢SQL记录
          log-slow-sql: true
          # 慢sql标准，单位毫秒
          slow-sql-millis: 1000
          # 合并sql
          merge-sql: true
        wall:
          config:
            # 是否允许一次执行多条语句，默认关闭
            multi-statement-allow: true

这里添加了两个数据源master和slave相关配置，分别连接db-master和db-slave两个库。 

2.Druid属性配置类DruidProperties

/**
 * druid 配置属性
 * 
 * @author ruoyi
 */
@Configuration
public class DruidProperties
{
    @Value("${spring.datasource.druid.initialSize}")
    private int initialSize;

    @Value("${spring.datasource.druid.minIdle}")
    private int minIdle;

    @Value("${spring.datasource.druid.maxActive}")
    private int maxActive;

    @Value("${spring.datasource.druid.maxWait}")
    private int maxWait;

    @Value("${spring.datasource.druid.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.druid.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.maxEvictableIdleTimeMillis}")
    private int maxEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.validationQuery}")
    private String validationQuery;

    @Value("${spring.datasource.druid.testWhileIdle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.druid.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.druid.testOnReturn}")
    private boolean testOnReturn;

    public DruidDataSource dataSource(DruidDataSource datasource)
    {
        /** 配置初始化大小、最小、最大 */
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);


        /** 配置获取连接等待超时的时间 */
        datasource.setMaxWait(maxWait);

        /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

        /** 配置一个连接在池中最小、最大生存的时间，单位是毫秒 */
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);

        /**
         * 用来检测连接是否有效的sql，要求是一个查询语句，常用select 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
         */
        datasource.setValidationQuery(validationQuery);
        /** 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 */
        datasource.setTestWhileIdle(testWhileIdle);
        /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnBorrow(testOnBorrow);
        /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnReturn(testOnReturn);
        return datasource;
    }
}

 通过@Value注解DruidProperties类会将application.yml中druid相关配置赋值给对应的字段。

3.数据源切换处理类DynamicDataSourceContextHolder

/**
 * 数据源切换处理
 * 
 * @author ruoyi
 */
public class DynamicDataSourceContextHolder
{
    public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);

    /**
     * 使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
     *  所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
     */
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    /**
     * 设置数据源的变量
     */
    public static void setDataSourceType(String dsType)
    {
        log.info("切换到{}数据源", dsType);
        CONTEXT_HOLDER.set(dsType);
    }

    /**
     * 获得数据源的变量
     */
    public static String getDataSourceType()
    {
        return CONTEXT_HOLDER.get();
    }

    /**
     * 清空数据源变量
     */
    public static void clearDataSourceType()
    {
        CONTEXT_HOLDER.remove();
    }
}

 DynamicDataSourceContextHolder中使用ThreadLocal为每个调用线程维护了一个String类型的线程本地变量，表示要切换的目标数据源的名字。并提供了set，get和clear方法。

4.新建AbstractRoutingDataSource的实现类DynamicDataSource

/**
 * 动态数据源
 * 
 * @author ruoyi
 */
public class DynamicDataSource extends AbstractRoutingDataSource
{
    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources)
    {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

    /**
     * 获取目标数据源的key：
     * 调用了DynamicDataSourceContextHolder的getDataSourceType()，即读取线程本地变量CONTEXT_HOLDER的值
     * @return: java.lang.Object
     * @author: gefeng
     * @date: 2022/5/7 15:54
     */
    @Override
    protected Object determineCurrentLookupKey()
    {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

 新增了构造方法可设置默认的目标数据源和备用的目标数据源。

5.Druid多数据源配置类DruidConfig

/**
 * druid 配置多数据源
 * 3个Bean的加载顺序：
 * dynamicDataSource
 * ->masterDataSource(是dynamicDataSource的参数)
 * ->slaveDataSource(setDataSource中SpringUtils.getBean("slaveDataSource")中有使用)
 * 
 * @author ruoyi
 */
@Configuration
public class DruidConfig
{
    @Bean
    @ConfigurationProperties("spring.datasource.druid.master")
    //@ConfigurationProperties将自动将spring.datasource.druid.master下的配置属性赋值给该Bean(DruidDataSource的实例)
    public DataSource masterDataSource(DruidProperties druidProperties)
    {
        //创建一个DruidDataSource的实例，并将配置文件中druid属性配置赋值给该实例
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidProperties.dataSource(dataSource);
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.slave")
//    @ConditionalOnProperty(prefix = "spring.datasource.druid.slave", name = "enabled", havingValue = "true")
    //spring.datasource.druid.slave.enabled=true时，该bean将被Spring上下文加载
    //@ConfigurationProperties将自动将spring.datasource.druid.slave下的配置属性赋值给该Bean(DruidDataSource的实例)
    public DataSource slaveDataSource(DruidProperties druidProperties)
    {
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidProperties.dataSource(dataSource);
    }

    @Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dataSource(DataSource masterDataSource)
    {
        //注意targetDataSources中数据源的key（DataSourceType.MASTER.name()，DataSourceType.SLAVE.name()）
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.MASTER.name(), masterDataSource);
        setDataSource(targetDataSources, DataSourceType.SLAVE.name(), "slaveDataSource");
        return new DynamicDataSource(masterDataSource, targetDataSources);
    }
    
    /**
     * 设置数据源
     * 
     * @param targetDataSources 备选数据源集合
     * @param sourceName 数据源名称
     * @param beanName bean名称
     */
    public void setDataSource(Map<Object, Object> targetDataSources, String sourceName, String beanName)
    {
        try
        {
            DataSource dataSource = SpringUtils.getBean(beanName);
            targetDataSources.put(sourceName, dataSource);
        }
        catch (Exception e)
        {
        }
    }

    /**
     * 去除监控页面底部的广告
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    @Bean
    @ConditionalOnProperty(name = "spring.datasource.druid.statViewServlet.enabled", havingValue = "true")
    public FilterRegistrationBean removeDruidFilterRegistrationBean(DruidStatProperties properties)
    {
        // 获取web监控页面的参数
        DruidStatProperties.StatViewServlet config = properties.getStatViewServlet();
        // 提取common.js的配置路径
        String pattern = config.getUrlPattern() != null ? config.getUrlPattern() : "/druid/*";
        String commonJsPattern = pattern.replaceAll("\\*", "js/common.js");
        final String filePath = "support/http/resources/js/common.js";
        // 创建filter进行过滤
        Filter filter = new Filter()
        {
            @Override
            public void init(javax.servlet.FilterConfig filterConfig) throws ServletException
            {
            }
            @Override
            public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                    throws IOException, ServletException
            {
                chain.doFilter(request, response);
                // 重置缓冲区，响应头不会被重置
                response.resetBuffer();
                // 获取common.js
                String text = Utils.readFromResource(filePath);
                // 正则替换banner, 除去底部的广告信息
                text = text.replaceAll("<a.*?banner\"></a><br/>", "");
                text = text.replaceAll("powered.*?shrek.wang</a>", "");
                response.getWriter().write(text);
            }
            @Override
            public void destroy()
            {
            }
        };
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(filter);
        registrationBean.addUrlPatterns(commonJsPattern);
        return registrationBean;
    }
}

 SpringBoot启动时在加载名为dynamicDataSource的Bean时，调用了DynamicDataSource中的构造方法，注意targetDataSources中数据源的key（DataSourceType.MASTER.name()，DataSourceType.SLAVE.name()）。

6.数据源枚举类DataSourceType

/**
 * 数据源
 * 
 * @author ruoyi
 */
public enum DataSourceType
{
    /**
     * 主库
     */
    MASTER,

    /**
     * 从库
     */
    SLAVE
}

包含MASTER和SLAVE两个枚举值 ，对应上面提到的targetDataSources中数据源的key。

 7.自定义数据源注解@DataSource

/**
 * 自定义多数据源切换注解
 *
 * 优先级：先方法，后类，如果方法覆盖了类上的数据源类型，以方法的为准，否则以类上的为准
 * 如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类
 *
 * @author ruoyi
 */
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource
{
    /**
     * 切换数据源名称
     */
    public DataSourceType value() default DataSourceType.MASTER;
}

@DataSource只有只一个字段，用来设置目标数据源在targetDataSources中的key，类型为DataSourceType，默认为DataSourceType.MASTER。

8.多数据源动态切换AOP切面类DataSourceAspect

/**
 * 实现多数据源动态切换的aop切面
 * @within 对象级别
 * @annotation 方法级别
 * 
 * @author ruoyi
 */
@Aspect
@Order(1)
@Component
public class DataSourceAspect
{
    protected Logger logger = LoggerFactory.getLogger(getClass());

    //切点：@DataSource注解的方法和@DataSource注解的类的对象
    @Pointcut("@annotation(com.doit.annotation.DataSource)"
            + "|| @within(com.doit.annotation.DataSource)")
    public void dsPointCut()
    {

    }

    /**
     * 切点执行前：通过DynamicDataSourceContextHolder设置调用线程本地变量CONTEXT_HOLDER
     * 切点执行后：通过DynamicDataSourceContextHolder清除调用线程本地变量CONTEXT_HOLDER
     * @param point 1
     * @return: java.lang.Object
     * @author: gefeng
     * @date: 2022/5/7 16:24
     */
    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable
    {
        DataSource dataSource = getDataSource(point);

        if (StringUtils.isNotNull(dataSource))
        {
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
        }

        try
        {
            return point.proceed();
        }
        finally
        {
            // 销毁数据源 在执行方法之后
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
    }

    /**
     * 获取需要切换的数据源
     */
    public DataSource getDataSource(ProceedingJoinPoint point)
    {
        MethodSignature signature = (MethodSignature) point.getSignature();
        DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), DataSource.class);
        if (Objects.nonNull(dataSource))
        {
            return dataSource;
        }

        return AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class);
    }
}

 切点为@DataSource注解的方法和@DataSource注解的类的对象被调用时。

9.在Controller的方法中如何使用@DataSource

@RestController
@RequestMapping("/user")
public class UserController extends BaseController{
    @Autowired
    private UserService userService;

    @GetMapping("/list")
    @DataSource(DataSourceType.MASTER)
    public TableDataInfo list(){
        List<User> list = userService.list();
        return getDataTable(list);
    }

}

UserContoller中list方法使用了master数据源。

@RestController
@RequestMapping("/employee")
public class EmployeeController extends BaseController{
    @Autowired
    private EmployeeService employeeService;

    @GetMapping("/list")
    @DataSource(DataSourceType.SLAVE)
    public TableDataInfo list(){
        List<Employee> list = employeeService.list();
        return getDataTable(list);
    }

}

EmployeeContoller中list方法使用了slave数据源。

二、启动测试

1.项目端口上下文配置

server:
  port: 9998
  servlet:
    context-path: /abstract-routing-demo

2.启动类

//exclude，排除此类的AutoConfig，即禁止 SpringBoot 自动注入数据源配置。
//
//DataSourceAutoConfiguration.class 会自动查找 application.yml 或者 properties 文件
//里的 spring.datasource.* 相关属性并自动配置单数据源「注意这里提到的单数据源」。
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class AbstractRoutingDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(AbstractRoutingDemoApplication.class, args);
    }
}

3.启动项目，使用测试工具insomnia访问接口

访问user/list接口

 控制台打印出sql语句：

 访问成功，可以看到连接的是master数据源。

访问employee/list接口

  控制台打印出sql语句：

 访问成功，可以看到连接的是slave数据源。数据源切换成功，perfect。

4.访问Druid监控页面

使用statViewServlet下配置的login-username和login-password登录可以看到上面的页面，成功。

gefeng1209
关注
专栏目录
mybatis-plus+springboot+druid实现读写分离
u011215412的博客
11-12 1200
网上大多读写分离实例，都是需要手动侵入代码修改数据源，本博客主要实现，如何对现有系统，不侵入原有代码，进行读写分离配置。 Mybatis-Plus自带动态数据源配置，但是也需要对手动配置，需要的可以参考官网Mybstis-Plus官网 1、引入依赖 依赖较多，主要还有MybatisPlus单数据源配置的依赖，作者就全部贴上来了。 <!-- mysql--> <...
SpringBoot集成Druid 动态切换数据源
qq_46237915的博客
07-14 910
SpringBoot集成Druid 动态切换数据源 主要逻辑 通过继承 AbstractRoutingDataSource 类覆写其 determineCurrentLookupKey() 方法来设置数据源，动态切换则基于aop实现。通过自定义一个注解，传入我们需要的数据源名称，在切面中获取到数据源名称并将其存储到当前线程的私有内存（ThreadLocal）中。在调用方法时读取当前线程存储的数据源名称，并根据这个名称去设置数据源. 依赖： <parent> <groupId>
spring boot+druid+mybatisPlus 动态切换数据源
俞兆鹏的博客
02-26 7808
前言 项目中经常会有集成其他数据库的情况，我们项目是使用spring Boot+Druid+Mybatis Plus开发，本文简述在项目通过AOP的方式动态的切换数据库 版本号 框架 版本号 maven依赖 druid 1.1.10 <groupId>com.alibaba</groupId> <artifactId>druid-sp...
springboot+Druid+MybatisPlus整合多数据源（MySQL＋postgresql）
xikx99的博客
10-18 2315
在工作中，可能会有些项目会需要两个数据库，一部分操作是对于A数据库，一部分操作对于B数据库，于是在网上寻找方法，最后使用了这个mybatis-plus实现了动态数据源。
springboot+mybatis+mysql+AbstractRoutingDataSource实现多数据源切换(一写多读数据源)
07-28
springboot+mybatis+mysql+AbstractRoutingDataSource实现多数据源切换(一写多读数据源)项目中包含完整的demo案例配备文档说明,亲测可用;实现简单,代码思路清晰.
多数据源的配置和使用
programmer188的博客
07-09 693
yaml文件里的: spring: datasource: one: jdbc-url: jdbc:mysql://127.0.0.1:3306/bet?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true username: root password: root two: jdbc-url: jdbc:mysql://127.0.0.2:3306.
基于SpringBoot的MyBatisPlus+Druid+AbstractRoutingDataSource的动态数据源实现方案
做一名持续学习的GIS Coder
06-26 1290
AbstractRoutingDataSource是Spring框架中提供的一个抽象类，用于实现动态数据源。它继承自javax.sql.DataSource接口，并重写了getConnection()方法，该方法会根据当前线程绑定的数据源key来获取相应的数据源，并返回一个连接。中有来存放我们需要切换的数据源；中方法进行了特殊处理，通过方法返回的lookupKey来决定使用哪个数据源来返回数据库连接对象。因此示例中我们对方法进行了重写，来实现我们想要的效果（从Holder中拿到数据源key进行切换）。
springboot+mybatisplus+mysql+druid双数据源动态切换（附代码）
m0_37679361的博客
02-09 418
java
springboot+mybatisPlus+druid实现动态数据源切换，使用Aop+注解实现
最新发布
weixin_58569348的博客
04-05 2359
以上的就是mybatisPlus+druid实现多数据源的步骤，步骤仅做参考，有不对的地方，欢迎大家交流指导。
Springboot2.0x 多数据源+Durid 使用注解动态切换
qq_39971775的博客
06-03 1552
Spring boot提供了AbstractRoutingDataSource 根据用户定义的规则选择当前的数据源，这样我们可以在执行查询之前，设置使用的数据源。实现可动态路由的数据源，在每次数据库查询操作前执行。它的抽象方法 determineCurrentLookupKey() 决定使用哪个数据源。
多数据源 - dynamic-datasource | 常见问题汇总
甘蓝的专栏
03-26 1443
基于 SpringBoot 的多数据源实现 dynamic-datasource 常见问题汇总。
基于Spring Boot实现Mybatis的多数据源切换和动态数据源加载
热门推荐
【逸辰杳】的博客
12-25 2万+
Spring Boot Mybaits mybatis基本配置、多数据源切换、动态加载数据源
mybatis-plus实现动态数据源
qq_59047319的博客
06-14 3263
1 创建数据源实体类2 获取数据源缓存。读取数据库，获取数据源信息，生成druidDataSource实体，放入Map中 key是数据源名称，value是对应数据源druidDataSource实体3 明确本线程的数据源 创建线程本地变量ThreadLocal 存放线程的key4 创建db注解 放在需要的方法上 例如 @Db(“master”)5 切库 使用Aop在方法执行前通过ThreaLocal的key,替换注解的value,实现切库。
springboot+整合druid+整合mybatis+配置多数据源+动态数据源切换
Fisher3652的博客
02-29 2542
一、 srpingboot整合druid 1.jar包导入(pom.xml完整配置请查看第三部分) <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.0.26</version...
springboot+mybatis+druid动态数据源
ko_10086的博客
06-18 1196
思路：从动态数据源工具中获取到DataSource标示，根据标示获取DataSrouce对象。在Spring容器中，这一点其实更好实现。原理就是在DB访问之前，切换数据源。
【Java】mybatis用AbstractRoutingDataSource实现动态数据源时的事务管理
qq523786283的博客
01-21 2114
第一阶段 最近遇到一个用到多数据源的项目，它是通过实现AbstractRoutingDataSource类来动态切换数据源的。而当我想为这个项目加入事务时，发现程序报错。就是数据源切换失败。 经过探索后发现原因是spring默认的事务管理器DataSourceTransactionManager在开启事务时会缓存连接。如图 恰好我当时对分布式事务有点兴趣，所有我首先想到的是尝试通过改用
基于Spring内置AbstractRoutingDataSource实现MyBatis线程级动态数据源
shanchahua123456的博客
09-16 950
github 代码：https://github.com/sw008/Repository 其他文章： https://www.liaoxuefeng.com/article/00151054582348974482c20f7d8431ead5bc32b30354705000 https://blog.csdn.net/u013360850/article/details/78861442...
事务—【01】Spring事务管理介绍以及SpringBoot+Druid+MyBatis单数据源事务管理实现
苡仁
01-11 841
前置知识 简单介绍 详解自行google. 事务是什么？ 事务是一种可靠、一致的方式，访问和操作数据库中的程序单元 事务的特性 原子性：要么做，要么不做 一致性：一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态 持久性：持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的。 隔离性：不同的事务操作的互相不干扰 并发事务的问题 脏读：脏读是...
Mybatis多数据源的切换——AbstractRoutingDataSource
天天向上
12-02 1141
Spring数据源路由核心类AbstractRoutingDataSource，API文档解释如下： Abstract javax.sql.DataSource implementation that routes getConnection() calls to one of various target DataSources based on a lookup key. The latt...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值