spring boot 2.0多数据源配置

于 2021-01-04 16:04:49 发布
阅读量436 收藏 1
点赞数
分类专栏： 一天一点点 文章标签： java spring boot
原文链接：https://blog.csdn.net/tuesdayma/article/details/81081666?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control
版权

一,第一种方式

1.配置文件

spring.datasource.test1.jdbc-url=jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
spring.datasource.test1.username=root
spring.datasource.test1.password=123456
spring.datasource.test1.driver-class-name=com.mysql.jdbc.Driver

spring.datasource.test2.jdbc-url=jdbc:mysql://localhost:3306/demo1?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
spring.datasource.test2.username=root
spring.datasource.test2.password=123456
spring.datasource.test2.driver-class-name=com.mysql.jdbc.Driver

server.port=8083
logging.level.com.atguigu=trace

2.第一数据源配置

package com.config;

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.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.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;

/**
 * 用@Primary区分主数据源
 * @Date 2018/10/30.
 */
@Configuration
@MapperScan(basePackages = "com.mapper.test01",sqlSessionTemplateRef   = "test1SqlSessionTemplate")
public class PrimaryConfig {
    // 将这个对象放入Spring容器中
    @Bean(name = "test1DataSource")
    // 表示这个数据源是默认数据源
    @Primary
    // 读取application.properties中的配置参数映射成为一个对象
    // prefix表示参数的前缀
    @ConfigurationProperties(prefix = "spring.datasource.test1")
    public DataSource getDateSource1() {
        return DataSourceBuilder.create().build();
    }
    @Bean(name = "test1SqlSessionFactory")
    // 表示这个数据源是默认数据源
    @Primary
    // @Qualifier表示查找Spring容器中名字为test1DataSource的对象
    public SqlSessionFactory test1SqlSessionFactory(@Qualifier("test1DataSource") DataSource datasource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(datasource);
        bean.setMapperLocations(
                // 设置mybatis的xml所在位置
                new PathMatchingResourcePatternResolver().getResources("classpath*:com/mapper/test01/*.xml"));
        return bean.getObject();
    }
    @Bean("test1SqlSessionTemplate")
    // 表示这个数据源是默认数据源
    @Primary
    public SqlSessionTemplate test1sqlsessiontemplate(
            @Qualifier("test1SqlSessionFactory") SqlSessionFactory sessionfactory) {
        return new SqlSessionTemplate(sessionfactory);
    }


 /*   @Bean(name = "test1TransactionManager")
    @Primary
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test1DataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }*/

}

3.第二数据源配置

package com.config;

        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.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 javax.sql.DataSource;

/**
 * @Date 2018/10/30.
 */
@Configuration
@MapperScan(basePackages = "com.mapper.test02",sqlSessionTemplateRef = "test2SqlSessionTemplate")
public class SecondaryConfig {
    @Bean(name = "test2DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.test2")
    public DataSource getDateSource2() {
        return DataSourceBuilder.create().build();
    }
    @Bean(name = "test2SqlSessionFactory")
    public SqlSessionFactory test2SqlSessionFactory(@Qualifier("test2DataSource") DataSource datasource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(datasource);
        bean.setMapperLocations(
                new PathMatchingResourcePatternResolver().getResources("classpath*:com/mapper/test02/*.xml"));
        return bean.getObject();
    }
    @Bean("test2SqlSessionTemplate")
    public SqlSessionTemplate test2sqlsessiontemplate(
            @Qualifier("test2SqlSessionFactory") SqlSessionFactory sessionfactory) {
        return new SqlSessionTemplate(sessionfactory);
    }


  /*  @Bean(name = "test2TransactionManager")
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test2DataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
*/
}

service

package com.service.test02;

import com.domain.test02.User2;

/**
 * @Date 2018/8/22.
 */
public interface UserService {

    public User2 getUser2(String username);
}

impl实现

package com.service.test02.impl;

import com.domain.test02.User2;
import com.mapper.test02.User2Mapper;
import com.service.test02.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @Date 2018/8/22.
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private User2Mapper user2Mapper;


    @Override
    public User2 getUser2(String username) {
        // 数据库查询有没此用户如无直接返回null
        User2 user = user2Mapper.findUserByUsername(username);
        return user;
    }

}

控制

package com.controller;

import com.domain.test01.Depot;
import com.domain.test02.User2;
import com.service.test01.DepotService;
import com.service.test02.UserService;
import com.utils.ResponseBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Date 2018/10/30.
 */
@RestController
public class TestController {

    @Autowired
    private DepotService depotService;
    @Autowired
    private UserService userService;

    @GetMapping("/depot")
    public ResponseBean getDepot(int id) {
        Depot depot = depotService.selectByPrimaryKey(id);
        ResponseBean responseBean = new ResponseBean(200, "success", depot);
        return responseBean;
    }

    @GetMapping("/user")
    public ResponseBean getUser(String name) {
        User2 user = userService.getUser2(name);
        ResponseBean responseBean = new ResponseBean(200, "success", user);
        return responseBean;
    }
}

