Spring boot 配置多数据源并使用连接池管理- mysql

最新推荐文章于 2024-09-30 11:02:27 发布
置顶 最新推荐文章于 2024-09-30 11:02:27 发布
阅读量1.7k 收藏 6
点赞数 1
分类专栏： java mysql 文章标签： 配置多数据源 java spring
原文链接：https://blog.csdn.net/mao502010435/article/details/99238858
版权
1、搭建springboot项目，项目目录如下：

在这里插入图片描述

2.部分配置源码如下，yml配置：
spring:
  datasource:
    #使用druid连接池
    type: com.alibaba.druid.pool.DruidDataSource
# 自定义的主数据源配置信息
primary:
  datasource:
    #druid相关配置
    druid:
      #监控统计拦截的filters
      filters: stat
      driverClassName: com.mysql.jdbc.Driver
      #配置基本属性
      url: jdbc:mysql://127.0.0.1:3306/test2?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&autoReconnect=true&useSSL=false
      username: root
      password: 12311
      #配置初始化大小/最小/最大
      initialSize: 1
      minIdle: 1
      maxActive: 10
      #获取连接等待超时时间
      maxWait: 60000
      #间隔多久进行一次检测，检测需要关闭的空闲连接
      timeBetweenEvictionRunsMillis: 60000
      #一个连接在池中最小生存的时间
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 'x'
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      #打开PSCache，并指定每个连接上PSCache的大小。oracle设为true，mysql设为false。分库分表较多推荐设置为false
      poolPreparedStatements: false
      maxPoolPreparedStatementPerConnectionSize: 10
 
# 自定义的从数据源配置信息
back:
  datasource:
    #druid相关配置
    druid:
      #监控统计拦截的filters
      filters: stat
      driverClassName: com.mysql.jdbc.Driver
      #配置基本属性
      url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&autoReconnect=true&useSSL=false
      username: root
      password: 12311
      #配置初始化大小/最小/最大
      initialSize: 1
      minIdle: 1
      maxActive: 10
      #获取连接等待超时时间
      maxWait: 60000
      #间隔多久进行一次检测，检测需要关闭的空闲连接
      timeBetweenEvictionRunsMillis: 60000
      #一个连接在池中最小生存的时间
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 'x'
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      #打开PSCache，并指定每个连接上PSCache的大小。oracle设为true，mysql设为false。分库分表较多推荐设置为false
      poolPreparedStatements: false
      maxPoolPreparedStatementPerConnectionSize: 10
 
# 自定义的从数据源配置信息
hive:
  datasource:
    #druid相关配置
    druid:
      #监控统计拦截的filters
      filters: stat
      driverClassName: org.apache.hive.jdbc.HiveDriver
      #配置基本属性
      url: jdbc:hive2://192.168.159.206:10000/eshop
      username: root
      password: 12311
      #配置初始化大小/最小/最大
      initialSize: 1
      minIdle: 1
      maxActive: 10
      #获取连接等待超时时间
      maxWait: 60000
      #间隔多久进行一次检测，检测需要关闭的空闲连接
      timeBetweenEvictionRunsMillis: 60000
      #一个连接在池中最小生存的时间
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 'x'
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      #打开PSCache，并指定每个连接上PSCache的大小。oracle设为true，mysql设为false。分库分表较多推荐设置为false
      poolPreparedStatements: false
      maxPoolPreparedStatementPerConnectionSize: 10
  namenodes: hdfs://192.168.159.206:8020
es:
  clusterName: elasticsearch
  clientTransportSniff: ture
  port: 9300
  hostname: 127.0.0.1
mysql主库配置文件：
package com.mao.mysqlhive.demomh.config;
 
import com.alibaba.druid.pool.DruidDataSource;
import lombok.Data;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
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 org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
 
import javax.sql.DataSource;
import java.sql.SQLException;
 
/**
 * @Description: 主数据源配置类
 * 前缀为primary.datasource.druid的配置信息
 */
