2. 程式人生 > >SpringBoot+Mybatis+Druid動態多資料來源

SpringBoot+Mybatis+Druid動態多資料來源

阿新 • • 發佈：2018-12-15

背景

前兩天突然想起了，咕泡老師寫的原始碼中有關於多資料來源的實現。翻出來看了看，想移植到springboot裡面去，可是移動過去，不起作用，而後又百度了些大神做法，還是不起作用，故自己研究了一番，最終實現了mybatis的動態資料來源。水平有限，還請大佬輕噴，希望能和各位大佬多多交流。

配置多資料來源

application.yml配置：

#
spring:
  datasource:
     type: com.alibaba.druid.pool.DruidDataSource
     url: jdbc:mysql://127.0.0.1:3306/test_db?useUnicode=true&characterEncoding=utf8
     username: root
     password: root
     driver-class-name: com.mysql.jdbc.Driver
     initialSize: 1
     minIdle: 1
     maxActive: 200
     maxWait: 60000
     timeBetweenEvictionRunsMillis: 60000
     minEvictableIdleTimeMillis: 300000
     validationQuery: SELECT 'x'
     testWhileIdle: true
     testOnBorrow: false
     testOnReturn: false
     poolPreparedStatements: false
     maxPoolPreparedStatementPerConnectionSize: 20
     filters: stat,log4j,wall
     connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
     useGlobalDataSourceStat: true
  datasource2:
       type: com.alibaba.druid.pool.DruidDataSource
       url: jdbc:mysql://127.0.0.1:3306/db_test3?useUnicode=true&characterEncoding=utf8
       username: root
       password: root
       driver-class-name: com.mysql.jdbc.Driver
       initialSize: 1
       minIdle: 1
       maxActive: 200
       maxWait: 60000
       timeBetweenEvictionRunsMillis: 60000
       minEvictableIdleTimeMillis: 300000
       validationQuery: SELECT 'x'
       testWhileIdle: true
       testOnBorrow: false
       testOnReturn: false
       poolPreparedStatements: false
       maxPoolPreparedStatementPerConnectionSize: 20
       filters: stat,log4j,wall
       connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
       useGlobalDataSourceStat: true
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.liulei.study.xmlbatisboot.domain
default:
  dataSource: dataSource1

我這裡配置了兩個mysql資料來源。配置bean，dataSource1 如下：

import com.alibaba.druid.pool.DruidDataSource;
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;
import java.sql.SQLException;

//解決 spring.datasource.filters=stat,wall,log4j 無法正常註冊進去
@Configuration
@ConfigurationProperties(prefix = "spring.datasource")
public class IDataSource1 {
    private String url;
    private String username;
    private String password;
    private String driverClassName;
    private int initialSize;
    private int minIdle;
    private int maxActive;
    private int maxWait;
    private int timeBetweenEvictionRunsMillis;
    private int minEvictableIdleTimeMillis;
    private String validationQuery;
    private boolean testWhileIdle;
    private boolean testOnBorrow;
    private boolean testOnReturn;
    private boolean poolPreparedStatements;
    private int maxPoolPreparedStatementPerConnectionSize;
    private String filters;
    private String connectionProperties;
    private boolean useGlobalDataSourceStat;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public int getInitialSize() {
        return initialSize;
    }

    public void setInitialSize(int initialSize) {
        this.initialSize = initialSize;
    }

    public int getMinIdle() {
        return minIdle;
    }

    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }

    public int getMaxActive() {
        return maxActive;
    }

    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }

    public int getMaxWait() {
        return maxWait;
    }

    public void setMaxWait(int maxWait) {
        this.maxWait = maxWait;
    }

    public int getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }

    public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }

    public int getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }

    public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }

    public String getValidationQuery() {
        return validationQuery;
    }

    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }

    public boolean isTestWhileIdle() {
        return testWhileIdle;
    }

    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }

    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }

    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }

    public boolean isTestOnReturn() {
        return testOnReturn;
    }

    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }

    public boolean isPoolPreparedStatements() {
        return poolPreparedStatements;
    }

    public void setPoolPreparedStatements(boolean poolPreparedStatements) {
        this.poolPreparedStatements = poolPreparedStatements;
    }

    public int getMaxPoolPreparedStatementPerConnectionSize() {
        return maxPoolPreparedStatementPerConnectionSize;
    }

    public void setMaxPoolPreparedStatementPerConnectionSize(int maxPoolPreparedStatementPerConnectionSize) {
        this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
    }

    public String getFilters() {
        return filters;
    }

    public void setFilters(String filters) {
        this.filters = filters;
    }

    public String getConnectionProperties() {
        return connectionProperties;
    }

    public void setConnectionProperties(String connectionProperties) {
        this.connectionProperties = connectionProperties;
    }

    public boolean isUseGlobalDataSourceStat() {
        return useGlobalDataSourceStat;
    }

    public void setUseGlobalDataSourceStat(boolean useGlobalDataSourceStat) {
        this.useGlobalDataSourceStat = useGlobalDataSourceStat;
    }

    @Bean(name="dataSource1") //宣告其為Bean例項
    public DataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);

