SpringBoot数据源的配置

最新推荐文章于 2024-03-19 14:32:57 发布
原创 最新推荐文章于 2024-03-19 14:32:57 发布 · 329 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Spring配置数据源

本文详细介绍了SpringBoot中单一及多数据源的配置方法，包括传统Java配置、注入方式和更优雅的松散绑定配置。同时，深入探讨了动态数据源的实现，通过AOP在不同数据源间切换，实现读写分离。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

SpringBoot数据源的配置

一、单一数据源三种配置方式

1.传统Java配置

  1. 创建jdbc.properties文件

    jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/hahaha
jdbc.username=root
jdbc.password=a123456

  2. 编写代码读取配置文件

    package com.ihaha.config;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import javax.sql.DataSource;
/**
 * @author: Aaron
 * @Date: 2018/12/1 16:56
 */
@Configuration
@PropertySource("classpath:application.properties")
public class ConfigureOne {
    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;
    @Bean
    public DataSource datasource(){
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setPassword(password);
        dataSource.setJdbcUrl(url);
        dataSource.setUsername(username);
        dataSource.setDriverClassName(driverClassName);
        return dataSource;
    }
}
2.springboot注入方式

  1. 新建一个类，用于属性注入

    package com.ihaha.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
 * @author: Aaron
 * @Date: 2018/12/1 17:07
 */
@Data
@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;
}

  2. 通过@EnableConfigurationProperties注解，使用上面的属性

    package com.ihaha.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
/**
 *@author: Aaron
 *@Date: 2018/12/1 17:15
 */

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {
    @Bean
    public DataSource getDatasource(JdbcProperties jdbc){
        DruidDataSource dataSource = new DruidDataSource ();
        dataSource.setPassword(jdbc.getPassword());
        dataSource.setUrl(jdbc.getUrl());
        dataSource.setUsername(jdbc.getUsername());
        dataSource.setDriverClassName(jdbc.getDriverClassName());
        return dataSource;
    }
}
3.更加优雅的注入

直接通过@ConfigurationProperties松散绑定：

package com.ihaha.config;
import com.alibaba.druid.pool.DruidDataSource;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
/**
 * @author: Aaron
 * @Date: 2018/12/1 16:44
 */
@Configuration
public class DataBaseConfig {
    @Bean
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}

二、多数据源的配置

业务需求：项目需要同时连接两个不同的数据库A, B，并且它们都为主从架构，一台写库，多台读库。

首先禁掉spring boot自带的DataSourceAutoConfiguration，因为它会读取application.properties文件的spring.datasource.*属性并自动配置单数据源。在@SpringBootApplication注解中添加exclude属性即可：

package com.ihaha;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
/**
 * @author: Aaron
 * @Date: 2018/12/1 15:57
 */
@SpringBootApplication(exclude = {
        DataSourceAutoConfiguration.class
})
public class IhahaApplication {
    public static void main(String[] args) {
        SpringApplication.run(IhahaApplication.class);

    }
}
1.配置文件
# A库
spring.datasource.demoa.url=jdbc:mysql://localhost:3306/demoa
spring.datasource.demoa.username=root
spring.datasource.demoa.password=a123456
spring.datasource.demoa.driver-class-name=com.mysql.jdbc.Driver
# 省略
# 其它库
spring.datasource.demob.url=jdbc:mysql://localhost:3306/demob
spring.datasource.demob.username=root
spring.datasource.demob.password=a123456
spring.datasource.demob.driver-class-name=com.mysql.jdbc.Driver
2.手动创建数据源
package com.ihaha.config;
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 javax.sql.DataSource;
/**
 * @author: Aaron
 * @Date: 2018/12/1 21:37
 */
