SpringBoot+druid多数据源

最新推荐文章于 2024-08-15 21:36:29 发布
最新推荐文章于 2024-08-15 21:36:29 发布
阅读量137 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pingpei1133/article/details/96155234
版权

开始

项目开发中存在不止一个数据库的情况，需要用到多数据源配置，进行相关业务开发。

实现方式

使用方式与单个druid配置相同

pom

1
2
3
4
5

 <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.14</version>
</dependency>

配置文件

application配置

#第一个数据配置
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai

# 连接池指定 springboot版本默认使用HikariCP 此处要替换成Druid
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

## 初始化连接池的连接数量 大小，最小，最大
spring.datasource.druid.initial-size=1
spring.datasource.druid.min-idle=1
spring.datasource.druid.max-active=20
## 配置获取连接等待超时的时间
spring.datasource.druid.max-wait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.druid.time-between-eviction-runs-millis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.druid.min-evictable-idle-time-millis=300000
spring.datasource.druid.validation-query=SELECT 'x'
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
spring.datasource.druid.filter.stat.log-slow-sql=true
# 是否缓存preparedStatement，也就是PSCache  官方建议MySQL下建议关闭   个人建议如果想用SQL防火墙 建议打开
spring.datasource.druid.pool-prepared-statements=false
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
spring.datasource.druid.filters=stat,wall
spring.datasource.druid.test-while-idle=true
#Spring监控，对内部各接口调用的监控
spring.datasource.druid.aop-patterns=com.felix.project.controller.*,com.felix.project.mapper.*,com.felix.project.service.*

# 第二个数据库配置
spring.datasource.felix.username=root
spring.datasource.felix.password=root
spring.datasource.felix.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.felix.url=jdbc:mysql://localhost:3306/test1?characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
# 连接池指定 springboot版本默认使用HikariCP 此处要替换成Druid
spring.datasource.felix.type=com.alibaba.druid.pool.DruidDataSource
## 初始化连接池的连接数量 大小，最小，最大
spring.datasource.felix.druid.initial-size=1
spring.datasource.felix.druid.min-idle=1
spring.datasource.felix.druid.max-active=20
## 配置获取连接等待超时的时间
spring.datasource.felix.druid.max-wait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.felix.druid.time-between-eviction-runs-millis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.felix.druid.min-evictable-idle-time-millis=300000
spring.datasource.felix.druid.validation-query=SELECT 'x'
spring.datasource.felix.druid.test-on-borrow=false
spring.datasource.felix.druid.test-on-return=false
spring.datasource.felix.druid.filter.stat.log-slow-sql=true
# 是否缓存preparedStatement，也就是PSCache  官方建议MySQL下建议关闭   个人建议如果想用SQL防火墙 建议打开
spring.datasource.felix.druid.pool-prepared-statements=false
spring.datasource.felix.druid.max-pool-prepared-statement-per-connection-size=20
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
spring.datasource.felix.druid.filters=stat,wall
spring.datasource.felix.druid.test-while-idle=true
#Spring监控，对内部各接口调用的监控
spring.datasource.felix.druid.aop-patterns=com.felix.project.controller.*,com.felix.project.mapper.*,com.felix.project.service.*