//configuration
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            System.err.println("druid configuration initialization filter: " + e);
        }
        datasource.setConnectionProperties(connectionProperties);
        return datasource;
    }
}

dataSource2 如下：


import com.alibaba.druid.pool.DruidDataSource;
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;
import java.sql.SQLException;

//解決 spring.datasource.filters=stat,wall,log4j 無法正常註冊進去
@Configuration
@ConfigurationProperties(prefix = "spring.datasource2")
public class IDataSource2 {
    private String url;
    private String username;
    private String password;
    private String driverClassName;
    private int initialSize;
    private int minIdle;
    private int maxActive;
    private int maxWait;
    private int timeBetweenEvictionRunsMillis;
    private int minEvictableIdleTimeMillis;
    private String validationQuery;
    private boolean testWhileIdle;
    private boolean testOnBorrow;
    private boolean testOnReturn;
    private boolean poolPreparedStatements;
    private int maxPoolPreparedStatementPerConnectionSize;
    private String filters;
    private String connectionProperties;
    private boolean useGlobalDataSourceStat;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public int getInitialSize() {
        return initialSize;
    }

    public void setInitialSize(int initialSize) {
        this.initialSize = initialSize;
    }

    public int getMinIdle() {
        return minIdle;
    }

    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }

    public int getMaxActive() {
        return maxActive;
    }

    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }

    public int getMaxWait() {
        return maxWait;
    }

    public void setMaxWait(int maxWait) {
        this.maxWait = maxWait;
    }

    public int getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }

    public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }

    public int getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }

    public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }

    public String getValidationQuery() {
        return validationQuery;
    }

    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }

    public boolean isTestWhileIdle() {
        return testWhileIdle;
    }

    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }

    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }

    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }

    public boolean isTestOnReturn() {
        return testOnReturn;
    }

    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }

    public boolean isPoolPreparedStatements() {
        return poolPreparedStatements;
    }

    public void setPoolPreparedStatements(boolean poolPreparedStatements) {
        this.poolPreparedStatements = poolPreparedStatements;
    }

    public int getMaxPoolPreparedStatementPerConnectionSize() {
        return maxPoolPreparedStatementPerConnectionSize;
    }

    public void setMaxPoolPreparedStatementPerConnectionSize(int maxPoolPreparedStatementPerConnectionSize) {
        this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
    }

    public String getFilters() {
        return filters;
    }

    public void setFilters(String filters) {
        this.filters = filters;
    }

    public String getConnectionProperties() {
        return connectionProperties;
    }

    public void setConnectionProperties(String connectionProperties) {
        this.connectionProperties = connectionProperties;
    }

    public boolean isUseGlobalDataSourceStat() {
        return useGlobalDataSourceStat;
    }

    public void setUseGlobalDataSourceStat(boolean useGlobalDataSourceStat) {
        this.useGlobalDataSourceStat = useGlobalDataSourceStat;
    }

    @Bean(name="dataSource2") //宣告其為Bean例項
    public DataSource dataSource2() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);

//configuration
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            System.err.println("druid configuration initialization filter: " + e);
        }
        datasource.setConnectionProperties(connectionProperties);
        return datasource;
    }
}

配置SqlSessionFactory

實際上對於Mybatis來說，可以省略這個配置，springboot會預設建立，但是這裡為了後面操作的方便性，自己配置一個SqlSessionFactory:


import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import javax.sql.DataSource;

@Configuration
@MapperScan("com.liulei.study.xmlbatisboot.dao")
public class MybatisSqlSessionFactoryConfig {
    @Autowired
    @Qualifier("dataSource1")
    private DataSource dataSource1;