@Configuration
public class ManyDatasource {
    //创建第一个数据库连接池
    @Bean(name="datasourceA")
    @ConfigurationProperties(prefix = "spring.datasource.demoa")
    public DataSource getDatasourceA(){
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
    //创建第二个数据库连接池
    @Bean(name="datasourceB")
    @ConfigurationProperties(prefix = "spring.datasource.demob")
    public DataSource getDatasourceB(){
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
}
3.配置SqlSessionFactory
package com.ihaha.config;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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 tk.mybatis.spring.annotation.MapperScan;
import javax.sql.DataSource;
/**
 * @author: Aaron
 * @Date: 2018/12/1 21:30
 */
@Configuration
@MapperScan(basePackages = {"com.ihaha.mapper.datasourceA"}, sqlSessionFactoryRef = "sqlSessionFactory1")
public class MybatisDbAConfig {
    @Autowired
    @Qualifier("datasourceA")
    private DataSource datasourceA;
    
    @Bean(name = "sqlSessionFactory1")
    @Primary
    public SqlSessionFactory sqlSessionFactory1() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(datasourceA);
        factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/demoA/*.xml"));
        return factoryBean.getObject();

    }
    
    @Bean
    @Primary
    public SqlSessionTemplate sqlSessionTemplate1() throws Exception {
        // 使用上面配置的Factory
        SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory1());
        return template;
    }
}

同理，配置datasourceA的SQLSessionFactory，注意，这里有一个坑，就是如果不配置：

factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/demoA/*.xml"));

报异常：Invalid bound statement (not found)！

找了一上午的Bug，终于搞定！

三、动态数据源

使用动态数据源的初衷，是能在应用层做到读写分离，即在程序代码中控制不同的查询方法去连接不同的库。除了这种方法以外，数据库中间件也是个不错的选择，它的优点是数据库集群对应用来说只暴露为单库，不需要切换数据源的代码逻辑。

1.定义一个ContextHolder
package com.ihaha.config.dynamic;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * @author: Aaron
 * @Date: 2018/12/2 16:52
 */
public class DataSourceContextHolder {

    public static final Logger log = LoggerFactory.getLogger(DataSourceContextHolder.class);
    /**
     * 默认数据源
     */
    public static final String DEFAULT_DS = "datasourceA";
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
    
    // 设置数据源名
    public static void setDB(String dbType) {
        log.debug("切换到{}数据源", dbType);
        contextHolder.set(dbType);
    }
    
    // 获取数据源名
    public static String getDB() {
        return (contextHolder.get());
    }
    
    // 清除数据源名
    public static void clearDB() {
        contextHolder.remove();
    }
}
2.自定义一个DataSource
package com.ihaha.config.dynamic;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.stereotype.Component;
/**
 * @author: Aaron
 * @Date: 2018/12/2 16:59
 */
@Component
public class DynamicDataSource extends AbstractRoutingDataSource {

    private static final Logger log = LoggerFactory.getLogger(DynamicDataSource.class);
    @Override
    protected Object determineCurrentLookupKey() {

        log.debug("数据源为{}", DataSourceContextHolder.getDB());

        return DataSourceContextHolder.getDB();
    }

}
3.创建动态数据源
package com.ihaha.config;
import com.alibaba.druid.pool.DruidDataSource;
import com.ihaha.config.dynamic.DynamicDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * @author: Aaron
 * @Date: 2018/12/1 21:37
 */
@Configuration
public class ManyDatasource {
    //创建第一个数据库连接池
    @Bean(name="datasourceA")
    @ConfigurationProperties(prefix = "spring.datasource.demoa")
    public DataSource getDatasourceA(){
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
    //创建第二个数据库连接池
    @Bean(name="datasourceB")
    @ConfigurationProperties(prefix = "spring.datasource.demob")
    public DataSource getDatasourceB(){
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }

    /**
     * 动态数据源: 通过AOP在不同数据源之间动态切换
     * @return
     */
    @Bean(name = "dynamicDataSource")
    public DataSource getDynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        // 默认数据源
        dynamicDataSource.setDefaultTargetDataSource(getDatasourceA());
        // 配置多数据源
        Map<Object, Object> dsMap = new HashMap(5);
        dsMap.put("datasourceA", getDatasourceA());
        dsMap.put("datasourceB", getDatasourceB());

        dynamicDataSource.setTargetDataSources(dsMap);

        return dynamicDataSource;
    }
    /**
     * 配置@Transactional注解事务
     * @return
     */
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(getDynamicDataSource());
    }

}
4.自定义注释 @DS
package com.ihaha.config.dynamic;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * @author: Aaron
 * @Date: 2018/12/1 17:10
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({
        ElementType.METHOD
})
public @interface DS {
    String value() default "datasourceA";
}
5.编写AOP切面
package com.ihaha.config.dynamic;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;

@Aspect
@Component
public class DynamicDataSourceAspect {

    @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 = DataSourceContextHolder.DEFAULT_DS;
        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();
        }
        // 切换数据源
        DataSourceContextHolder.setDB(dataSource);

    }
    @After("@annotation(DS)")
    public void afterSwitchDS(JoinPoint point){
        DataSourceContextHolder.clearDB();

    }
}
6.SqlSessionFactory
package com.ihaha.config.dynamic;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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 tk.mybatis.spring.annotation.MapperScan;