mybatis.mapper-locations=classpath:mapper/*.xml,classpath:mapper2/*.xml
mybatis.type-aliases-package=com.felix.project.model
mapper.not-empty=false
mapper.identity=MYSQL

yml 配置文件相类似

第一个config类

新建两个druid配置,采用手动配置的方式，避免druid不能监控到SQL
第一个配置文件

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
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 tk.mybatis.spring.annotation.MapperScan;

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

@Configuration
@MapperScan(basePackages ="com.felix.project.mapper", sqlSessionFactoryRef = "masterSqlSessionFactory")
public class DruidConfig {

    @Value("${spring.datasource.url}")
    private String url;
    @Value("${spring.datasource.username}")
    private String username;
    @Value("${spring.datasource.password}")
    private String password;
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.druid.initial-size}")
    private int initialSize;
    @Value("${spring.datasource.druid.min-idle}")
    private int minIdle;
    @Value("${spring.datasource.druid.max-active}")
    private int maxActive;
    @Value("${spring.datasource.druid.max-wait}")
    private int maxWait;
    @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
    private int timeBetweenEvictionRunsMillis;
    @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
    private int minEvictableIdleTimeMillis;
    @Value("${spring.datasource.druid.validation-query}")
    private String validationQuery;
    @Value("${spring.datasource.druid.test-while-idle}")
    private boolean testWhileIdle;
    @Value("${spring.datasource.druid.test-on-borrow}")
    private boolean testOnBorrow;
    @Value("${spring.datasource.druid.test-on-return}")
    private boolean testOnReturn;
    @Value("${spring.datasource.druid.pool-prepared-statements}")
    private boolean poolPreparedStatements;
    @Value("${spring.datasource.druid.max-pool-prepared-statement-per-connection-size}")
    private int maxPoolPreparedStatementPerConnectionSize;
    @Value("${spring.datasource.druid.filters}")
    private String filters;
    @Value("${spring.datasource.druid.aop-patterns}")
    private String[] aopPatterns;
    /**
     * 创建数据源
     *
     * @return DataSource
     */
    @Bean(name = "masterDataSource")
    @Primary
    public DataSource masterDataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);
        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);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return datasource;
    }

    // 创建该数据源的事务管理
    @Primary
    @Bean(name = "primaryTransactionManager")
    public DataSourceTransactionManager primaryTransactionManager() throws SQLException {
        return new DataSourceTransactionManager(masterDataSource());
    }

    // 创建Mybatis的连接会话工厂实例
    @Primary
    @Bean(name = "masterSqlSessionFactory")
    public SqlSessionFactory primarySqlSessionFactory(@Qualifier("masterDataSource") DataSource primaryDataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(primaryDataSource);  // 设置数据源bean
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/*.xml"));  // 设置mapper文件路径
        return sessionFactory.getObject();
    }
}

第二config类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

package com.felix.project.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
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.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import tk.mybatis.spring.annotation.MapperScan;

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

@Configuration
@MapperScan(basePackages ="com.felix.project.mapper2",sqlSessionFactoryRef = "secondSqlSessionFactory")
public class DruidFelicConfig {

    @Value("${spring.datasource.felix.url}")
    private String url;
    @Value("${spring.datasource.felix.username}")
    private String username;
    @Value("${spring.datasource.felix.password}")
    private String password;
    @Value("${spring.datasource.felix.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.felix.druid.initial-size}")
    private int initialSize;
    @Value("${spring.datasource.felix.druid.min-idle}")
    private int minIdle;
    @Value("${spring.datasource.felix.druid.max-active}")
    private int maxActive;
    @Value("${spring.datasource.felix.druid.max-wait}")
    private int maxWait;
    @Value("${spring.datasource.felix.druid.time-between-eviction-runs-millis}")
    private int timeBetweenEvictionRunsMillis;
    @Value("${spring.datasource.felix.druid.min-evictable-idle-time-millis}")
    private int minEvictableIdleTimeMillis;
    @Value("${spring.datasource.felix.druid.validation-query}")
    private String validationQuery;
    @Value("${spring.datasource.felix.druid.test-while-idle}")
    private boolean testWhileIdle;
    @Value("${spring.datasource.felix.druid.test-on-borrow}")
    private boolean testOnBorrow;
    @Value("${spring.datasource.felix.druid.test-on-return}")
    private boolean testOnReturn;
    @Value("${spring.datasource.felix.druid.pool-prepared-statements}")
    private boolean poolPreparedStatements;
    @Value("${spring.datasource.felix.druid.max-pool-prepared-statement-per-connection-size}")
    private int maxPoolPreparedStatementPerConnectionSize;
    @Value("${spring.datasource.felix.druid.filters}")
    private String filters;
    @Value("${spring.datasource.felix.druid.aop-patterns}")
    private String[] aopPatterns;

    /**
     *  DataSource
     * @return
     */
    @Bean(name = "secondDataSource")
    public DataSource secondDataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);
        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);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return datasource;
    }

    // 创建该数据源的事务管理
    @Bean(name = "secondTransactionManager")
    public DataSourceTransactionManager secondTransactionManager() throws SQLException {
        return new DataSourceTransactionManager(secondDataSource());
    }

    // 创建Mybatis的连接会话工厂实例
    @Bean(name = "secondSqlSessionFactory")
    public SqlSessionFactory secondSqlSessionFactory(@Qualifier("secondDataSource") DataSource primaryDataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(primaryDataSource);  // 设置数据源bean
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/*.xml"));  // 设置mapper文件路径
        return sessionFactory.getObject();
    }
}

两配置文件基本相同，主要区别在与主配置需要加上@Primary注解

监控

新建一个DruidMoniterConfig配置项用于开启druid监控

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package com.felix.project.config;

import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DruidMoniterConfig {
    @Bean
    @ConditionalOnMissingBean
    public ServletRegistrationBean druidServlet() {
        ServletRegistrationBean servletRegistrationBean =
                new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        //白名单
        // servletRegistrationBean.addInitParameter("allow","192.168.6.195");
        //IP黑名单(存在共同时，deny优先于allow) : 如果满足deny的话提示:Sorry, you are not permitted to view this page.
        //  servletRegistrationBean.addInitParameter("deny","192.168.6.73");
        //用于登陆的账号密码
        servletRegistrationBean.addInitParameter("loginUsername", "admin");
        servletRegistrationBean.addInitParameter("loginPassword", "admin");
        //是否能重置数据
        servletRegistrationBean.addInitParameter("resetEnable", "false");
        return servletRegistrationBean;
    }

    @Bean
    @ConditionalOnMissingBean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
        //添加过滤规则.
        filterRegistrationBean.addUrlPatterns("/*");
        //添加不需要忽略的格式信息.
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return filterRegistrationBean;
    }

}

登录

Snipaste_2019-03-15_17-01-48.jpguploading.4e448015.gif转存失败重新上传取消druid

Snipaste_2019-03-15_17-05-09.jpguploading.4e448015.gif转存失败重新上传取消druid
Snipaste_2019-03-15_17-05-47.jpguploading.4e448015.gif转存失败重新上传取消druid

查询数据库验证

Snipaste_2019-03-15_17-21-20.jpguploading.4e448015.gif转存失败重新上传取消druid

参考

https://www.cnblogs.com/qdhxhz/p/10192041.html

Jim pretty
关注
springboot druid 多数据源demo
12-05
springboot开发,使用阿里druid-spring-boot-starter包,配置的多数据源demo,可自由加入多个数据源
SpringBoot多数据源druid
qq_15592789的博客
04-28 643
SpringBoot多数据源druid依赖引入数据源和druid的配置druid的servlet和filter设置代码多语言切换注解枚举数据源AOP 代码创建dataSource的Bean对象自定义DynamicDataSource设置数据源注解的有效范围效果源码AbstractRoutingDataSource类 依赖引入 主要包含JDBC、mysql、druid(需要logj4d的依赖)、aop(多数据源选择时需要切面) <dependency> <groupI
springBoot+ druid配置多数据源
最新发布
darlene2929的博客
08-15 764
里面有3个类，分别：DruidConfigFirst ，DruidConfigSecond ，TwoDataSourceConfig。dao 里面分开对应mysql的Mapper，oracle的Mapper。springBoot+ druid配置多数据源。应用：正常注入就行，他会自己去对应数据库。2.新建一个config文件。
springboot+druid+多数据源
qq_38491310的博客
07-30 466
这样的博客有很多了，我只是在此记录一下我遇到的问题，如果可以帮助到你，那就很开心了。 本篇文章的重点不是多数据源，而是在多数据源的情况下如何整合阿里的cruid。 1. 配置文件(applications.properties文件) 坑0：我是从Hikari数据源改写到cruid，Hikari的jdbc的url配置项名称是jdbc-url，而cruid直接就是url 坑1：filters这个配置项...
Springboot+druid+多数据源
fonjames的专栏
05-30 1624
1.在Spring Boot中配置两个不同的Oracle数据源，你需要在配置类中分别定义两个数据源，并使用AbstractRoutingDataSource来路由到不同的数据源。当然，如果你的应用需要配置多个Druid数据源，并且每个数据源的密码都需要通过自定义的解密方法解密，你可以扩展上面的配置方法以适应多数据源的场景。这样，每次调用到数据源的地方，都会根据你的逻辑动态切换到不同的数据源。3. 使用多数据源在业务代码中，你可以通过@DS注解器来指定使用特定的数据源，或者不指定时使用默认的数据源。
Springboot+mybatis+druid多数据源配置（oracle+mybatis）
07-29
总结，Spring Boot结合Mybatis和Druid实现多数据源配置的过程包括：配置数据源、配置Mybatis、创建数据源切换器、以及针对不同数据库的测试。这一过程涉及了Spring Boot的自动配置、依赖注入、配置属性绑定等多个...
Springboot+Mybatis+Druid多数据源配置
01-14
本教程将围绕"Springboot+Mybatis+Druid多数据源配置"这一主题，详细介绍如何实现这一功能。 首先，Spring Boot简化了Spring应用的初始化和配置。在多数据源场景下，我们可以通过Spring Boot的@...
通过springboot+mybatis+druid配置动态数据源
08-25
通过 SpringBoot、MyBatis 和 Druid 配置动态数据源是一种常见的解决方案，它可以帮助开发者轻松地管理多个数据源，并提供了动态切换数据源的能力。在本文中，我们将通过示例代码详细介绍如何使用 SpringBoot、...
SpringBoot+druid+多数据源示例
12-25
通过以上步骤，我们就完成了SpringBoot+Druid+多数据源的配置。在实际项目中，还可以进一步完善数据源切换策略，例如通过AOP切面来自动切换数据源，或者使用更复杂的路由规则，以满足复杂业务场景的需求。 这个`...
SpringBoot+Mybatis+Druid+PageHelper实现多数据源并分页方法
08-26
在本文中，我们将深入探讨如何使用SpringBoot、Mybatis、Druid和PageHelper来实现多数据源和分页功能。首先，SpringBoot是基于Spring框架的简化版本，它旨在简化微服务开发，提供了自动配置、内嵌式Web服务器以及...
Springboot整合Druid与Mybatis的多数据源切换
10-17
踩坑实录 亲测可用的springboot 整合mybatis druid 多数据源切换方案 使用注解方式更加灵活
SpringBoot + Druid配置多数据源
u010529525的博客
09-15 334
/** * 配置多数据源 */ @Configuration public class DynamicDataSourceConfig { @Bean(name = "firstDataSource") @ConfigurationProperties("spring.datasource.druid.first") public DataSource firstDataSource() { return DruidDataSourceBuilder.crea.
Spring Boot+Druid多数据源配置
weixin_34015336的博客
01-14 1701
依赖版本 Spring Boot：1.5.18 druid-spring-boot-starter：1.1.10 参考文档 druid-spring-boot-starter pom配置 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns...
springboot+druid+mybatis 多数据源
ye7785812的专栏
06-29 327
1：在pom文件中引入druid jar包 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>${druid.version}</version> </dep
SpringBoot 整合 druid（多数据源）
日有寸进
04-05 1012
步骤一 pom.xml 引入依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.0.26</version> </dependency> <depe...
springboot多数据源配置-使用druid配置多数据源
Samurai77的博客
10-16 250
Service层代码 @DataSource(value = MultiDataSourceConst.SLAVE) public List<User> getUserList() { List<User> userList = userRepository.findAll(); return userList; } app...
spring boot使用druid多数据源配置
异世者的博客
06-24 4075
在实际项目中，尤其是复杂系统，往往需要连接多个数据源，实现多数据库读写，这时就需要配置多数据源连接，而Spring Boot整合MybatisPlus实现多数据源有两种方式：分包 和 AOP。习惯问题，这里讲的是分包方式实现，借用网上的一张图说明很清晰了： 本文在已经配置好mybatisPlus和druid的前提下增加为多数据源的，不清楚可以参考前面的文章 数据源配置 properties.xml中设置两个数据源，假设这里的数据库分别为mickey和tianji spring.datasour
Springboot整合Mybatis实现Druid多数据源
wolf909867753的专栏
06-29 9307
本例将采用maven管理，代码托管在github上，地址：https://github.com/wolf909867753/springboot。 1。创建maven-module，mybatis-mutil-datasource,并在pom.xml中添加springboot依赖 project xmlns="http://maven.apache.org/POM/4.0.0" x
SpringBoot+Mybatis+Druid动态数据源配置实战
"通过springboot+mybatis+druid配置动态数据源" 在现代企业级应用中，经常需要处理多个数据库，比如分离读写操作、分布式系统或是多租户环境。在这种情况下，动态数据源的配置变得至关重要。本教程将详细讲解如何在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值