@Data
@Configuration
@ConfigurationProperties(prefix = "primary.datasource.druid")
@MapperScan(basePackages = PrimaryDataBaseConfig.PACKAGE, sqlSessionFactoryRef = "primarySqlSessionFactory")
public class PrimaryDataBaseConfig {
 
    /**
     * dao层的包路径
     */
    static final String PACKAGE = "com.mao.mysqlhive.demomh.mapper.primary";
 
    /**
     * mapper文件的相对路径
     */
    private static final String MAPPER_LOCATION = "classpath:mappers/primary/*Mapper.xml";
 
    @Value("${back.datasource.druid.filters}")
    private String filters;
    @Value("${primary.datasource.druid.driverClassName}")
    private String url;
    @Value("${primary.datasource.druid.url}")
    private String username;
    @Value("${primary.datasource.druid.username}")
    private String password;
    @Value("${primary.datasource.druid.password}")
    private String driverClassName;
    @Value("${primary.datasource.druid.initialSize}")
    private int initialSize;
    @Value("${primary.datasource.druid.minIdle}")
    private int minIdle;
    @Value("${primary.datasource.druid.maxActive}")
    private int maxActive;
    @Value("${primary.datasource.druid.maxWait}")
    private long maxWait;
    @Value("${primary.datasource.druid.timeBetweenEvictionRunsMillis}")
    private long timeBetweenEvictionRunsMillis;
    @Value("${primary.datasource.druid.minEvictableIdleTimeMillis}")
    private long minEvictableIdleTimeMillis;
    @Value("${primary.datasource.druid.validationQuery}")
    private String validationQuery;
    @Value("${primary.datasource.druid.testWhileIdle}")
    private boolean testWhileIdle;
    @Value("${primary.datasource.druid.testOnBorrow}")
    private boolean testOnBorrow;
    @Value("${primary.datasource.druid.testOnReturn}")
    private boolean testOnReturn;
    @Value("${primary.datasource.druid.poolPreparedStatements}")
    private boolean poolPreparedStatements;
    @Value("${primary.datasource.druid.maxPoolPreparedStatementPerConnectionSize}")
    private int maxPoolPreparedStatementPerConnectionSize;
 
    /**
     * 主数据源使用@Primary注解进行标识
     */
 
    @Primary
    @Bean(name = "primaryDataSource")
    public DataSource primaryDataSource() throws SQLException {
        DruidDataSource druid = new DruidDataSource();
        // 监控统计拦截的filters
        druid.setFilters(filters);
 
        // 配置基本属性
        druid.setDriverClassName(driverClassName);
        druid.setUsername(username);
        druid.setPassword(password);
        druid.setUrl(url);
 
        //初始化时建立物理连接的个数
        druid.setInitialSize(initialSize);
        //最大连接池数量
        druid.setMaxActive(maxActive);
        //最小连接池数量
        druid.setMinIdle(minIdle);
        //获取连接时最大等待时间，单位毫秒。
        druid.setMaxWait(maxWait);
        //间隔多久进行一次检测，检测需要关闭的空闲连接
        druid.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        //一个连接在池中最小生存的时间
        druid.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        //用来检测连接是否有效的sql
        druid.setValidationQuery(validationQuery);
        //建议配置为true，不影响性能，并且保证安全性。
        druid.setTestWhileIdle(testWhileIdle);
        //申请连接时执行validationQuery检测连接是否有效
        druid.setTestOnBorrow(testOnBorrow);
        druid.setTestOnReturn(testOnReturn);
        //是否缓存preparedStatement，也就是PSCache，oracle设为true，mysql设为false。分库分表较多推荐设置为false
        druid.setPoolPreparedStatements(poolPreparedStatements);
        // 打开PSCache时，指定每个连接上PSCache的大小
        druid.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
 
        return druid;
    }
 
    /**
     * 创建该数据源的事务管理
     */
    @Primary
    @Bean(name = "primaryTransactionManager")
    public DataSourceTransactionManager primaryTransactionManager() throws SQLException {
        return new DataSourceTransactionManager(primaryDataSource());
    }
 
