springboot -- druid 多資料來源(根據mapp位置區分業務資料庫)

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

1.多資料來源切換：指專案所需要不止一個數據庫的連線資訊，eg：同一資料庫地址下的不同庫或者壓根連地址都不同。

專案中不同的業務需求儲存在不同的資料庫中。

如會員資訊---會員資料庫中

訂單資訊-- 訂單資料庫中。

多資料來源彼此切換，要求不同的mybatis例項的mapper對映目錄不能相同

如圖：

sql指令碼:

zhw-demo:
CREATE TABLE `cat_user` (
  `id` int(11) NOT NULL,
  `name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO `zhw-demo`.`cat_user`(`id`, `name`) VALUES (1, 'primary');


wss:

CREATE TABLE `cat_order` (
  `id` int(11) NOT NULL,
  `name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO `wss`.`cat_order`(`id`, `name`) VALUES (1, 'second');

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example.jdbc</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <!-- mybatis -->
        <mybatis.version>1.1.1</mybatis.version>
    </properties>

    <dependencies>

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

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

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

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

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.version}</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.3</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.22</version>
        </dependency>
    </dependencies>

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


</project>

2.application.properties配置

#Spring Boot 2.0後，一些配置及用法有了變化，如果不小心就會碰到“jdbcUrl is required with driverClassName.”的錯誤
#使用spring.datasource.jdbc-url，而不是通常使用的spring.datasource.url
#主庫
spring.datasource.one.jdbc-url=jdbc:mysql://123.206.206.156:3306/zhw-demo?useUnicode=true&characterEncoding=utf-8
spring.datasource.one.username=root
spring.datasource.one.password=maobc2018
spring.datasource.one.driver-class-name = com.mysql.jdbc.Driver
#從庫
spring.datasource.two.jdbc-url=jdbc:mysql://123.206.206.156:3306/wss?useUnicode=true&characterEncoding=utf-8
spring.datasource.two.username=root
spring.datasource.two.password=maobc2018
spring.datasource.two.driver-class-name = com.mysql.jdbc.Driver



#spring.datasource.type=com.example.jdbc.demo.config.MyDruidDataSource
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
spring.datasource.maxWait=60000
spring.datasource.timeBetweenEvictionRunsMillis=60000
spring.datasource.minEvictableIdleTimeMillis=30000
spring.datasource.validationQuery=select 'x'
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
spring.datasource.filters=stat,wall,logback
spring.datasource.initialSize=1
spring.datasource.minIdle=5
spring.datasource.maxActive=20

3.PrimaryDruidConfiguration

package com.example.jdbc.demo.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.example.jdbc.demo.utils.AesUtils;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
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.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;
import java.sql.SQLException;