import javax.sql.DataSource;

/**
 * @author: Aaron
 * @Date: 2018/12/2 17:12
 */
@Configuration
@MapperScan(basePackages = {"com.ihaha.mapper.datasourceB"}, sqlSessionFactoryRef = "dynamicSqlSessionFactory")
public class DynamicDataSourceConfig {

    @Autowired
    private DynamicDataSource dynamicDataSource;
    
    @Bean(name = "dynamicSqlSessionFactory")
    @Primary
    public SqlSessionFactory dynamicSqlSessionFactory() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dynamicDataSource);
        factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/dynamic/*.xml"));
        return factoryBean.getObject();

    }
    @Bean
    @Primary
    public SqlSessionTemplate sqlSessionTemplate1() throws Exception {
        // 使用上面配置的Factory
        SqlSessionTemplate template = new SqlSessionTemplate(dynamicSqlSessionFactory());
        return template;
    }
    
}

完事儿！

四、补充点

1.@Primary
2.@Qualifier
3.Springboot默认的静态资源路径为
  • classpath:/META-INF/resources/
  • classpath:/resources/
  • classpath:/static/
  • classpath:/public
4.指定配置文件
spring:
  profiles:
    active: dev
5.添加拦截器
  1. 自定义拦截器，实现HandlerInterceptor接口
  2. 编写配置类，注册拦截器，实现WebMvcConfigurer接口
【项目实战】SpringBoot的数据源配置
本本本添哥
08-14 1888
在SpringBoot项目中，可以通过配置一个数据源来提供数据的访问和管理。SpringBoot提供了许多数据源的配置方式，如使用Spring Data JPA、Mybatis等框架来配置数据源。
springboot之数据源配置
星星都没我亮的博客
10-29 836
文章目录1、JDBC2、自定义数据源DruidDataSource3、springboot配置多数据源并动态切换4、springboot整合mybatis ​ Spring Framework 为 SQL 数据库提供了广泛的支持。从直接使用 JdbcTemplate 进行 JDBC 访问到完全的对象关系映射（object relational mapping）技术，比如 Hibernate。Spring Data 提供了更多级别的功能，直接从接口创建的 Repository 实现，并使用了约定从方法名生成
SpringBoot单数据源配置（一）
qq_38277366的博客
03-12 1275
SpringBoot单数据源配置
Springboot配置单数据源
GongZiYouM的博客
06-23 259
示例数据源为H2嵌入式数据库，所以引入H2的数据库驱动依赖 因为需要对数据库进行操作，还需要引入JDBC依赖：spring-boot-starter-jdbc 数据库连接定义的几个对象： 数据源：javax.sql.DataSource 数据库连接：java.sql.Connection 数据源相关配置属性： spring.datasource.url=jdbc:mysql://localhost/test spring.datasource.username=dbuser spring.datasourc
Spring Boot单数据源自定义配置
oneslide
05-12 1479
Spring会自动配置很多@Bean对象，所以你可以专注于应用的逻辑开发。这篇文章，我会整理配置单数据源，以未后来配置多数据源做准备。 基本的项目架构是，以Java方式配置数据源，并在application.properties文件中配置元信息。 @Configuration /**When the @EnableConfigurationProperties annotation is ...
Springboot配置数据源
mk33092250的博客
12-26 1234
springboot下多数据源的配置
详解SpringBoot和Mybatis配置多数据源
08-30
在当前的软件开发中，多数据源配置已经成为一个非常常见的需求，特别是在大型企业级应用程序中。SpringBoot作为一个流行的Java框架，提供了非常便捷的方式来配置多数据源，并且可以与Mybatis框架进行集成。本文将...
SpringBoot配置多数据源实现动态切换数据源
06-29
多数据源配置允许我们灵活地管理这些数据。 SpringBoot实现多数据源主要依靠Spring的`@Configuration`和`@DataSourceConfiguration`注解，以及Spring JDBC的`DataSource`接口。下面是一个基本的配置示例： ```java...
SpringBoot中配置多个数据源
最新发布
没刮胡子的程序员专栏
03-19 943
在SpringBoot中配置多个数据源并实现自动切换，可以通过使用AbstractRoutingDataSource和AOP（面向切面编程）的方式来实现。
springboot v2.0.3版本多数据源配置方法
08-26
Spring Boot v2.0.3版本多数据源配置方法 在Spring Boot v2.0.3版本中，配置多数据源是一项重要的任务。本文将详细介绍如何配置多数据源，包括之前的配置方法和升级到v2.0.3版本后的变化。 之前的多数据源配置方法...
com.mysql.jdbc.Driver驱动包，亲测可用
10-09
com.mysql.jdbc.Driver驱动包，亲测可用,自用版，
java连接数据库 Jdbc
weixin_52188949的博客
08-30 442
JDBC 去数据官网下载数据响应的驱动程序 java对每个数据库厂家提供相应接口，驱动程序就是对接口的实现类 导入驱动的jar包 Ecplise版放jar包 俩种方法 放在WEB-INF/lib下 通过build path导入 不同版本的数据库导入不同的jar包 连接时的写法也略有区别： 1.使用的jar包版本：mysql-connector-5.1.0+ //1.注册驱动 Class.forName("com.mysql.jdbc.Driver
java连接池hkai,MySQL连接配置文件密码加密及其在多种连接池上的应用
weixin_39592240的博客
03-16 430
为了安全，连接数据库的配置文件中，如密码等信息需要采用密文的形式存放。本文将给出多种连接池数据库密码密文存放的实现~如何配置数据库密码加密访问数据库？将配置文件用户相关的信息(例如：密码)进行加密使其以密文形式存在，进行 初始化连接池 的时候进行解密操作，达到成功创建连接池的目的 。接下来，我们完成如下几个连接池采用数据库密文存储的实现：DBCP连接池C3P0连接池Druid连接池DBCP连接池数...
SpringBoot多数据源配置
上善若泪
03-27 3万+
文章目录1 SpringBoot分库配置1.1 准备数据1.2 springboot+mybatis使用分包方式整合1.2.1 pom.xml1.2.2 application.yml 配置文件1.2.3 连接数据源配置文件1.2.3.1 连接源配置一1.2.3.2 连接源配置二1.2.4 项目结构1.3 springboot+druid+mybatisplus使用注解整合1.3.1 pom.xml1.3.2 application.yml 配置文件1.3.3 使用@DS区分数据源1.4 读写分离库1.4.
SpringBoot篇——SpringBoot操作数据库（整合JDBC、Druid和Mybatis，超详细！）
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
11-28 8782
1、首先在Springboot04DataApplication启动程序的同级建立config文件夹，新建Druid配置类，在该配置类中做绑定配置文件和自定义的监控配置等。八、编写application.yaml配置文件，将来都会整合到一个配置文件中（这一步很关键，不然我们编写的mapper.xml无法被扫描到）一、整合之前回顾当初Spring整合Mybatis时候，需要导入特定的依赖，而如今我们SpringBoot整合Mybatis，也需要导入依赖。预祝猿朋友早日成为全栈工程师！
springboot如何配置单数据源
程序员蒋老湿的博客
02-25 1058
如果要做对应的数据操作，需要配置对应数据源，为了简单演示，这里是H2 内存数据库作为数据源，maven 需要添加如下配置 引入jdbc依赖和h2数据库 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency&gt
SpringBoot项目配置多数据源的两种方式
weixin_50003028的博客
11-24 6657
spring:druid:db1:db2:该类的作用就是初始化数据源DataSource实例，以及初始化SqlSessionFactory实例。这里需要注意的是必须使用来获取会话工厂SqlSessionFactory，不然的话，baseMapper中的生成动态SQL的方法就不能使用了。//mapper模式下的接口层/*** 配置数据源* @return*/@Primary/*** 配置数据源* @return*/@Bean。
SpringBoot配置数据源DataSource
热门推荐
喜爱兰兰
06-29 19万+
github源码地址: https://github.com/yangxiaowan/databaseconfig.git SpringBoot如何快速配置数据源?有如下两种方式: 通过spring-boot-starter-jdbc快速配置数据源 自定义数据源DataSource 首先我们需要明确数据源DataSource有什么作用: 通过DataSource可以获...
SpringBoot中多数据源的配置
zhangxing
07-27 3万+
1.场景还原 在实际项目中，一个工程配置多个数据源很常见，工程可能会根据业务或者模块访问不同的数据库或表；今天笔者就springboot中配置多数据源作个详细的讲解 2.实现方案 注意：一个应用工程中有且只有一个启动类，其依赖的模块不能是带有启动类的模块 ①application.yml配置 spring: datasource: druid: maste...
springboot 数据源配置
08-13
总结起来，SpringBoot提供了简单易用的数据源配置，可以通过`DataSourceProperties`来定义数据源的属性，通过`spring.datasource.type`来指定数据源的类型。如果需要多数据源配置，可以参考Druid和HikariCP的相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值