【源码解析】多数据源 dynamic-datasource快速入门及源码解析

已于 2023-04-21 11:31:06 修改
阅读量2k 收藏 6
点赞数 6
分类专栏： 源码解析 开源项目介绍 文章标签： servlet java spring
于 2023-04-21 11:30:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42985872/article/details/130284590
版权

快速入门

依赖引入

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>

配置文件

spring.datasource.druid.stat-view-servlet.enabled = true
spring.datasource.druid.stat-view-servlet.login-username = root
spring.datasource.druid.stat-view-servlet.login-password = root
spring.datasource.dynamic.druid.filters = stat,wall
spring.datasource.druid.aop-patterns = com.charles.mapper.*
spring.datasource.druid.web-stat-filter.enabled = true
spring.datasource.druid.filter.stat.enabled = true
spring.datasource.druid.filter.stat.log-slow-sql = true
spring.datasource.druid.filter.stat.slow-sql-millis = 1000

spring.datasource.dynamic.primary = db0
spring.datasource.dynamic.datasource.db1.driver-class-name = com.mysql.cj.jdbc.Driver
spring.datasource.dynamic.datasource.db1.url = jdbc:mysql://127.0.0.1:3306/eb-crm?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
spring.datasource.dynamic.datasource.db1.username = app
spring.datasource.dynamic.datasource.db1.password = Ys@123456
spring.datasource.dynamic.datasource.db1.type = com.alibaba.druid.pool.DruidDataSource
spring.datasource.dynamic.datasource.db0.driver-class-name = com.mysql.cj.jdbc.Driver
spring.datasource.dynamic.datasource.db0.url = jdbc:mysql://127.0.0.1:3306/newcrm?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true
spring.datasource.dynamic.datasource.db0.username = app
spring.datasource.dynamic.datasource.db0.password = Ys@123456
spring.datasource.dynamic.datasource.db0.type = com.alibaba.druid.pool.DruidDataSource

使用注解拦截

@DS("db1")
public interface TbpExcelLogMapper extends BaseMapper<TbpExcelLog> {
}

源码解析

启动的时候，会加载在dynamic-datasource-spring-boot-starter的jar包中的spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DynamicDataSourceAutoConfiguration

数据源加载

在DynamicDataSourceAutoConfiguration会注入DynamicRoutingDataSource

    @Bean
    @ConditionalOnMissingBean
    public DataSource dataSource() {
        DynamicRoutingDataSource dataSource = new DynamicRoutingDataSource();
        dataSource.setPrimary(properties.getPrimary());
        dataSource.setStrict(properties.getStrict());
        dataSource.setStrategy(properties.getStrategy());
        dataSource.setP6spy(properties.getP6spy());
        dataSource.setSeata(properties.getSeata());
        return dataSource;
    }

DynamicRoutingDataSource#afterPropertiesSet，系统启动的时候会加载所有的数据源

    @Override
    public void afterPropertiesSet() throws Exception {
        // 检查开启了配置但没有相关依赖
        checkEnv();
        // 添加并分组数据源
        Map<String, DataSource> dataSources = new HashMap<>(16);
        for (DynamicDataSourceProvider provider : providers) {
            dataSources.putAll(provider.loadDataSources());
        }
        for (Map.Entry<String, DataSource> dsItem : dataSources.entrySet()) {
            addDataSource(dsItem.getKey(), dsItem.getValue());
        }
        // 检测默认数据源是否设置
        if (groupDataSources.containsKey(primary)) {
            log.info("dynamic-datasource initial loaded [{}] datasource,primary group datasource named [{}]", dataSources.size(), primary);
        } else if (dataSourceMap.containsKey(primary)) {
            log.info("dynamic-datasource initial loaded [{}] datasource,primary datasource named [{}]", dataSources.size(), primary);
        } else {
            log.warn("dynamic-datasource initial loaded [{}] datasource,Please add your primary datasource or check your configuration", dataSources.size());
        }
    }

在DynamicDataSourceAutoConfiguration会注入DynamicDataSourceProvider

    @Bean
    public DynamicDataSourceProvider ymlDynamicDataSourceProvider() {
        return new YmlDynamicDataSourceProvider(properties.getDatasource());
    }

