springboot数据源配置

最新推荐文章于 2024-04-02 00:35:11 发布
最新推荐文章于 2024-04-02 00:35:11 发布
阅读量47 收藏
点赞数
文章标签： java runtime 数据库
原文链接：http://www.cnblogs.com/popcornya/p/9031433.html
版权
springboot数据源配置

===========================多数据源配置==============================

配置文件application.properties：

    #多数据源配置
spring.datasource.db1.url=jdbc:mysql://localhost:3306/hibernate?useSSL=false
spring.datasource.db1.username=root
spring.datasource.db1.password=root
spring.datasource.db1.driver-class-name=com.mysql.jdbc.Driver

spring.datasource.db2.url=jdbc:mysql://localhost:3306/spring?useSSL=false
spring.datasource.db2.username=root
spring.datasource.db2.password=root
spring.datasource.db2.driver-class-name=com.mysql.jdbc.Driver

数据库配置DatasourceConfigure.java：

package com.bxw.configuration;

import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
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.util.HashMap;
import java.util.Map;

@Configuration
public class DataSourceConfigure {
    @Bean(name = "db1")
    @ConfigurationProperties(prefix = "spring.datasource.db1") // application.properteis中对应属性的前缀
    public DataSource dataSource1() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "db2")
    @ConfigurationProperties(prefix = "spring.datasource.db2") // application.properteis中对应属性的前缀
    public DataSource dataSource2() {
        return DataSourceBuilder.create().build();
    }
}

采用spring注解方式注入数据源，数据源名称分别为db1,db2

 

注入sessionFactory,sessionTemplate

MybatisDBAConfig.java
package com.bxw.configuration;

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.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = {"com.bxw.mapperB"},sqlSessionFactoryRef = "sqlSessionFactory1")
public class MybatisDBAConfig {

    @Autowired
    @Qualifier("db1")
    private DataSource db1;

    @Bean
    public SqlSessionFactory sqlSessionFactory1() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(db1); // 使用db1数据源, 连接hibernate库

        return factoryBean.getObject();

    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate1() throws Exception {
        SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory1()); // 使用上面配置的Factory
        return template;
    }
}
MybatisDBBConfig.java
package com.bxw.configuration;

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.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = {"com.bxw.mapperA"},sqlSessionFactoryRef = "sqlSessionFactory2")
public class MybatisDBBConfig {
    @Autowired
    @Qualifier("db2")
    private DataSource db2;

    @Bean
    public SqlSessionFactory sqlSessionFactory2() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(db2); // 使用db1数据源, 连接hibernate库

        return factoryBean.getObject();

    }

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

该配置配置过后，在com.bxw.mapperA和com.bxw.mapperB两个包中的mapper分别使用不同的数据源。

 ==================================sprIngboot动态数据源=============================================

DBConfig1.java:

package com.bxw.configuration;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "spring.datasource.db1")
public class DBConfig1 {
    private String url;
    private String password;
    private String username;

    public String getUrl() {
        return url;
    }

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

    public String getPassword() {
        return password;
    }

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

    public String getUsername() {
        return username;
    }

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

通过@ConfigurationProperties注入数据源的属性值。

DBConfig2.java：

package com.bxw.configuration;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "spring.datasource.db2")
public class DBConfig2 {
    private String url;
    private String password;
    private String username;

    public String getUrl() {
        return url;
    }

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

    public String getPassword() {
        return password;
    }

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

    public String getUsername() {
        return username;
    }

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

DatasourceContextHolder.java:

package com.bxw.configuration;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class DatasourceContextHolder {
    public static final Logger log = LoggerFactory.getLogger(DatasourceContextHolder.class);

    public static final String primary_DB = "db1";

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();
    //设置数据源名
    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();
    }
}

自定义数据源管理类。

DynamicDatasource.java:

package com.bxw.configuration;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDatasource extends AbstractRoutingDataSource {

    private static Logger log = LoggerFactory.getLogger(DynamicDatasource.class);

    @Override
    protected Object determineCurrentLookupKey() {
        log.debug("数据源为{}",DatasourceContextHolder.getDB());
        return DatasourceContextHolder.getDB();
    }
}

DatasourceConfigure.java

package com.bxw.configuration;

import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
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.util.HashMap;
import java.util.Map;

@Configuration
public class DataSourceConfigure {
    //动态数据源
    @Bean(name="dynamicDB1")
    public DataSource dataSource(){
        DynamicDatasource dynamicDatasource = new DynamicDatasource();
        //默认数据源
        dynamicDatasource.setDefaultTargetDataSource(dataSource1());

        Map<Object,Object> dbMap = new HashMap(5);
        dbMap.put("db1",dataSource1());
        dbMap.put("db2",dataSource2());
        dynamicDatasource.setTargetDataSources(dbMap);
        return dynamicDatasource;
    }
}

配置动态数据源。

MybatisDBCConfig.java:

package com.bxw.configuration;

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.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

/**
 * 动态数据源
 */
@Configuration
@MapperScan(basePackages = {"com.bxw.mapperDynamic"},sqlSessionFactoryRef = "sqlSessionFactory3")
public class MybatisDBCConfig {
    @Autowired
    @Qualifier("dynamicDB1")
    private DataSource dynamicDB1;

    @Bean
    public SqlSessionFactory sqlSessionFactory3() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dynamicDB1); // 使用db1数据源, 连接hibernate库

        return factoryBean.getObject();

    }

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