    /**
     * 创建Mybatis的连接会话工厂实例
     */
    @Primary
    @Bean(name = "primarySqlSessionFactory")
    public SqlSessionFactory primarySqlSessionFactory(@Qualifier("primaryDataSource") DataSource primaryDataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(primaryDataSource);  // 设置数据源bean
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(PrimaryDataBaseConfig.MAPPER_LOCATION));  // 设置mapper文件路径
 
        return sessionFactory.getObject();
    }
}
mysql从库配置文件：
package com.mao.mysqlhive.demomh.config;
 
import com.alibaba.druid.pool.DruidDataSource;
import lombok.Data;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
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.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;
 
/**
 * @ProjectName
 * @Description: 后台数据源配置类
 */
@Data
@Configuration
@ConfigurationProperties(prefix = "back.datasource.druid")
@MapperScan(basePackages = BackDataBaseConfig.PACKAGE, sqlSessionFactoryRef = "backSqlSessionFactory")
public class BackDataBaseConfig {
    /**
     * dao层的包路径
     */
    static final String PACKAGE = "com.mao.mysqlhive.demomh.mapper.back";
 
    /**
     * mapper文件的相对路径
     */
    private static final String MAPPER_LOCATION = "classpath:mappers/back/*Mapper.xml";
 
    @Value("${back.datasource.druid.filters}")
    private String filters;
    @Value("${back.datasource.druid.driverClassName}")
    private String url;
    @Value("${back.datasource.druid.url}")
    private String username;
    @Value("${back.datasource.druid.username}")
    private String password;
    @Value("${back.datasource.druid.password}")
    private String driverClassName;
    @Value("${back.datasource.druid.initialSize}")
    private int initialSize;
    @Value("${back.datasource.druid.minIdle}")
    private int minIdle;
    @Value("${back.datasource.druid.maxActive}")
    private int maxActive;
    @Value("${back.datasource.druid.maxWait}")
    private long maxWait;
    @Value("${back.datasource.druid.timeBetweenEvictionRunsMillis}")
    private long timeBetweenEvictionRunsMillis;
    @Value("${back.datasource.druid.minEvictableIdleTimeMillis}")
    private long minEvictableIdleTimeMillis;
    @Value("${back.datasource.druid.validationQuery}")
    private String validationQuery;
    @Value("${back.datasource.druid.testWhileIdle}")
    private boolean testWhileIdle;
    @Value("${back.datasource.druid.testOnBorrow}")
    private boolean testOnBorrow;
    @Value("${back.datasource.druid.testOnReturn}")
    private boolean testOnReturn;
    @Value("${back.datasource.druid.poolPreparedStatements}")
    private boolean poolPreparedStatements;
    @Value("${back.datasource.druid.maxPoolPreparedStatementPerConnectionSize}")
    private int maxPoolPreparedStatementPerConnectionSize;
 
 
    @Bean(name = "backDataSource")
    public DataSource backDataSource() throws SQLException {
        DruidDataSource druid = new DruidDataSource();
        // 监控统计拦截的filters
        druid.setFilters(filters);
 
        // 配置基本属性
        druid.setDriverClassName(driverClassName);
        druid.setUsername(username);
        druid.setPassword(password);
        druid.setUrl(url);
 
        //初始化时建立物理连接的个数
        druid.setInitialSize(initialSize);
        //最大连接池数量
        druid.setMaxActive(maxActive);
        //最小连接池数量
        druid.setMinIdle(minIdle);
        //获取连接时最大等待时间，单位毫秒。
        druid.setMaxWait(maxWait);
        //间隔多久进行一次检测，检测需要关闭的空闲连接
        druid.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        //一个连接在池中最小生存的时间
        druid.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        //用来检测连接是否有效的sql
        druid.setValidationQuery(validationQuery);
        //建议配置为true，不影响性能，并且保证安全性。
        druid.setTestWhileIdle(testWhileIdle);
        //申请连接时执行validationQuery检测连接是否有效
        druid.setTestOnBorrow(testOnBorrow);
        druid.setTestOnReturn(testOnReturn);
        //是否缓存preparedStatement，也就是PSCache，oracle设为true，mysql设为false。分库分表较多推荐设置为false
        druid.setPoolPreparedStatements(poolPreparedStatements);
        // 打开PSCache时，指定每个连接上PSCache的大小
        druid.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        return druid;
    }
 