AbstractDataSourceProvider#createDataSourceMap，根据配置文件中的信息创建数据源。

    protected Map<String, DataSource> createDataSourceMap(
            Map<String, DataSourceProperty> dataSourcePropertiesMap) {
        Map<String, DataSource> dataSourceMap = new HashMap<>(dataSourcePropertiesMap.size() * 2);
        for (Map.Entry<String, DataSourceProperty> item : dataSourcePropertiesMap.entrySet()) {
            String dsName = item.getKey();
            DataSourceProperty dataSourceProperty = item.getValue();
            String poolName = dataSourceProperty.getPoolName();
            if (poolName == null || "".equals(poolName)) {
                poolName = dsName;
            }
            dataSourceProperty.setPoolName(poolName);
            dataSourceMap.put(dsName, defaultDataSourceCreator.createDataSource(dataSourceProperty));
        }
        return dataSourceMap;
    }

AbstractDataSourceCreator#createDataSource，模板方法。该方法会调用dataSourceInitEvent.beforeCreate(dataSourceProperty);。而doCreateDataSource交由每个子类来创建。

    @Override
    public DataSource createDataSource(DataSourceProperty dataSourceProperty) {
        String publicKey = dataSourceProperty.getPublicKey();
        if (StringUtils.isEmpty(publicKey)) {
            publicKey = properties.getPublicKey();
            dataSourceProperty.setPublicKey(publicKey);
        }
        Boolean lazy = dataSourceProperty.getLazy();
        if (lazy == null) {
            lazy = properties.getLazy();
            dataSourceProperty.setLazy(lazy);
        }
        dataSourceInitEvent.beforeCreate(dataSourceProperty);
        DataSource dataSource = doCreateDataSource(dataSourceProperty);
        dataSourceInitEvent.afterCreate(dataSource);
        this.runScrip(dataSource, dataSourceProperty);
        return wrapDataSource(dataSource, dataSourceProperty);
    }

DruidDataSourceCreator#doCreateDataSource，创建druid数据源。根据全局配置gConfig和定制化配置结合来生成DruidDataSource。spring.datasource.dynamic.datasource.xxx.type=com.alibaba.druid.pool.DruidDataSource可以进行定制化配置，也可以通过spring.datasource.dynamic.druid全局配置druid的属性

    private DruidConfig gConfig;

    @Override
    public DataSource doCreateDataSource(DataSourceProperty dataSourceProperty) {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername(dataSourceProperty.getUsername());
        dataSource.setPassword(dataSourceProperty.getPassword());
        dataSource.setUrl(dataSourceProperty.getUrl());
        dataSource.setName(dataSourceProperty.getPoolName());
        String driverClassName = dataSourceProperty.getDriverClassName();
        if (!StringUtils.isEmpty(driverClassName)) {
            dataSource.setDriverClassName(driverClassName);
        }
        DruidConfig config = dataSourceProperty.getDruid();
        Properties properties = config.toProperties(gConfig);

        List<Filter> proxyFilters = this.initFilters(dataSourceProperty, properties.getProperty("druid.filters"));
        dataSource.setProxyFilters(proxyFilters);

        dataSource.configFromPropety(properties);
        //连接参数单独设置
        dataSource.setConnectProperties(config.getConnectionProperties());
        //设置druid内置properties不支持的的参数
        this.setParam(dataSource, config);

        if (Boolean.FALSE.equals(dataSourceProperty.getLazy())) {
            try {
                dataSource.init();
            } catch (SQLException e) {
                throw new ErrorCreateDataSourceException("druid create error", e);
            }
        }
        return dataSource;
    }

切面修改数据源的key

在DynamicDataSourceAutoConfiguration会注入DynamicDataSourceAnnotationAdvisor

    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    @Bean
    @ConditionalOnProperty(prefix = DynamicDataSourceProperties.PREFIX + ".aop", name = "enabled", havingValue = "true", matchIfMissing = true)
    public Advisor dynamicDatasourceAnnotationAdvisor(DsProcessor dsProcessor) {
        DynamicDatasourceAopProperties aopProperties = properties.getAop();
        DynamicDataSourceAnnotationInterceptor interceptor = new DynamicDataSourceAnnotationInterceptor(aopProperties.getAllowedPublicOnly(), dsProcessor);
        DynamicDataSourceAnnotationAdvisor advisor = new DynamicDataSourceAnnotationAdvisor(interceptor, DS.class);
        advisor.setOrder(aopProperties.getOrder());
        return advisor;
    }