返回结果类

package com.utils;

/**
 * 返回结果集
 */
public class ResponseBean {

    // http 状态码
    private int code;

    // 返回信息
    private String msg;

    // 返回的数据
    private Object data;

    public ResponseBean(int code, String msg, Object data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

}

目录结构

 

二,第二种方式：aop

 

package com.config.aop;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * 切换数据源类型的类
 * @Date 2021/1/4.
 */

public class DataSourceType {
    private static final Logger logger = LogManager.getLogger(DataSourceType.class);
    public enum DataBaseType {
        TEST01, TEST02
    }

    // 使用ThreadLocal保证线程安全
    private static final ThreadLocal<DataBaseType> TYPE = new ThreadLocal<DataBaseType>();

    // 往当前线程里设置数据源类型
    public static void setDataBaseType(DataBaseType dataBaseType) {
        if (dataBaseType == null) {
            throw new NullPointerException();
        }
        logger.info("[将当前数据源改为]：" + dataBaseType);
        //System.err.println("[将当前数据源改为]：" + dataBaseType);
        TYPE.set(dataBaseType);
    }

    // 获取数据源类型
    public static DataBaseType getDataBaseType() {
        DataBaseType dataBaseType = TYPE.get() == null ? DataBaseType.TEST01 : TYPE.get();
        logger.info("[获取当前数据源的类型为]：" + dataBaseType);
        //System.err.println("[获取当前数据源的类型为]：" + dataBaseType);
        return dataBaseType;
    }

    // 清空数据类型
    public static void clearDataBaseType() {
        TYPE.remove();
    }
}

package com.config.aop;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 动态数据源
 * @Date 2021/1/4.
 */

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        DataSourceType.DataBaseType dataBaseType = DataSourceType.getDataBaseType();
        return dataBaseType;
    }
}

package com.config.aop;

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.boot.jdbc.DataSourceBuilder;
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 javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * 多个数据源配置
 * @Date 2021/1/4.
 */
@Configuration
@MapperScan(basePackages = "com.mapper", sqlSessionFactoryRef = "SqlSessionFactory")
public class DataSourceConfig {

    @Primary
    @Bean(name = "test1DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.test1")
    public DataSource getDateSource1() {
        return DataSourceBuilder.create().build();
    }
    @Bean(name = "test2DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.test2")
    public DataSource getDateSource2() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "dynamicDataSource")
    public DynamicDataSource DataSource(@Qualifier("test1DataSource") DataSource test1DataSource,
                                        @Qualifier("test2DataSource") DataSource test2DataSource) {
        Map<Object, Object> targetDataSource = new HashMap<>();
        targetDataSource.put(DataSourceType.DataBaseType.TEST01, test1DataSource);
        targetDataSource.put(DataSourceType.DataBaseType.TEST02, test2DataSource);
        DynamicDataSource dataSource = new DynamicDataSource();
        dataSource.setTargetDataSources(targetDataSource);
        dataSource.setDefaultTargetDataSource(test1DataSource);
        return dataSource;
    }
    @Bean(name = "SqlSessionFactory")
    public SqlSessionFactory test1SqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dynamicDataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dynamicDataSource);
        bean.setMapperLocations(
                new PathMatchingResourcePatternResolver().getResources("classpath*:com/mapper/*.xml"));
        return bean.getObject();
    }
}

package com.config.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 不同业务切换不同数据库的入口
 * @Date 2021/1/4.
 */
@Aspect
@Component
public class DataSourceAop {
    @Before("execution(* com.service.test01.impl..*.*(..))")
    public void setDataSource2test01() {
        System.err.println("test01业务");
        DataSourceType.setDataBaseType(DataSourceType.DataBaseType.TEST01);
    }

    @Before("execution(* com.service.test02.impl..*.*(..))")
    public void setDataSource2test02() {
        System.err.println("test02业务");
        DataSourceType.setDataBaseType(DataSourceType.DataBaseType.TEST02);
    }

}

目录结构

https://blog.csdn.net/tuesdayma/article/details/81081666?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