    @Value("${mybatis.mapper-locations}")
    private Resource[] mapperLocations;
    @Value("${mybatis.type-aliases-package}")
    private String typeAliasesPackage;

    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource1); //
        factoryBean.setMapperLocations(mapperLocations);
        factoryBean.setTypeAliasesPackage(typeAliasesPackage);
        return factoryBean.getObject();

    }
}

建立DataSourceHelper輔助類，動態切換資料來源


import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
@Component
public class DataSourceHelper implements InitializingBean,ApplicationContextAware {

    private ApplicationContext applicationContext;
    private static Map<String,Environment> Environments;
    private static Configuration configuration;
    private SqlSessionFactory sqlSessionFactory;
    @Override
    public void afterPropertiesSet() throws Exception {

        //獲取所有資料來源
        Map<String, DataSource> dataSources = applicationContext.getBeansOfType(DataSource.class);
        sqlSessionFactory = applicationContext.getBean(SqlSessionFactory.class);
        //獲取sqlSessionFactory的configuration
        configuration = sqlSessionFactory.getConfiguration();
        Environment environment;
        if(Environments==null){
            Environments=new HashMap<String,Environment>(dataSources.size());
        }
        for (Map.Entry<String, DataSource> entry : dataSources.entrySet()) {
            environment=new Environment(SqlSessionFactoryBean.class.getSimpleName(),
                    new SpringManagedTransactionFactory(),entry.getValue());
            //初始化所有資料來源的environment，便於之後切換資料來源使用
            Environments.put(entry.getKey(),environment);
        }
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext=applicationContext;
    }

    public static void setSqlSessionFactoryEnvironment(String dsName){
        //切換Mybatis的Environment
        configuration.setEnvironment(Environments.get(dsName));
    }

}

有必要說一下，這裡實現了InitializingBean，和ApplicationContextAware介面，實現的目的不多說，不明白的朋友請自行學習spring。並且這裡@Component註解不可少，這和單純使用spring有區別。 另外afterPropertiesSet方法裡，最終的目的是初始化Environment 的Map集合，待之後使用。

使用DataSourceHelper，實現動態切換資料來源


@RestController
@RequestMapping("/test")
@EnableTransactionManagement
public class TestController {

    @Autowired
    private PersonService personService;
    @RequestMapping("/getPersonById")
    public <T> T getPersonById(@RequestParam String id){
        return (T)personService.getPersonById(id);
    }
    @RequestMapping("/insert")
    public int insertPerson(){
        Person person;
        for(int age=28;age<33;age++){
            person = new Person();
            person.setId("sdfdf");
            person.setName("adsfdf");
            person.setAddress("adsfdf");
            person.setAge(age);
            if(age<30)
                //這裡做了切換資料來源
                DataSourceHelper.setSqlSessionFactoryEnvironment("dataSource2");
            else
                //這裡做了切換資料來源
                DataSourceHelper.setSqlSessionFactoryEnvironment("dataSource1");
            personService.insertPerson(person);

        }
        return 0;
    }
}

這裡只需要呼叫 DataSourceHelper.setSqlSessionFactoryEnvironment(“dataSource2”)方法即可實現切換資料來源，省略mapper.xml和PersonService的程式碼。但是這樣做不太方便。故有了下面的aop的方式。

Aop的方式動態切換資料來源

首先，定義註解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface DS {
    String value() default "dataSource1";
}

然後，定義Aop

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.aspectj.lang.reflect.MethodSignature;

import java.lang.reflect.Method;