DynamicDataSourceAnnotationAdvisor#buildPointcut，构造切面，对方法和类都拦截。

    private Pointcut buildPointcut() {
        Pointcut cpc = new AnnotationMatchingPointcut(annotation, true);
        Pointcut mpc = new AnnotationMethodPoint(annotation);
        return new ComposablePointcut(cpc).union(mpc);
    }

如果使用@Aspect来切面的话，对注解进行切片，要注意@within和@annotation的区别。

 1.  @within 对象级别
 2.  @annotation 方法级别

DynamicDataSourceAnnotationInterceptor#invoke，获取方法上或者类上的注解中的key

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        String dsKey = determineDatasourceKey(invocation);
        DynamicDataSourceContextHolder.push(dsKey);
        try {
            return invocation.proceed();
        } finally {
            DynamicDataSourceContextHolder.poll();
        }
    }

DynamicDataSourceAnnotationInterceptor#determineDatasourceKey，如果key以#开头，则返回dsProcessor.determineDatasource(invocation, key)，否则直接返回key。

    private String determineDatasourceKey(MethodInvocation invocation) {
        String key = dataSourceClassResolver.findKey(invocation.getMethod(), invocation.getThis());
        return key.startsWith(DYNAMIC_PREFIX) ? dsProcessor.determineDatasource(invocation, key) : key;
    }

DsProcessor

在DynamicDataSourceAutoConfiguration会注入DsProcessor，使用过滤器链的模式进行处理。

    @Bean
    @ConditionalOnMissingBean
    public DsProcessor dsProcessor(BeanFactory beanFactory) {
        DsHeaderProcessor headerProcessor = new DsHeaderProcessor();
        DsSessionProcessor sessionProcessor = new DsSessionProcessor();
        DsSpelExpressionProcessor spelExpressionProcessor = new DsSpelExpressionProcessor();
        spelExpressionProcessor.setBeanResolver(new BeanFactoryResolver(beanFactory));
        headerProcessor.setNextProcessor(sessionProcessor);
        sessionProcessor.setNextProcessor(spelExpressionProcessor);
        return headerProcessor;
    }

DsHeaderProcessor#doDetermineDatasource，如果方法上的注解类似于@DS(#header=tenat_id)，那么切换路由的key是由header中tenat_id的值决定的。

    @Override
    public String doDetermineDatasource(MethodInvocation invocation, String key) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        return request.getHeader(key.substring(8));
    }

spelExpressionProcessor是支持表达式的。

在注解中配置@DS("#header=tenantName")，则从header里面去寻找key；写了@DS("#session=tenantName")，就从session里面获取以tenantName为键的值。而@DS("#tenantName")和@DS("#user.tenantName")根据参数来获取。

获取数据源

获取连接，AbstractRoutingDataSource#getConnection()。首先获取数据源，从数据源中获取Connection

    @Override
    public Connection getConnection() throws SQLException {
        String xid = TransactionContext.getXID();
        if (StringUtils.isEmpty(xid)) {
            return determineDataSource().getConnection();
        } else {
            String ds = DynamicDataSourceContextHolder.peek();
            ds = StringUtils.isEmpty(ds) ? "default" : ds;
            ConnectionProxy connection = ConnectionFactory.getConnection(ds);
            return connection == null ? getConnectionProxy(ds, determineDataSource().getConnection()) : connection;
        }
    }

DynamicRoutingDataSource#determineDataSource，获取线程变量的数据，根据线程变量获取数据源。

    @Override
    public DataSource determineDataSource() {
        String dsKey = DynamicDataSourceContextHolder.peek();
        return getDataSource(dsKey);
    }