自定义注解DB.java:

package com.bxw.annotation;

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 DB {
    String value() default "db1";
}

StudentService.java

package com.bxw.service;

import com.bxw.annotation.DB;
import com.bxw.entity.Student;
import com.bxw.mapperTA.StudentMapperTA;
import com.bxw.mapperTB.StudentMapperTB;
import com.bxw.mapperDynamic.StudentMapperC;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

@Service
public class StudentService {
    @Autowired
    private StudentMapperC studentMapperC;

    /**
     * 动态数据源
     */
    @DB
    public List<Student> db1(){
        return studentMapperC.findAll();
    }

    @DB("db2")
    public List<Student> db2(){
        return studentMapperC.findAll();
    }
}

@DB根据不同值切换数据源。

 

posted on 2018-05-13 15:25 popcorn丫 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/popcornya/p/9031433.html

weixin_30614587
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mysql多数据源配置_Springboot多数据源配置
weixin_34141225的博客
02-02 345
目前，业界流行的数据操作框架是 Mybatis，那 Druid 是什么呢？ Druid 是 Java 的数据库连接池组件。Druid 能够提供强大的监控和扩展功能。比如可以监控 SQL ，在监控业务可以查询慢查询 SQL 列表等。Druid 核心主要包括三部分： 1. DruidDriver 代理 Driver，能够提供基于 Filter－Chain 模式的插件体系。 2. DruidDataSo...
说说在 Spring Boot 中如何配置数据源
读万卷书，行万里路
10-10 1964
假设我们需要使用 Oracle 数据库，那么首先需要在 pom.xml 中引用 Oracle 数据库驱动包： <properties> <oracle.version>12.2.0.1</oracle.version> ... </properties> <dependency> <groupId>com.oracle</groupId> <artifactId>oj
Spring Boot 自动配置数据源及操作数据库，干货精讲
最新发布
2401_83946284的博客
04-02 818
MapperScan(“com.lou.springboot.dao”) //添加 @Mapper 注解①.编写数据库实体类User注意类名和字段名要和数据库完全一致才能对应上去②.编写接口在dao包中新建UserDao接口，并定义增删改查四个接口：③.编写Mapper实现接口在目录下新建Mapper接口的映射文件，之后进行映射文件的编写。
springboot属性注入
qq_41923555的博客
12-22 106
方法一： 1.创建application.properties jdbc.driverClassName=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/leyou jdbc.username=root jdbc.password=123 2.创建属性类JdbcProperties import lombok.Dat...
SpringBoot数据源配置
sky
04-06 219
server: port: 31200 spring: application: name: xc-service-manage-course datasource: type: com.alibaba.druid.pool.DruidDataSource #切换数据源：配置druid为数据源（提供连接池），替换掉之前默认的tomcat的数据源 url: jdb...
Springboot配置数据源
mk33092250的博客
12-26 1072
springboot下多数据源的配置
SpringBoot配置多数据源实现动态切换数据源
06-29
通过简单的demo实现SpingBoot多数据源配置并动态切换多数据源
springboot多数据源配置
07-28
springboot多数据源配置
详解SpringBoot和Mybatis配置多数据源
08-30
本篇文章主要介绍了详解SpringBoot和Mybatis配置多数据源，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot Mybatis如何配置多数据源并分包
08-19
主要介绍了SpringBoot Mybatis如何配置多数据源并分包,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot配置数据源
yf_1018的博客
12-07 7899
Spring Framework 为 SQL 数据库提供了广泛的支持。从直接使用 JdbcTemplate 进行 JDBC 访问到完全的对象关系映射（object relational mapping）技术，比如 Hibernate。Spring Data 提供了更多级别的功能，直接从接口创建的 Repository 实现，并使用了约定从方法名生成查询。
SpringBoot中多数据源配置
hdn_kb的博客
06-09 128
2、数据源切换注解 3、数据源枚举 4、数据库持有 5、数据源路由：AbstractRoutingDataSource 6、动态数据源配置 7、JDBC配置 8、AOP切面 9、问题 在同一个事物中，数据源切换失败
【项目实战】SpringBoot的数据源配置
本本本添哥
08-14 1536
在SpringBoot项目中，可以通过配置一个数据源来提供数据的访问和管理。SpringBoot提供了许多数据源的配置方式，如使用Spring Data JPA、Mybatis等框架来配置数据源。
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中如何整合数据源？
万猫学社
06-28 1497
JdbcTemplate是Spring框架中提供的一个简化JDBC操作的工具类，它可以帮助我们避免编写大量的重复代码，提高开发效率。简化数据库连接的获取和释放；简化SQL语句的执行；简化结果集的处理。MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。灵活的SQL编写，支持动态SQL；易于集成，可以与Spring、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配置多数据源的四种方式
qq_45515182的博客
08-14 2万+
在日常的项目中我们的开发都是采用单数据库的模式，但是在高并发的时代，单数据库已经无法承载大数据量的访问，所以就需要使用多个数据库进行对数据的读写分离。
springboot 数据源配置
08-13
总结起来，SpringBoot提供了简单易用的数据源配置，可以通过`DataSourceProperties`来定义数据源的属性，通过`spring.datasource.type`来指定数据源的类型。如果需要多数据源配置，可以参考Druid和HikariCP的相关...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值