    @Bean(name = "backTransactionManager")
    public DataSourceTransactionManager backTransactionManager() throws SQLException {
        return new DataSourceTransactionManager(backDataSource());
    }
 
    @Bean(name = "backSqlSessionFactory")
    public SqlSessionFactory backSqlSessionFactory(@Qualifier("backDataSource") DataSource backDataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(backDataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(BackDataBaseConfig.MAPPER_LOCATION));
 
        return sessionFactory.getObject();
    }
}
mysql数据库如下：
#test:
-- ----------------------------
-- Table structure for account
-- ----------------------------
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `money` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Records of account
-- ----------------------------
INSERT INTO `account` VALUES ('1', 'tom', '10');
 
 
#test2:
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'tom', '12');
INSERT INTO `user` VALUES ('2', 'jonn', '13');
其他的如目录所见，与单数据源使用方法相同，此处不再赘述
Spring Boot入门(20)：使用Mybatis-plus实现Spring Boot多数据源配置，轻松实现数据库读写分离！
**My Coding Family**
08-22 1万+
如何实现多数据源的配置及项目使用，此文教会你，超级简单，开箱即用。
【项目实战】SpringBoot的数据源配置
本本本添哥
08-14 1755
在SpringBoot项目中，可以通过配置一个数据源来提供数据的访问和管理。SpringBoot提供了许多数据源的配置方式，如使用Spring Data JPA、Mybatis等框架来配置数据源。
springboot+mybatis多数据源+动态数据源配置(连接池)
09-09
springboot+mybatis多数据源+动态数据源配置(连接池),mysql数据库，代码实现了简单的读写分离，但是不建议这种操作，建议使用数据库中间件进行读写分离，例如使用mycat进行读写分离主从热备，使用该代码对于多个mycat集群资源进行多数据源动态访问
Spring Boot 配置Druid数据源
热门推荐
u012809062的博客
05-18 1万+
Druid是阿里巴巴开源平台上的一个项目,整个项目由数据库连接池、插件框架和SQL解析器组成。添加Druid数据源要使用Druid数据源，我们需要在 application.properties 下添加配置信息#数据库访问配置 #mysql #spring.datasource.type=com.alibaba.druid.pool.DruidDataSource #spring.datasourc
详解 JDBC和连接池
最新发布
lllsure的博客
09-30 1649
JDBC连接、预处理、批处理、JDBCUtils 工具类、ApDBUtils工具类、Druid（德鲁伊）、C3P0、BasicDAO
SpringBoot多数据源配置
代码蒋的博客
05-30 4794
保存了所有可能的数据源，key为数据库的key，value为DataSource对象或字符串形式的连接信息：保存了默认的数据源，用于找不到具体的数据源时使用方法：解析targetDataSources数据源信息成<key,DataSource>的形式，保存在Map<Object, DataSource> resolvedDataSources中将defaultTargetDataSource中的默认数据源信息解析成 DataSource对象保存在中。
springboot数据源配置
qq_17859117的博客
12-20 401
【代码】springboot数据源配置。
SpringBoot 之数据源配置
const_
07-23 1万+
文章目录市面上的几种数据源比对SpringBoot自动装配DataSource原理Hikari 数据源配置Druid 数据源配置配置参数详解配置 Druid 数据源参数配置 Druid 后台管理 Servlet 和 监控 FilterSpringBoot集成Druid连接池数据源 c3p0 并集成 mybatisDruid 多数据源配置 springboot2.0整合druid，以及springboot自动装配DataSource原理 市面上的几种数据源比对 常用的数据库连接池： C3P0、DBCP、Dru
Spring boot 配置多数据源并使用连接池管理 - mysql - hive
mthinking
08-11 4548
1、搭建springboot项目，项目目录如下： 2.部分配置源码如下，不想自己配置的小伙伴可以直接去github下载，github地址：github项目地址： yml配置： spring: datasource: #使用druid连接池 type: com.alibaba.druid.pool.DruidDataSource # 自定义的主数据源配置信息 prim...
spring boot配置MySQL数据库连接、Hikari连接池和Mybatis的简单配置方法
08-27
Spring Boot 配置 MySQL 数据库连接、Hikari 连接池和 MyBatis 的简单配置方法 Spring Boot 是一个基于 Java 的框架，用于快速构建生产级别的应用程序。作为一个现代化的框架，Spring Boot 提供了许多便捷的配置...
springboot-AOP实现多数据源动态切换（Druid连接池）
12-25
该技术的关键在于如何在同一个应用中配置和使用多个数据源，以及如何在运行时根据上下文动态切换数据源。本知识点将围绕使用Spring AOP和Druid连接池来实现这一目标进行详细说明。 首先，要实现多数据源动态切换，...
解决spring boot 1.5.4 配置多数据源的问题
08-30
在Spring Boot 1.5.4中，配置多数据源是为了实现应用程序与多个数据库之间的交互。这在处理分布式系统、主从数据库分离或不同数据库类型的应用场景中非常常见。下面将详细介绍如何解决Spring Boot 1.5.4中配置多数据...
springboot2.x 多数据源
05-28
1、完善连接池参数实现，调整了参数配置文件的配置，采用数组方式兼容yml文件 2、支持为每个数据源分别配置连接池参数 3、注解 @TargetDataSource 更名为 @DataSource 4、支持类级别、方法级别、参数级别的动态数据源 5、将注解使用范围下沉到更接近SQL的 Mapper 层，可以完全避免在Service层因为嵌套调用使用不当导致的数据源冲突或不生效问题 6、支持自定义SQL的数据源切换，兼容通用Mapper内置各种的方法的数据源切换 7、对PageHeader分页使用无影响
springboot多数据源配置
07-28
springboot多数据源配置
SpringBoot配置数据源
qq_33266200的博客
12-10 265
使用SpringBoot默认数据源 在resource下创建application.yml文件 在下面添加以下配置 spring: datasource: type: com.zaxxer.hikari.HikariDataSource driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/db_foodie?serverTimezone=UTC&charac
SpringBoot中关于数据源的相关配置
yu的博客
03-22 471
注解引入内部的限制条件类，检测容器中是否已经存在池化数据源（PooledDataSource），若不存在，通过@Import 注解引入 EmbeddedDataSourceConfiguration 类来向容器中添加一个内嵌的数据源（DataSource），若存在，则 EmbeddedDatabaseConfiguration 不能被实例化。用来检测容器中是否已经存在池化数据源的，若存在，可以向容器中添加池化数据源。PooledDataSourceConfiguration：池化数据源配置。
springboot配置数据源
yf_1018的博客
12-07 8075
Spring Framework 为 SQL 数据库提供了广泛的支持。从直接使用 JdbcTemplate 进行 JDBC 访问到完全的对象关系映射（object relational mapping）技术，比如 Hibernate。Spring Data 提供了更多级别的功能，直接从接口创建的 Repository 实现，并使用了约定从方法名生成查询。
springboot之数据源配置
星星都没我亮的博客
10-29 688
文章目录1、JDBC2、自定义数据源DruidDataSource3、springboot配置多数据源并动态切换4、springboot整合mybatis ​ Spring Framework 为 SQL 数据库提供了广泛的支持。从直接使用 JdbcTemplate 进行 JDBC 访问到完全的对象关系映射（object relational mapping）技术，比如 Hibernate。Spring Data 提供了更多级别的功能，直接从接口创建的 Repository 实现，并使用了约定从方法名生成
Spring Boot 1.5.4快速配置多数据源教程
"在Spring Boot 1.5.4版本中，配置多数据源变得更为便捷。传统的多数据源配置可能需要自定义大量代码，但在Spring Boot的支持下，我们可以通过简单的配置文件来实现这一功能。本文将介绍如何在Spring Boot项目中配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值