anyeoo
关注
专栏目录
spring boot2.0多数据源配置 jdbcUrl is required with driverClassName.
杨鹏的博客
05-30 6672
问题描述 springboot2.0版本终于在三月与大家见面本次升级可谓是一次重大升级，鉴于springboot2.0对众多插件进行升级并支持spring5于是公司也进行了一次版本升级升级中发现多数据源配置会提示 jdbcUrl is required with driverClassName. 于是就开始了排错之旅 所使用的技术栈 spring boot 2.0.2 j...
spring boot 2.0 jpa多数据源配置
思与学的博客
11-07 1285
spring boot 1.x内多数据源配置方式参考Spring Boot多数据源配置与使用，但升级到2后该配置无效，以下是自测可行的配置方式（spring boot版本2.0.6.RELEASE）。 1. application.properties配置 #数据源1 spring.datasource.primary.jdbc-url=jdbc:mysql://localhost:3306/te...
spring-boot2.0多数据源
09-06
spring-boot2.0多数据源 下载直接可以使用。支持扩展多个数据库。动态切换数据库
springboot2.0多数据源配置
Voice的博客
07-23 201
springboot多数据源配置 application.yml ################# dataSource #################### spring: datasource: db1: jdbc-url: jdbc:mysql://127.0.0.1:3306/test1?serverTimezone=Asia/Shanghai&u...
SpringBoot2.0多数据源配置，超级简单好用
不忘初心,继续前进
08-01 1016
1.配置文件application.yml，我这里用的postgresql，Oracle MySql等用相应的jdbc和Driver就行 #datasource spring: application: name: bpas datasource: type: com.alibaba.druid.pool.DruidDataSource bpas: ...
SpringBoot2.0之八 多数据源配置
qh870754310的博客
03-05 551
在开发的过程中我们可能都会遇到对接公司其他系统等需求，对于外部的系统可以采用接口对接的方式，对于一个公司开发的两个系统，并且知道相关数据库结构的情况下，就可以考虑使用多数据源来解决这个问题。SpringBoot为我们提供了相对简单的实现。 一、建立如下结构的maven项目 二、添加相关数据库配置信息 server: port: 8080 spring: datasource: ...
Springboot2.0配置多数据源
weixin_34356310的博客
04-08 366
前提 本文针对SpringBoot2.0以上版本进行说明，本文的数据库连接池采用的是HikariCP，首先在pom.xml中引入springboot的依赖 <dependencyManagement> <dependencies> <dependency> <!-- Impor...
Spring Boot 2.0多数据源配置方法实例详解
08-26
Spring Boot 2.0 多数据源配置方法实例详解是一篇详细介绍 Spring Boot 2.0 中多数据源配置方法的文章。该文章主要介绍了如何在 Spring Boot 2.0 中配置多个数据源，并提供了详细的实例代码。 多数据源配置是指在同...
springboot2.0多数据源集成hibernate配置hibernateDaoSupport示例
04-12
本示例主要介绍如何实现Spring Boot 2.0多数据源的集成，并结合Hibernate进行配置，特别是在DAO层使用`HibernateDaoSupport`进行操作，而非使用JPA（Java Persistence API）。 首先，让我们了解Spring Boot 2.0的...
springboot2.0多数据源
乐闻世界
05-26 1280
springboot多数据源操作
Spring-boot项目多数据源配置
08-30
基于maven的spring-boot项目配置多数据源，基于xml配置文件配置多数据源
springboot配置多数据源，注解自由切换，完美运行
10-16
基于spring boot mybatis的多数据源配置，使用Druid配置连接池，使用注解自动切换数据源，完美运行！
springBoot2.0+mybatis支持多数据源+shiro
06-05
springboot整合shiro目前只配置了一个数据源 按照方式再加上一个再加主从标识就OK了，shiro的权限有流程还需完善
springboot多数据源快速启动器,基于 springBoot2.0
05-04
一个简单能直接运行的项目基于 springBoot2.0. 它适用于读写分离，一主多从的环境。 主数据库使用 INSERT UPDATE DELETE 操作. 从数据库使用 SELECT 操作. 如果你的项目比较复杂，建议使用 sharding-jdbc .
SpringBoot整合Mybatis多数据源
xiaoming
08-28 234
SpringBoot整合多数据源 在一个项目中有多个数据源（不同库JDBC）：最多可以有无限多个。具体多少根据内存大小。 在一个项目多数据源如何划分？ 分包名（根据业务）：原理使用根据包名，加载不同的数据源 或者根据注解方式。 配置文件中新增两个数据源 ###datasource1 spring.datasource.test1.driver-class-name = com.mysql.jdbc...
SpringBoot配置多数据源
后厂村老司机
08-13 231
前言 项目中用到了两个数据库，分别是Oracle和Mysql，涉及到了多数据源问题，这里做下记录 官方讲解：https://github.com/alibaba/druid/tree/master/druid-spring-boot-starter 日志JDBC配置：https://github.com/alibaba/druid/wiki/%E9%85%...
springboot2.0配置多数据源
赴前尘
06-07 216
一.mysql数据库测试脚本 CREATE DATABASE test01; use test01; set password for root@localhost = password('a'); CREATE TABLE USER ( id int PRIMARY KEY AUTO_INCREMENT, name varchar(20) NOT NULL, ag...
SpringBoot2.0--- 多数据源配置
WGH100817的博客
06-25 85
  在开发的过程中我们可能都会遇到对接公司其他系统等需求，对于外部的系...
全新升级的Spring Boot 2.0源代码发布
作为开发者，使用这个Spring Boot源文件版本2.0，你将能够体验到Spring Boot框架的便捷性，通过阅读和修改这些源代码，你可以学习到如何构建一个可运行的Spring Boot应用，以及如何组织项目结构。此外，通过参考代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值