@Configuration
@MapperScan(basePackages = "com.example.jdbc.demo.mapper.UserMapper", sqlSessionTemplateRef  = "oneSqlSessionTemplate")
public class PrimaryDruidConfiguration {
    @Value("${spring.datasource.one.jdbc-url}")
    private String dbUrl;
    @Value("${spring.datasource.one.username}")
    private String username;
    @Value("${spring.datasource.one.password}")
    private String password;
    @Value("${spring.datasource.one.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.initialSize}")
    private int initialSize;
    @Value("${spring.datasource.minIdle}")
    private int minIdle;
    @Value("${spring.datasource.maxActive}")
    private int maxActive;
    @Value("${spring.datasource.maxWait}")
    private int maxWait;
    @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;
    @Value("${spring.datasource.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;
    @Value("${spring.datasource.validationQuery}")
    private String validationQuery;
    @Value("${spring.datasource.testWhileIdle}")
    private boolean testWhileIdle;
    @Value("${spring.datasource.testOnBorrow}")
    private boolean testOnBorrow;
    @Value("${spring.datasource.testOnReturn}")
    private boolean testOnReturn;
    @Value("${spring.datasource.poolPreparedStatements}")
    private boolean poolPreparedStatements;
    @Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
    private int maxPoolPreparedStatementPerConnectionSize;
    @Value("${spring.datasource.filters}")
    private String filters;
    @Value("{spring.datasource.connectionProperties}")
    private String connectionProperties;

    @Bean(name = "oneDataSource")
    //@ConfigurationProperties(prefix = "spring.datasource.one")
    @Primary
    public DataSource customDataSource() {
        //return DataSourceBuilder.create().build();
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(this.dbUrl);
        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;
    }

    @Bean(name = "oneSqlSessionFactory")
    @Primary
    public SqlSessionFactory customSqlSessionFactory(@Qualifier("oneDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setTypeAliasesPackage("com.example.jdbc.demo.entity");
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/*.xml"));
        return bean.getObject();
    }

    @Bean(name = "oneTransactionManager")
    @Primary
    public DataSourceTransactionManager customTransactionManager(@Qualifier("oneDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "oneSqlSessionTemplate")
    @Primary
    public SqlSessionTemplate customSqlSessionTemplate(@Qualifier("oneSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

2.SecondDruidConfiguration

package com.example.jdbc.demo.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.example.jdbc.demo.utils.AesUtils;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;
import java.sql.SQLException;

@Configuration
@MapperScan(basePackages = "com.example.jdbc.demo.mapper.OrderMapper", sqlSessionTemplateRef  = "twoSqlSessionTemplate")
public class SecondDruidConfiguration{

    @Value("${spring.datasource.two.jdbc-url}")
    private String dbUrl;
    @Value("${spring.datasource.two.username}")
    private String username;
    @Value("${spring.datasource.two.password}")
    private String password;
    @Value("${spring.datasource.two.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.initialSize}")
    private int initialSize;
    @Value("${spring.datasource.minIdle}")
    private int minIdle;
    @Value("${spring.datasource.maxActive}")
    private int maxActive;
    @Value("${spring.datasource.maxWait}")
    private int maxWait;
    @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;
    @Value("${spring.datasource.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;
    @Value("${spring.datasource.validationQuery}")
    private String validationQuery;
    @Value("${spring.datasource.testWhileIdle}")
    private boolean testWhileIdle;
    @Value("${spring.datasource.testOnBorrow}")
    private boolean testOnBorrow;
    @Value("${spring.datasource.testOnReturn}")
    private boolean testOnReturn;
    @Value("${spring.datasource.poolPreparedStatements}")
    private boolean poolPreparedStatements;
    @Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
    private int maxPoolPreparedStatementPerConnectionSize;
    @Value("${spring.datasource.filters}")
    private String filters;
    @Value("{spring.datasource.connectionProperties}")
    private String connectionProperties;


    @Bean(name = "twoDataSource")
    //@ConfigurationProperties(prefix = "spring.datasource.two")
    public DataSource customDataSource() {
       // return DataSourceBuilder.create().build();
        //return DataSourceBuilder.create().build();
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(this.dbUrl);
        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;
    }

    @Bean(name = "twoSqlSessionFactory")
    public SqlSessionFactory customSqlSessionFactory(@Qualifier("twoDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setTypeAliasesPackage("com.example.jdbc.demo.entity");
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/*.xml"));
        return bean.getObject();
    }

    @Bean(name = "twoTransactionManager")
    public DataSourceTransactionManager customTransactionManager(@Qualifier("twoDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "twoSqlSessionTemplate")
    public SqlSessionTemplate customSqlSessionTemplate(@Qualifier("twoSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

4.OrderInfoMapper

package com.example.jdbc.demo.mapper.OrderMapper;

import com.example.jdbc.demo.entity.Order;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface OrderInfoMapper {
    List<Order> findOrderList();
}

5.UserInfoMapper

package com.example.jdbc.demo.mapper.UserMapper;

import com.example.jdbc.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface UserInfoMapper {

    List<User> findUserList();

}

6.OrderServiceImpl

import com.example.jdbc.demo.entity.Order;
import com.example.jdbc.demo.mapper.OrderMapper.OrderInfoMapper;
import com.example.jdbc.demo.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderInfoMapper orderMapper;


    @Override
    public List<Order> list() {
        return orderMapper.findOrderList();
    }
}

結果：

程式碼

springboot -- druid 多資料來源(根據mapp位置區分業務資料庫)

1.多資料來源切換：指專案所需要不止一個數據庫的連線資訊，eg：同一資料庫地址下的不同庫或者壓根連地址都不同。專案中不同的業務需求儲存在不同的資料庫中。如會員資訊---會員資料庫中訂單資訊-- 訂單資料庫中。多資料來源彼此切換，要求不同的mybatis例項的

springboot -- druid 多資料來源(註解版)

1.通過註解實現不同的資料庫彼此切換。 2.pom依賴： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot

springboot druid 多資料來源配置

由於工作當中，需要配置雙資料來源進行資料同步，以目錄進行區別主副庫的編寫。這裡記錄一下，方便大家。 1、pom配置 <dependency> <groupId>com.alibaba</groupId> <artif

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

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

SpringBoot配置多資料來源(druid)

分析 spring本身是支援多資料來源動態切換的，AbstractRoutingDataSource這個抽象類就是spring提供的一個數據源路由的一個入口，該抽象類暴露了一個determineCurrentLookupKey()的方法，該方法返回值是Object，該返回值作為key

springboot+mybatis+druid 多資料來源

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

springboot配置多資料來源並整合Druid

1.application.properties配置檔案 spring.datasource.type = com.alibaba.druid.pool.DruidDataSource #----DS1---- spring.datasource.primary.u

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

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

SpringBoot配置多資料來源（結合Druid）

在單資料來源的情況下，Spring Boot的配置非常簡單，只需要在application.properties檔案中配置連線引數即可。但是往往隨著業務量發展，我們通常會進行資料庫拆分或是引入其他資料庫，從而我們需要配置多個數據源，下面介紹多資料來源的配置方式。

springboot配置多資料來源之Spring Date JPA

多資料來源在專案開發中是經常遇到的，如果同一個專案的不同模組使用的是不同資料庫，就需要多資料來源的處理。現在先寫之前使用JPA的時候遇到多資料來源的配置，後續可能再來個關於mybatis的多資料來源配置。現在有這樣的需求，專案中有兩個模組，分別是flow與imap，flow需要使用預設資料

springboot配置多資料來源(MongoDB主從)

相信看過上一篇文章的小夥伴已經知道了，這章要講的就是MongoDB主從配置。在這邊文章中，你將要學到的是在專案中配置主從資料庫,並且相容其他資料庫喲。。這些都是博主專案中需要並且比較重要的知識哦~ 好了，廢話不多說，直接進主題。 1.pom依賴 <depende

springboot配置多資料來源(不同DB)

springBoot整合Mysql+MongoDB 因為在專案中需要用到兩個不同的資料來源。但是又不存在於一個DB中。讓我很是苦惱，不得已只能整合多資料來源。博主文筆不好，只能講乾貨了。。目標：使用springBoot整合mys

實現SpringBoot的多資料來源配置

【場景】當業務資料量達到了一定程度，DBA 需要合理配置資料庫資源。即配置主庫的機器高配置，把核心高頻的資料放在主庫上；把次要的資料放在從庫，低配置。 –（引自 https://www.cnblogs.com/Alandre/p/6611813.html 泥瓦匠BYSocket

springboot+mybatis多資料來源配置，AOP註解動態切換資料來源

轉載至：https://blog.csdn.net/xiaosheng_papa/article/details/80218006 親測有效。注：有些系統中已經配置了單資料來源，現在要轉成多資料來源，可能需要額外的配置。拿我自己當前專案來說：專案在啟動類中配置了單資料來源：

SpringBoot整合多資料來源

多資料來源就是連線多個數據庫 1、在application.properties中配置兩個資料庫 spring.datasource.driverClassName=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:

基於SpirngBoot2.0+ 的 SpringBoot+Mybatis 多資料來源配置

Github 地址：github.com/Snailclimb/…(SpringBoot和其他常用技術的整合,可能是你遇到的講解最詳細的學習案例,力爭新手也能看懂並且能夠在看完之後獨立實踐。基於最新的 SpringBoot2.0+，是你學習SpringBoot 的最佳指南。) ，歡迎各位 Star。

新手也能看懂，基於SpirngBoot2.0+ 的 SpringBoot+Mybatis 多資料來源配置

Github 地址：https://github.com/Snailclimb/springboot-integration-examples(SpringBoot和其他常用技術的整合,可能是你遇到的講解最詳細的學習案例,力爭新手也能看懂並且能夠在看完之後獨立實踐。基於最新的 S

Spring Boot MyBatis配置Druid多資料來源（附原始碼）

Spring Boot MyBatis配置Druid多資料來源回顧在Spring中配置MyBatis SqlSessionFactory的配置：  <bean id="sqlSessionF

Mybatis（攔截器實現）通用mapper及全ORM實現（五）-- springboot+mybatis多資料來源設定

本篇實際上和mybatisext專案並沒有太大關係了，但在實際專案中脫離不開多個數據源，尤其是主從分離，同樣網上一些資料大同小異而且大部分並不能真正解決問題，所以單獨提出來說一下假設我們就是要解決一個主從分離，資料來源定義在了application.properties中

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

簡單實現了根據註解動態切換資料來源，支援同一個資料庫的宣告式事務，但不支援JTA事務。處理流程：根據配置的資料來源資訊，建立動態資料來源bean 利用DataSourceAspect處理@DataSource註解，設定當前要使用的具體資料來源 pom.xm

springboot -- druid 多資料來源(根據mapp位置區分業務資料庫)

相關推薦