DynamicRoutingDataSource#getDataSource，该key为空，获取默认数据源，优先从groupDataSources里面获取数据源，然后再从dataSourceMap里面获取。

    public DataSource getDataSource(String ds) {
        if (StringUtils.isEmpty(ds)) {
            return determinePrimaryDataSource();
        } else if (!groupDataSources.isEmpty() && groupDataSources.containsKey(ds)) {
            log.debug("dynamic-datasource switch to the datasource named [{}]", ds);
            return groupDataSources.get(ds).determineDataSource();
        } else if (dataSourceMap.containsKey(ds)) {
            log.debug("dynamic-datasource switch to the datasource named [{}]", ds);
            return dataSourceMap.get(ds);
        }
        if (strict) {
            throw new CannotFindDataSourceException("dynamic-datasource could not find a datasource named" + ds);
        }
        return determinePrimaryDataSource();
    }

DynamicDataSourceStrategy，从群组里面获取数据源需要配置获取策略，从集合中决定是哪一个，有随机和轮询。

public class RandomDynamicDataSourceStrategy implements DynamicDataSourceStrategy {

    @Override
    public String determineKey(List<String> dsNames) {
        return dsNames.get(ThreadLocalRandom.current().nextInt(dsNames.size()));
    }
}

比对一下，spring-jdbc中的动态数据源切换。

AbstractRoutingDataSource#afterPropertiesSet，重写了InitializingBean#afterPropertiesSet的方法。

    public void afterPropertiesSet() {
        if (this.targetDataSources == null) {
            throw new IllegalArgumentException("Property 'targetDataSources' is required");
        } else {
            this.resolvedDataSources = new HashMap(this.targetDataSources.size());
            this.targetDataSources.forEach((key, value) -> {
                Object lookupKey = this.resolveSpecifiedLookupKey(key);
                DataSource dataSource = this.resolveSpecifiedDataSource(value);
                this.resolvedDataSources.put(lookupKey, dataSource);
            });
            if (this.defaultTargetDataSource != null) {
                this.resolvedDefaultDataSource = this.resolveSpecifiedDataSource(this.defaultTargetDataSource);
            }

        }
    }

AbstractRoutingDataSource#getConnection()。获取lookupKey的方式由子类决定。

    public Connection getConnection() throws SQLException {
        return this.determineTargetDataSource().getConnection();
    }

    protected DataSource determineTargetDataSource() {
        Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
        Object lookupKey = this.determineCurrentLookupKey();
        DataSource dataSource = (DataSource)this.resolvedDataSources.get(lookupKey);
        if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
            dataSource = this.resolvedDefaultDataSource;
        }

        if (dataSource == null) {
            throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
        } else {
            return dataSource;
        }
    }

    @Nullable
    protected abstract Object determineCurrentLookupKey();

多数据源事务

在DynamicDataSourceAutoConfiguration会注入dynamicTransactionAdvisor，主要是拦截处理有DSTransactional注解的方法。

    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    @Bean
    @ConditionalOnProperty(prefix = DynamicDataSourceProperties.PREFIX, name = "seata", havingValue = "false", matchIfMissing = true)
    public Advisor dynamicTransactionAdvisor() {
        DynamicLocalTransactionInterceptor interceptor = new DynamicLocalTransactionInterceptor();
        return new DynamicDataSourceAnnotationAdvisor(interceptor, DSTransactional.class);
    }

DynamicLocalTransactionInterceptor，开启事务。

public class DynamicLocalTransactionInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        if (!StringUtils.isEmpty(TransactionContext.getXID())) {
            return methodInvocation.proceed();
        }
        boolean state = true;
        Object o;
        LocalTxUtil.startTransaction();
        try {
            o = methodInvocation.proceed();
        } catch (Exception e) {
            state = false;
            throw e;
        } finally {
            if (state) {
                LocalTxUtil.commit();
            } else {
                LocalTxUtil.rollback();
            }
        }
        return o;
    }
}

LocalTxUtil#startTransaction

    public static void startTransaction() {
        if (!StringUtils.isEmpty(TransactionContext.getXID())) {
            log.debug("dynamic-datasource exist local tx [{}]", TransactionContext.getXID());
        } else {
            String xid = UUID.randomUUID().toString();
            TransactionContext.bind(xid);
            log.debug("dynamic-datasource start local tx [{}]", xid);
        }
    }