@Aspect
@Component
public class DynamicDataSourceAspect {
    @Value("${default.dataSource}")
    private String DEFAULT_SOURCE;
    @Before("@annotation(DS)")
    public void beforeSwitchDS(JoinPoint point){
        //獲得當前訪問的class
        Class<?> className = point.getTarget().getClass();
        //獲得訪問的方法名
        String methodName = point.getSignature().getName();
        //得到方法的引數的型別
        Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
        String dataSource = DEFAULT_SOURCE;
        try {
            // 得到訪問的方法物件
            Method method = className.getMethod(methodName, argClass);
            // 判斷是否存在@DS註解
            if (method.isAnnotationPresent(DS.class)) {
                DS annotation = method.getAnnotation(DS.class);
                // 取出註解中的資料來源名
                dataSource = annotation.value();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 切換資料來源
        DataSourceHelper.setSqlSessionFactoryEnvironment(dataSource);
    }

    /*@After("@annotation(DS)")
    public void afterSwitchDS(JoinPoint point) {
        DataSourceHelper.setSqlSessionFactoryEnvironment(DEFAULT_SOURCE);
    }*/
}

這裡註釋了@After("@annotation(DS)這一部分，如果有需要，可以開啟註釋，做一些其他的操作。 然後使用方法:


@Service
@Transactional
public class PersonService {
    @Autowired
    private PersonMapper personMapper;

    public Person getPersonById(String id){

       return personMapper.getPersonById(id);

    }
    @DS("dataSource2")
    public int insertPerson(Person person){

        return personMapper.insertPerson(person);
    }
}

只需要加上註解就可以指定，該操作的資料來源了。

總結

本篇所實現的切換資料來源的方式，仍然侵入到了mybatis中去，並不是很好的做法，但是沒辦法繼承AbstractRoutingDataSource類的方法，不管用。所以我閱讀了一下mybatis的原始碼，找到了這種方法，如果哪位大佬有更好的方法，請不吝賜教，大家互相學習，共同進步。

專案git地址： https://github.com/Lewis-Liulei/springboot.git 裡面commo包下的類並沒有使用到，DynamicDataSource類和DynamicDataSourceEntry類可以刪掉。

相關推薦

SpringBoot+Mybatis+Druid動態多資料來源

背景 前兩天突然想起了，咕泡老師寫的原始碼中有關於多資料來源的實現。翻出來看了看，想移植到springboot裡面去，可是移動過去，不起作用，而後又百度了些大神做法，還是不起作用，故自己研究了一番，最終實現了mybatis的動態資料來源。水平有限，還請大佬輕噴，

springboot+mybatis+druid實現多資料來源配置，支援註解和xml兩種sql書寫方式

https://github.com/cheegoday/springboot-demo-djg 要點： 一、依次建立以下幾個Bean 資料來源：DataSource session工廠：SqlSessionFactory 執行緒安全session：Sql

全程解析，MyBatis在SpringBoot中的動態多資料來源配置

在分庫的業務場景和跨資料庫例項獲取資訊之類的場景中，我們會遇到處理多個數據源訪問的問題，**通常情況下可以採用中介軟體**，如cobar, tddl, mycat等。 但取決於業務需求，有時我們需要直接通過MyBatis和SpringData來完成這個任務。即使沒有，**理解MyBatis多資料來源配置的過

springboot+mybatis實現動態切換資料來源

前幾天有個需求，需要使用不同的資料來源，例如某業務要用A資料來源，另一個業務要用B資料來源。我上網收集了一些資料整合了一下，雖然最後這個需求不了了之了，但是多資料來源動態切換還是蠻好用的，所以記錄一下，或許以後有用呢？或者自己感興趣又想玩呢！ 1.加個依賴 <dependency>

SpringBoot + Mybatis + Druid 配置雙資料來源

SpringBoot + Mybatis + Druid 配置雙資料來源(IDEA) 為了防止自己以後踩坑，做個筆記，記錄一下. 在做這個雙資料來源的時候，真的讓人頭痛，網上的資料都不全，那些各種各樣的部落格，基本上都一樣，而且寫的遮遮掩掩的。看的很讓人頭痛。這一次自己做完後，也來記錄一下，試試看能不能寫

springboot+Mybatis配置實現多資料來源

簡述 應公司需求，結合網上的許多資料和公司專案配置實現多資料來源。在此記錄一下配置過程，以供大家參考。 專案簡介 框架用的是SpringBoot+Mybatis，初始資料庫是MySQL，具體MySQL的整合在這裡不做詳細說明，要求是新增一個Oracle

SpringBoot + Mybatis plus 實現多資料來源整合

SpringBoot 版本為1.5.10.RELEASE，Mybatis plus 版本為2.1.8。 第一步：填寫配置資訊： spring: aop: proxy-target-class: true auto: true

springboot+mybatis+druid 多資料來源整合

       前言：在上一篇文章裡面我們進行了spring boot 和 mybatis 的整合 《springboot整合mybatis使用druid資料來源》, 文中是使用的單資料來源，因為專案中有很多需要用到多資料來源的場景，比如主從同步（讀寫分離）

Spring Boot + Mybatis + Druid 動態切換多資料來源

在大型應用程式中，配置主從資料庫並使用讀寫分離是常見的設計模式。 在Spring應用程式中，要實現讀寫分離，最好不要對現有程式碼進行改動，而是在底層透明地支援。 這樣，就需要我們再一個專案中，配置兩個，乃至多個數據源。 今天，小編先來介紹一下自己配置動態多資料來源的步驟 專案簡介： 　　編譯器：ID

springboot+mybatis+druid 多資料來源

Druid介紹和使用 在使用Druid之前，先來簡單的瞭解下Druid。 Druid是一個數據庫連線池。Druid可以說是目前最好的資料庫連線池！因其優秀的功能、效能和擴充套件性方面，深受開發人員的青睞。 Druid已經在阿里巴巴部署了超過600個應用，經過一年多生產環境大規模部署的嚴苛考驗

SpringBoot+Mybatis+ Druid+PageHelper 實現多資料來源並分頁

前言 本篇文章主要講述的是SpringBoot整合Mybatis、Druid和PageHelper 並實現多資料來源和分頁。其中SpringBoot整合Mybatis這塊，在之前的的一篇文章中已經講述了，這裡就不過多說明了。重點是講述在多資料來源下的如何配置使用Druid和PageHelper 。 Druid

SpringBoot+mybatis+Druid多資料來源切換

1. 配置application.properties #primary db spring.datasource.primary.url=jdbc:mysql://127.0.0.1:3306/master?characterEncoding=utf-8

SpringBoot整合Mybatis動態多資料來源後，MybatisPlus的IPage失效的問題解決方案

背景 之前做資料抽取的時候，搭了一個mybatis動態資料來源切換的架子。方便他們寫抽取的程式碼。今天同事問我，架子裡面的mybatisplus的IPage失效了是什麼問題。想了一下，應該是寫動態資料來源的時候，我自定義的mybatis的配置覆蓋了已有的配置。於是我讓他先把我寫的配置進行刪除，看是否正常。得到

springboot使用mybatis如何配置多資料來源

本篇部落格提供一個工程想連線多個數據庫進行業務查詢，在原先的單個數據庫上進行配置實現多個數據庫的使用，對於springboot以及mybatis不在此進行展開介紹，只需要把程式碼按照步驟一步步貼上進你的專案，調整一下就能實現； 簡單介紹單個數據源配置 pom檔案匯入依賴 <

springboot 動態多資料來源事務

由於近期專案要對資料庫進行劃分成多個數據庫，從當一的資料庫，根據業務進行劃分多個數據庫，所以使用動態路由+aop來實現資料庫的動態切換，當是其中有一個重要的問題，就是事務要怎麼解決，比如在一個service中對其他業務資料庫進行查詢，修改，新增，會出現資料來源不會進行切換的問

SpringBoot學習筆記---配置多資料來源（Mybatis ）

介紹 為什麼配置多資料來源，因為在實際業務需求中 資料的來源可能不是一個數據庫中可進行配置兩套資料來源就可以避免跨庫查詢 pom檔案需要引入的依賴 <dependency> <groupId>org.mybatis.spring.boot</gr

SpringBoot+Mybatis 實現動態資料來源切換方案

背景 最近讓我做一個大資料的系統，分析了一下，麻煩的地方就是多資料來源切換抽取資料。考慮到可以跨伺服器跨資料庫抽數，再整理資料，就配置了這個動態資料來源的解決方案。在此分享給大家。 實現方案 資料庫配置檔案 我們專案使用的是yml形式的配置檔案，採用的是hikari的資料庫連線池。第一步我們自然是配置多個數據

springboot + mybatis +druid

ima eth hid time col sele ons getname uid Druid Spring Boot Starter mybatis-spring-boot-autoconfigure 新建spring boot工程，添加pom依賴 <depen

springboot+mybatis實現動態切換數據源

nbsp targe key component mybatis run 註解 config cte 前幾天有個需求，需要使用不同的數據源，例如某業務要用A數據源，另一個業務要用B數據源。我上網收集了一些資料整合了一下，雖然最後這個需求不了了之了，但是多數據源動態切換還是蠻

SpringBoot+Mybatis+ Druid+PageHelper 實現多數據源並分頁

utf 重置數據 count system 配置文件 urn 規模 pos mapper 前言 本篇文章主要講述的是SpringBoot整合Mybatis、Druid和PageHelper 並實現多數據源和分頁。其中SpringBoot整合Mybatis這塊，在之前的的一篇