AbstractRoutingDataSource#getConnection()，判断是否存在事务id，如果存在，则获取连接，并封装成ConnectionProxy。

    @Override
    public Connection getConnection() throws SQLException {
        String xid = TransactionContext.getXID();
        if (StringUtils.isEmpty(xid)) {
            return determineDataSource().getConnection();
        } else {
            String ds = DynamicDataSourceContextHolder.peek();
            ds = StringUtils.isEmpty(ds) ? "default" : ds;
            ConnectionProxy connection = ConnectionFactory.getConnection(ds);
            return connection == null ? getConnectionProxy(ds, determineDataSource().getConnection()) : connection;
        }
    }

    private Connection getConnectionProxy(String ds, Connection connection) {
        ConnectionProxy connectionProxy = new ConnectionProxy(connection, ds);
        ConnectionFactory.putConnection(ds, connectionProxy);
        return connectionProxy;
    }

ConnectionFactory#putConnection，存储到线程变量中的concurrentHashMap。

    public static void putConnection(String ds, ConnectionProxy connection) {
        Map<String, ConnectionProxy> concurrentHashMap = CONNECTION_HOLDER.get();
        if (!concurrentHashMap.containsKey(ds)) {
            try {
                connection.setAutoCommit(false);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            concurrentHashMap.put(ds, connection);
        }
    }

提交事务，LocalTxUtil#commit

    public static void commit() {
        ConnectionFactory.notify(true);
        log.debug("dynamic-datasource commit local tx [{}]", TransactionContext.getXID());
        TransactionContext.remove();
    }

ConnectionFactory#notify，对于线程变量中的连接全部处理（回滚或者提交），并清空线程变量。

    public static void notify(Boolean state) {
        try {
            Map<String, ConnectionProxy> concurrentHashMap = CONNECTION_HOLDER.get();
            for (ConnectionProxy connectionProxy : concurrentHashMap.values()) {
                connectionProxy.notify(state);
            }
        } finally {
            CONNECTION_HOLDER.remove();
        }
    }

配置文件加密

在DynamicDataSourceAutoConfiguration会注入EncDataSourceInitEvent

    @Bean
    @ConditionalOnMissingBean
    public DataSourceInitEvent dataSourceInitEvent() {
        return new EncDataSourceInitEvent();
    }

EncDataSourceInitEvent#beforeCreate，对加密的字符串进行解密

    @Override
    public void beforeCreate(DataSourceProperty dataSourceProperty) {
        String publicKey = dataSourceProperty.getPublicKey();
        if (StringUtils.hasText(publicKey)) {
            dataSourceProperty.setUrl(decrypt(publicKey, dataSourceProperty.getUrl()));
            dataSourceProperty.setUsername(decrypt(publicKey, dataSourceProperty.getUsername()));
            dataSourceProperty.setPassword(decrypt(publicKey, dataSourceProperty.getPassword()));
        }
    }

EncDataSourceInitEvent#decrypt，匹配正则表达式则进行解密。 Pattern ENC_PATTERN = Pattern.compile("^ENC\\((.*)\\)$");

    private String decrypt(String publicKey, String cipherText) {
        if (StringUtils.hasText(cipherText)) {
            Matcher matcher = ENC_PATTERN.matcher(cipherText);
            if (matcher.find()) {
                try {
                    return CryptoUtils.decrypt(publicKey, matcher.group(1));
                } catch (Exception e) {
                    log.error("DynamicDataSourceProperties.decrypt error ", e);
                }
            }
        }
        return cipherText;
    }

脚本执行器

AbstractDataSourceCreator#runScrip，用对应的数据源执行脚本

    private void runScrip(DataSource dataSource, DataSourceProperty dataSourceProperty) {
        DatasourceInitProperties initProperty = dataSourceProperty.getInit();
        String schema = initProperty.getSchema();
        String data = initProperty.getData();
        if (StringUtils.hasText(schema) || StringUtils.hasText(data)) {
            ScriptRunner scriptRunner = new ScriptRunner(initProperty.isContinueOnError(), initProperty.getSeparator());
            if (StringUtils.hasText(schema)) {
                scriptRunner.runScript(dataSource, schema);
            }
            if (StringUtils.hasText(data)) {
                scriptRunner.runScript(dataSource, data);
            }
        }
    }

主从插件

MasterSlaveAutoRoutingPlugin。当进行查询的时候，切换数据源SLAVE；当进行更新的时候，切换数据源，MASTER。

@Intercepts({
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
@Slf4j
public class MasterSlaveAutoRoutingPlugin implements Interceptor {

    @Autowired
    protected DataSource dynamicDataSource;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object[] args = invocation.getArgs();
        MappedStatement ms = (MappedStatement) args[0];
        String pushedDataSource = null;
        try {
            String dataSource = SqlCommandType.SELECT == ms.getSqlCommandType() ? DdConstants.SLAVE : DdConstants.MASTER;
            pushedDataSource = DynamicDataSourceContextHolder.push(dataSource);
            return invocation.proceed();
        } finally {
            if (pushedDataSource != null) {
                DynamicDataSourceContextHolder.poll();
            }
        }
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
    }
}

在这里插入图片描述

秋装什么
关注
专栏目录
Dynamic-Datasource：多数据源解决方案，轻松应对复杂业务场景
u013558123的博客
04-10 3286
Dynamic-Datasource作为一个多数据源解决方案，以其简单易用、灵活高效的特点，在应对复杂业务场景方面展现出了强大的能力。掌握Dynamic-Datasource的使用方法，将使您在开发过程中更加得心应手，轻松应对企业级应用的多数据源管理需求。
多数据源 - dynamic-datasource | 进阶 - 动态解析数据源
甘蓝的专栏
03-22 962
基于 SpringBoot 的多数据源实现 dynamic-datasource，实现动态解析数据源。
Dynamic-DataSource
05-15
dynamic-DataSource 利用AOP方式，实现动态数据源的切换
初识：DynamicDatasource动态数据源
m0_57623482的博客
09-09 878
主要是入门，认识DynamicDataSource的作用以及在其他maven如何运行的
dynamic-datasource源码分析
最新发布
younglg的博客
09-23 543
当多个数据源时要保证sql能到对应的数据库上，要求我们做到每一个不同数据源的sql都要拿到对应的数据源并获取相应数据库连接。只要你拿着数据源名称来，我根据名称提供给你数据源就好了，所以我们可以在路由类里维护一个Map集合，key为数据源名称，value为数据源。：通过自定义注解加切面，就可以拿到每个sql操作方法的所需数据源的名称，然后再去多数据源集合里取出对应的数据源。当从数据源拿数据库连接，就是调用DataSource接口的getConnection方法，dd实现了此方法。多数据源集合源码分析。
Dynamic DataSource 多数据源配置【 Springboot + DataSource + MyBatis Plus + Druid】
IT小郭的技术博客
10-23 9041
MybatisPlus多数据源配置主要解决的是多数据库连接和切换的问题。在一些大型应用中，由于数据量的增长或者业务模块的增多，可能需要访问多个数据库。这时，就需要配置多个数据源。
DynamicDatasource动态数据源实现及使用
努力提高技术水平
08-06 2506
baomidou开源的多数据源扩展插件DynamicDatasource使用及具体实现，附完整源码。
多数据源 - dynamic-datasource | 常见问题汇总
甘蓝的专栏
03-26 1474
基于 SpringBoot 的多数据源实现 dynamic-datasource 常见问题汇总。
芋道 Spring Boot 多数据源（读写分离）入门
芋艿V
04-06 906
点击上方“芋道源码”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2020 超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网...
Mybatis-Plus 新手入门，一篇足以
m0_65992672的博客
05-08 675
MyBatis-Plus.简介、入门案例、增删改查、BaseMapper、通用Service、IService、常用注解、@TableName、@TableId、@TbaleField、@TableLogic、条件构造器、QueryWrapper、UpdateWrapper、LambdaQueryWrapper、分页插件、乐观锁、通用枚举、代码生成器、多数据源、MyBatisX插件
Spring Boot 项目中的三种多数据源方案，一个比一个强！
芋艿V
07-21 434
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 8:55 更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2020 超神之路，很肝~...
dynamic-datasource.zip
08-19
dynamic-datasource.zip
DynamicDatasourceDemo
12-28
关于Spring动态使用多数据源，仅供参考。
dynamic-datasource-spring-boot-starter：springboot的动态数据源多数据源动态数据源主从分离读写分离分布式事务https：dynamic-datasource.com
01-30
一个基于springboot的快速集成多数据源的启动器 简介 dynamic-datasource-spring-boot-starter是一个基于springboot的快速集成多数据源的启动器。 其支持Jdk 1.7 +，SpringBoot 1.4.x 1.5.x 2.xx。 文件| 文献资料 | 特性 支持数据源分组，适用于多种场景纯粹的多库读写分离一主多从混合模式。 支持数据库敏感配置信息加密ENC（）。 支持每个数据库独立初始化表结构schema和数据库数据库。 支持自定义注解，需继承DS（3.2.0+）。 提供对德鲁伊，Mybatis-Plus，P6sy，Jndi的快速集成。 简化Druid和HikariCp配置，提供变量参数配置。配置一次，并行通用。 提供自定义数据源来源方案。 提供项目启动后动态增加可移除数据源方案。 提供Mybatis环境下的纯识读分离方案。 提供使用spel动态参数解析数据源方案。内置spel，会话，标题，支持自定义。 支持多层数据源嵌套切换。（ServiceA >>> ServiceB >>> ServiceC）。 提供对shiro，shardin
dynamic-datasource-spring-boot-starter-3.4.1-API文档-中英对照版.zip
05-04
赠送jar包：dynamic-datasource-spring-boot-starter-3.4.1.jar； 赠送原API文档：dynamic-datasource-spring-boot-starter-3.4.1-javadoc.jar； 赠送源代码：dynamic-datasource-spring-boot-starter-3.4.1-sources.jar； 赠送Maven依赖信息文件：dynamic-datasource-spring-boot-starter-3.4.1.pom； 包含翻译后的API文档：dynamic-datasource-spring-boot-starter-3.4.1-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：com.baomidou:dynamic-datasource-spring-boot-starter:3.4.1； 标签：spring、baomidou、starter、datasource、dynamic、boot、jar包、java、中英对照文档； 使用方法：解压翻译后的API文档，用浏览器打
Dynamic Datasource
weixin_46061449的博客
05-28 2412
Dynamic Datasource 实现多数据源，并动态切换
Dynamic-DataSource多数据源配置mybatis/mybatis-plus
qq_23095607的博客
09-25 5092
Dynamic-DataSource 可以和绝大多是连接层插件搭配使用，比如：mybatis,mybatis-plus,hibernate等如果公司不允许使用Dynamic-DataSource，可以参考上述视频进行原生代码的编写本示例仅讲就基本的使用（多数据源及事务），如果还需要更多功能，可参考上述官方文档进行编码。
dynamic-datasource动态数据源学习
pscool的博客
05-31 5548
dynamic-datasource-spring-boot-starter 是一个基于springboot的快速集成多数据源的启动器。其支持 Jdk 1.7+, SpringBoot 1.4.x 1.5.x 2.x.x。
使用数据库维护数据来源，动态切换数据源的工具：dynamic-datasource
wangxudongx的专栏
09-14 9519
dynamic-source是基于dynamic-datasource-spring-boot-starter 的一种工具，该工具是为了解决数据源动态切换而创建的。 **可采用数据库和配置文件维护数据源** **自动加载、移除数据源（数据来源为数据库方式）** **可以使用接口参数自动切换数据源** **同一数据源下切换schema（对于postgresql用的多）** **多层数据源嵌套切换使用方案** **自定义数据源切换逻辑**
dynamic-datasource-spring-boot-starter 实现多数据源
09-03
dynamic-datasource-spring-boot-starter 是一个用于在 Spring Boot 应用中实现多数据源的开源项目。它提供了简单易用的配置方式和强大的功能，让我们能够轻松地管理和切换多个数据源。 使用 dynamic-datasource-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值