springboot2多数据源之自定义配置方式，使用AOP切换数据源，yml文件维护数据

最新推荐文章于 2024-05-26 13:06:48 发布
最新推荐文章于 2024-05-26 13:06:48 发布
阅读量1.6k 收藏
点赞数
分类专栏： springBoot 文章标签： 多数据源 AOP 自定义数据源
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33333654/article/details/94471294
版权

环境：

springboot2

tomcat8

jdk1.8

驱动及加密：com.alibaba.druid

多数据源
1、数据源枚举定义
 public interface DatasourceEnum {
    String DATA_SOURCE = "dataSource";            //主数据源

    String DATA_SOURCE_2 = "dataSource2";            //其他业务的数据源
    String DATA_SOURCE_3 = "dataSource3";            //其他业务的数据源
}
2、定义数据源实体
 import com.alibaba.druid.pool.DruidDataSource;
import lombok.Getter;
import lombok.Setter;
@Setter
@Getter
public class MutiDataSourceProperties {

    private String dataSourceName;

    private String url;

    private String username;

    private String password;

    private String driverClassName;

    private String validationQuery = "SELECT 'x'";


    public void config(DruidDataSource dataSource) {
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setValidationQuery(validationQuery);
    }

}
 
 3、自定义注解
 import java.lang.annotation.*;

/**
 * @author keeps
 * @Title: DataSource
 * @ProjectName aifaceboot
 * @Description: 多数据源标识
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {

    String name() default DatasourceEnum.DATA_SOURCE;

}
 4、数据源基础配置类
 import lombok.Getter;
import lombok.Setter;

/**
 * @author keeps
 * @Title: DataConnectionProperties
 * @ProjectName aifaceboot
 * @Description: 数据源基础配置类
 */
@Setter
@Getter
public class DataSourceSchool {

    private String dataSourceName;

    private String dialectType;

}
5、定义数据源帮助类，共享上下文线程
 

/**
 * @author keeps
 * @Title: DataSourceContextHolder
 * @ProjectName aifaceboot
 * @Description: 动态切换数据源datasource的上下文
 */
public class DataSourceContextHolder {

    private static final ThreadLocal<DataSourceSchool> contextHolder = new ThreadLocal<DataSourceSchool>();


    /**
     * 设置数据源类型
     *
     * @param dataSourceThread 数据库名，数据源类型
     */
    public static void setDataSourceSchool(DataSourceSchool dataSourceThread) {

        contextHolder.set(dataSourceThread);
    }

    public static void setDataSourceType(String dataSourceName) {
        DataSourceSchool dataSourceThread = new DataSourceSchool();
        String dialectType = DataSourceDialect.dataSourceNameDialect.get(dataSourceName);
        dataSourceThread.setDialectType(dialectType);
        dataSourceThread.setDataSourceName(dataSourceName);
        contextHolder.set(dataSourceThread);
    }
    /**
     * 获取数据源类型
     */
    public static DataSourceSchool getDataSourceSchool() {
        if(contextHolder.get()==null){
            return new DataSourceSchool();
        }
        return contextHolder.get();
    }


    public static String getDialectType() {
        DataSourceSchool dataSourceSchool = contextHolder.get();
        if (dataSourceSchool!=null && dataSourceSchool.getDialectType() != null){
            return dataSourceSchool.getDialectType();
        }
        return null;
    }

    public static String getSQLDialect(String sql, int offset,int limit) {
        String dialectType = getDialectType();
        if (dialectType == null){
            return sql;
        }
        if (dialectType.toUpperCase().contains(Dialect.Type.MYSQL.name().toUpperCase())){
            return new MysqlDialect().getLimitSql(sql, offset, limit);
        } else if (dialectType.toUpperCase().contains(Dialect.Type.ORACLE.name().toUpperCase())) {
            return new OracleDialect().getLimitSql(sql, offset, limit);
        } else if (dialectType.toUpperCase().contains(Dialect.Type.SQLSERVER.name().toUpperCase())) {
            return new SqlServerDialect().getLimitSql(sql, offset, limit);
        }
        return sql;
    }

    /**
     * 清除数据源类型
     */
    public static void clearDataSourceSchool() {
        contextHolder.remove();
    }

}
 
6、创建动态数据源路由
 import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * @author keeps
 * @Title: DynamicDataSource
 * @ProjectName aifaceboot
 * @Description: 动态数据源路由
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    public DynamicDataSource() {
    }

    /*
     * DynamicDataSourceContextHolder代码中使用setDataSourceType
     * 设置当前的数据源，在路由类中使用getDataSourceType进行获取，
     *  交给AbstractRoutingDataSource进行注入使用。
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceSchool().getDataSourceName();
    }
7、定义切面，环绕

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.Ordered;

import java.lang.reflect.Method;

/**
 * @author keeps
 * @Title: MultiSourceExAop
 * @ProjectName aifaceboot
 * @Description: 多数据源切换的aop
 */
@Slf4j
@Aspect
public class MultiSourceAop implements Ordered {

    @Autowired
    private MutiDataSourceProperties mutiDataSourceProperties;


    @Pointcut("@annotation(com.newcap.xy.common.mutidatasource.annotion.DataSource)")
    private void cut()
    {
    }

    @Around("cut()")
    public Object around(ProceedingJoinPoint point)throws Throwable{
        //jdbcCoordinator.close();
        Signature signature = point.getSignature();
        MethodSignature methodSignature = null;
        if (!(signature instanceof MethodSignature)) {
            throw new IllegalArgumentException("该注解只能用于方法");
        }
        methodSignature = (MethodSignature)signature;

        Object target = point.getTarget();
        Method currentMethod = target.getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes());

        DataSource datasource = (DataSource)currentMethod.getAnnotation(DataSource.class);
        DataSourceSchool dataSourceSchool = new DataSourceSchool();
        String dialectType = DataSourceDialect.dataSourceNameDialect.get(datasource.name());
        dataSourceSchool.setDataSourceName(datasource.name());
        dataSourceSchool.setDialectType(dialectType);
        DataSourceContextHolder.setDataSourceSchool(dataSourceSchool);
        if (datasource != null) {
            this.log.debug("设置数据源为：" + datasource.name());
        } else {
           /* String dialectType = DataSourceDialect.dataSourceNameDialect.get(datasource.name());
            dataSourceSchool.setDataSourceName(datasource.name());
            dataSourceSchool.setDialectType(dialectType);
            DataSourceContextHolder.setDataSourceSchool(dataSourceSchool);*/
            this.log.debug("设置数据源为：dataSourceCurrent");
        }
        try
        {
            return point.proceed();
        } finally {
            this.log.debug("清空数据源信息！");
            DataSourceContextHolder.clearDataSourceSchool();
        }
    }

    public int getOrder()
    {
        return -1;
    }
}
 

8、植入springboot

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author keeps
 * @Title: DataSourceAopConfig
 * @Description: 初版生成 AOP
 */
@Configuration
public class DataSourceAopConfig {

    /**
     * 多数据源切换的aop
     */
    @Bean
    public MultiSourceAop multiSourceExAop() {
        return new MultiSourceAop();
    }

}
 

9、创建数据源分类map方便维护
 import java.util.HashMap;
import java.util.Map;

/**
 * @author keeps
 * @Title: DataSourceD
 * @ProjectName newcapboot
 * @Description: 数据源分类
 */
public class DataSourceDialect {

    public static Map<String,String> dataSourceNameDialect = new HashMap<>();

}
 

10、创建连接池优化实体
 

import com.alibaba.druid.pool.DruidDataSource;

import java.sql.SQLException;

/**
 * @author keeps
 * @Title: DruidProperties
 * @ProjectName aifaceboot
 * @Description: Druid Properties
 */
public class DruidProperties {

    private String url;

    private String username;

    private String password;

    private String driverClassName;

    private Integer initialSize = 2;

    private Integer minIdle = 1;

    private Integer maxActive = 20;

    private Integer maxWait = 60000;

    private Integer timeBetweenEvictionRunsMillis = 60000;

    private Integer minEvictableIdleTimeMillis = 300000;

    private String validationQuery = " select 1 FROM DUAL ";

    private Boolean testWhileIdle = true;

    private Boolean testOnBorrow = false;

    private Boolean testOnReturn = false;

    private Boolean poolPreparedStatements = true;

    private Integer maxPoolPreparedStatementPerConnectionSize = 20;

    private String filters = "stat";

    public void config(DruidDataSource dataSource) {

        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);

        // 打开PSCache，并且指定每个连接上PSCache的大小
        dataSource.setPoolPreparedStatements(poolPreparedStatements);
        dataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);

        try {
            dataSource.setFilters(filters);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public String getUrl() {
        return url;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

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

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public Integer getInitialSize() {
        return initialSize;
    }

    public void setInitialSize(Integer initialSize) {
        this.initialSize = initialSize;
    }

    public Integer getMinIdle() {
        return minIdle;
    }

    public void setMinIdle(Integer minIdle) {
        this.minIdle = minIdle;
    }

    public Integer getMaxActive() {
        return maxActive;
    }

    public void setMaxActive(Integer maxActive) {
        this.maxActive = maxActive;
    }

    public Integer getMaxWait() {
        return maxWait;
    }

    public void setMaxWait(Integer maxWait) {
        this.maxWait = maxWait;
    }

    public Integer getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }

    public void setTimeBetweenEvictionRunsMillis(Integer timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }

    public Integer getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }

    public void setMinEvictableIdleTimeMillis(Integer minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }

    public String getValidationQuery() {
        return validationQuery;
    }

    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }

    public Boolean getTestWhileIdle() {
        return testWhileIdle;
    }

    public void setTestWhileIdle(Boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }

    public Boolean getTestOnBorrow() {
        return testOnBorrow;
    }

    public void setTestOnBorrow(Boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }

    public Boolean getTestOnReturn() {
        return testOnReturn;
    }

    public void setTestOnReturn(Boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }

    public Boolean getPoolPreparedStatements() {
        return poolPreparedStatements;
    }

    public void setPoolPreparedStatements(Boolean poolPreparedStatements) {
        this.poolPreparedStatements = poolPreparedStatements;
    }

    public Integer getMaxPoolPreparedStatementPerConnectionSize() {
        return maxPoolPreparedStatementPerConnectionSize;
    }

    public void setMaxPoolPreparedStatementPerConnectionSize(Integer maxPoolPreparedStatementPerConnectionSize) {
        this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
    }

    public String getFilters() {
        return filters;
    }

    public void setFilters(String filters) {
        this.filters = filters;
    }
} 
 以上为多数据源所需AOP相关各个类。我是把上一篇文章的直接站过来了

自定义数据源

1、基础类

/**
 * @author keeps
 * @Title: MutiDataSourceProperties
 * @ProjectName aifaceboot
 * @Description: 多数据源配置
 */
@Setter
@Getter
public class MutiDataSourceProperties {

    private String dataSourceName;

    private String url;

    private String username;

    private String password;

    private String driverClassName;

    private String validationQuery = "SELECT 'x'";


    public void config(DruidDataSource dataSource) {
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setValidationQuery(validationQuery);
    }

}

2、数据列表类

import com.alibaba.druid.pool.DruidDataSource;


import java.util.List;

/**
 * @author keeps
 * @Title: MultiDataSourceExtraProperties
 * @ProjectName aifaceboot
 * @Description: 其它数据源列表
 */
public class MultiDataSourceExtraProperties {
    private List<MutiDataSourceProperties> dataConnectionPropertiesList;

    public List<MutiDataSourceProperties> getDataConnectionPropertiesList() {
        return dataConnectionPropertiesList;
    }

    public void setDataConnectionPropertiesList(List<MutiDataSourceProperties> dataConnectionPropertiesList) {
        this.dataConnectionPropertiesList = dataConnectionPropertiesList;
    }

    public void config(DruidDataSource druidDataSource, MutiDataSourceProperties dataConnectionProperties) {
        druidDataSource.setUrl(dataConnectionProperties.getUrl());
        druidDataSource.setUsername(dataConnectionProperties.getUsername());
        druidDataSource.setPassword(dataConnectionProperties.getPassword());
        druidDataSource.setDriverClassName(dataConnectionProperties.getDriverClassName());
        druidDataSource.setValidationQuery(dataConnectionProperties.getValidationQuery());
    }
}

3、自定义数据源管理类

import com.alibaba.druid.pool.DruidDataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
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.transaction.annotation.EnableTransactionManagement;

import java.sql.SQLException;
import java.util.HashMap;

/**
 * @author keeps
 * @Title: MultiDataSourceConfig
 * @ProjectName aifaceboot
 * @Description: 引入多数据源
 */
@ConditionalOnProperty(prefix = "newcap.jndi-datasource", name = "open", havingValue = "false")
@Configuration
@EnableTransactionManagement(order = 2)
@Slf4j
public class MultiDataSourceConfig {

    /**
     * druid配置
     */
    @Primary
    @Bean(name = "primaryDataSource")
    @Qualifier("primaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource")
    public DruidProperties druidProperties() {
        DruidProperties druidProperties = new DruidProperties();
        return druidProperties;
    }

    /**
     * 多数据源配置 扩展配置
     */
    @Bean
    @ConfigurationProperties(prefix = "newcap.multi-datasource")
    public MultiDataSourceExtraProperties multiDataSourceExtraProperties() {
        return new MultiDataSourceExtraProperties();
    }


    /**
     * 多数据源配置 原配置【只是为兼容MultiSourceExAop】
     */
    @Bean
    public MutiDataSourceProperties mutiDataSourceProperties() {
        MutiDataSourceProperties mutiDataSourceProperties=new MutiDataSourceProperties();
        return mutiDataSourceProperties;
    }

    /**
     * 单个数据源连接配置
     */
    @ConditionalOnProperty(prefix = "newcap.multi-datasource", name = "open", havingValue = "false")
    @Bean
    public DruidDataSource dataSource() {
        DruidProperties druidProperties = druidProperties();

        DruidDataSource dataSource = new DruidDataSource();

        druidProperties.config(dataSource);

        DataSourceDialect.dataSourceNameDialect.put(DatasourceEnum.DATA_SOURCE,druidProperties.getDriverClassName());

        return dataSource;
    }



    /**
     * 多数据源连接池配置
     */
    @ConditionalOnProperty(prefix = "newcap.multi-datasource", name = "open", havingValue = "true")
    @Bean
    public DynamicDataSource dynamicDataSource() {
        HashMap<Object, Object> hashMap = new HashMap<>();

        //读取主数据源配置
        DruidProperties druidProperties = druidProperties();

        //主数据源
        DruidDataSource dataSourceOne = new DruidDataSource();
        druidProperties.config(dataSourceOne);
        DataSourceDialect.dataSourceNameDialect.put(DatasourceEnum.DATA_SOURCE,druidProperties.getDriverClassName());
        try{
            dataSourceOne.init();

            hashMap.put(DatasourceEnum.DATA_SOURCE, dataSourceOne);

            MultiDataSourceExtraProperties multiDataSourceExtraProperties = multiDataSourceExtraProperties();

            for(MutiDataSourceProperties dataConnectionProperties:multiDataSourceExtraProperties.getDataConnectionPropertiesList()){
                DruidDataSource dataSource = new DruidDataSource();
                druidProperties.config(dataSource);
                dataConnectionProperties.config(dataSource);
                dataSource.init();
                hashMap.put(dataConnectionProperties.getDataSourceName(),dataSource);
                DataSourceDialect.dataSourceNameDialect.put(dataConnectionProperties.getDataSourceName(),dataConnectionProperties.getDriverClassName());
            }
        }catch (SQLException e){
            log.error("初始化数据源失败!");
        }

        DynamicDataSource dynamicDataSource = new DynamicDataSource();

        dynamicDataSource.setTargetDataSources(hashMap);
        dynamicDataSource.setDefaultTargetDataSource(dataSourceOne);
        return dynamicDataSource;
    }

}

配置

1、创建application-mysql.yml

spring:
  jpa: #jpa 方言
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
  datasource: #主数据库连接
    url:  jdbc:mysql://IP:3306/aiface?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    validation-query: select 1

2、创建application-oracle.yml文件

spring:
  jpa: #jpa 无需修改
    database-platform: org.hibernate.dialect.Oracle10gDialect
  datasource:
    url:  jdbc:oracle:thin:@IP:1521:face1
    username: facetest
    password: newcapec
    driver-class-name: oracle.jdbc.OracleDriver
    validation-query: select 1 FROM DUAL

3、application.yml文件配置 


spring:
  profiles:
    active: oracle
#druid连接池基础配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    maxActive: 400
    initialSize: 50
    maxWait: 60000
    minIdle: 10
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: select 1
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    maxOpenPreparedStatements: 100
    # 打开PSCache，并且指定每个连接上PSCache的大小
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    # 合并多个DruidDataSource的监控数据
    useGlobalDataSourceStat: true
newcap:
    multi-datasource:
    open: false
    dataConnectionPropertiesList:
    - dataSourceName: dataSource2
      dialect: oracle
      url: jdbc:oracle:thin:@IP:1521:jwkq
      username: ccense
      password: ccense
      driver-class-name: oracle.jdbc.OracleDriver
      validation-query: select 1 FROM DUAL

使用

Dao层方法上添加注解

@DataSource(name = DatasourceEnum.DATA_SOURCE)
不能吃辣的JAVA程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringBoot多数据源动态切换+统一事务配置+动态分页方言
代码宇宙
03-28 4182
SpringBoot多数据源动态切换+统一事务配置+动态分页方言欢迎使用Markdown编辑器不墨迹直接贴代码 欢迎使用Markdown编辑器 最近有公司项目有一个动态切换数据源的需求，但是网上找到的多半不能用或者是功能不全，自己摸索出了最终配置，在此记录下，帮助下有同样需求的人。 不墨迹直接贴代码 我的项目是分层项目，我选择在Service层写动态切换，因为可以在业务层随意切换数据源，很方便 首...
spring boot 多数据源切换aop---------------真的很方面
weixin_39314170的博客
07-24 2119
Boot版本 2.0   此处 @EnableTransactionManagement(order = 2) 需要打个问号，文章结尾会解释 application.yml   /** * 多数据源连接池配置 */ @Bean public DynamicDataSource mutiDataSource(DruidProperties druidProperties...
springboot系类代码：springboot-multisource-org.springframework.boot
BLOG域名:programb.blog.csdn.net
05-25 353
项目中经常会出现需要同时连接两个数据源的情况，这里基于MyBatis来配置两个数据源，并演示如何切换不同的数据源。 通过自定义注解+AOP的方式，来简化这种数据源的切换操作。 项目名称 文章地址 springboot-thymeleaf 集成Thymeleaf构建Web应用 springboot-mybatis 集成MyBatis springboot-hibernate 集成Hibernate springboot-mongodb 集成MongoDB springboot-restful 实现RESTf.
SpringBoot多数据源配置及动态切库注解的使用
最新发布
执笔写JAVA
05-26 263
SpringBoot多数据源配置及动态切库注解的使用
每天一个注解之@DataSource、 @DS
qq_43406318的博客
04-07 1450
多数据源实现实操，自由切换数据源
Spring中配置DataSource数据源的几种选择
热门推荐
当幸福来敲门的专栏
03-10 2万+
Spring中配置DataSource数据源的几种选择 在Spring框架中有如下3种获得DataSource对象的方法: 从JNDI获得DataSource.从第三方的连接池获得DataSource.使用DriverManagerDataSource获得DataSource. 一、从JNDI获得DataSource SpringJNDI数据源配
springboot实现多数据源而且加上事务不会使aop切换数据源失效
04-03
本示例主要讲解如何使用Spring Boot结合MyBatis实现多数据源切换，并确保AOP事务管理仍然有效。 首先，我们需要配置多数据源。在Spring Boot中，可以使用`DataSource`接口的实现类，如`HikariCP`或`Druid`，创建两...
SpringBoot使用AOP完成多数据源切换
09-29
本文将详细讲解如何使用SpringBoot结合AOP（面向切面编程）来实现多数据源的动态切换。 首先，理解SpringBoot的核心是Spring框架，它提供了一个便捷的方式来配置和管理应用。在Spring中，数据源可以通过`@Bean`注解...
springboot多数据源注册与切换
09-20
Spring Boot以其便捷的配置和开箱即用的功能深受开发者喜爱，而"springboot多数据源注册与切换"则是应对复杂数据库环境的一个核心特性。本文将深入探讨如何在Spring Boot应用中实现多数据源的注册、切换以及相关的切...
springboot多数据源切换mysql+sql server事例
04-28
本示例“springboot多数据源切换mysql+sql server”是关于如何在Spring Boot项目中配置和使用多个数据库的数据源切换。下面将详细阐述这个主题的知识点。 首先，**多数据源**是指在一个应用中同时连接并操作多个...
SpringBoot多数据源动态切换源码
07-07
SpringBoot提供了灵活的配置方式，使得我们可以通过配置文件（如application.yml或application.properties）来定义多个数据源。 接下来，项目的重点在于动态数据源切换。这通常涉及到以下关键技术点： 1. **配置...
PostgreSQL配制
Allan8212的专栏
02-06 838
[1]安装PostgreSQL[1]cd /usr/ports/databases/postgresql82-server/make install clean默认安装。[2]接下来初始化数据库：mkdir /var/pgsql/datachown pgsql /var/pgsql/data#su postgres$initdb -D /var/pgsql/data$ postmaster -D
Rocket-api 调研
wjandy0211的博客
04-16 1988
最近在做数据中台资产管理系统，主要核心功能是数据资产发布成api或者文档，客户通过api直接获取发布的数据资产。需要一下一下几点功能： 1 界面sql编辑数据产品 2. 自动发布数据产品到api 调研后一段时间主要技术有Rocket-api和Dataway(hasor)https://www.hasor.net/doc/display/dataway 简介： "Rocket-API" 基于spring boot 的API敏捷开发框架，通过写SQL或者 mongodb原始执行脚本代替CRU...
AbstarctRoutingDataSource配合ThreadLocal实现分库
code_guo的博客
12-23 1372
实现过程： 1.配置文件：配置数据表的连接信息生成bean，并将bean作为value，指定key名称，创建名为targetDataSources的map，该map通过spring初始化。 2.继承AbstarctRoutingDataSource抽象类，实现determine
spring mysql dialect_Spring Boot:在Spring Boot中使用Mysql和JPA
weixin_32630003的博客
01-30 701
本文向你展示如何在Spring Boot的Web应用中使用Mysq数据库，也充分展示Spring Boot的优势(尽可能少的代码和配置)。数据访问层我们将使用Spring Data JPA和Hibernate(JPA的实现之一)。1.Maven pom.xml文件在你的项目中增加如下依赖文件org.springframework.bootspring-boot-starter-weborg.spr...
SpringBoot整合aspectj实现面向切面编程(即AOP)
summon的博客
06-24 4716
…上面的场景都是真实存在的需求，但是如果不能统一处理的话，基本都是一改一大片，除了对业务代码有很强的侵入性，而且难以保证不出问题。所以为了解决这种需求，AspectJ框架应运而生。不过SpringBoot官方也推出了 Spring AOP， 具体对比我就不赘述了，详细对比可以参https://www.jianshu.com/p/872d3dbdc2ca 2、创建切面类并加上@Component注解 这一步相当于把切面类的管理权交给了Spring容器，让Spring容器负责该对象的创建与销毁，我们负责使用就行
Druid连接池二（学习笔记）
尹若轩
08-23 8943
6.Druid关联 6.1.Web关联监控配置  WebStatFilter用于采集web-jdbc关联监控的数据。 web.xml配置：      DruidWebStatFilter    com.alibaba.druid.support.http.WebStatFilter            exclusions        *.js,*.gif,*.jpg,*.png,*.
mybatisplus PageHelper
杨杰超的个人博客
06-15 1万+
PageHelper用于查询语句分页，让分页更简单、代码更优雅。如果硬是要纠结效率与资源，那您倒是直接手写BaseDao哇....集成mybatis-plus，代码中添加分页相关配置 /** * mybatis-plus分页插件&lt;br&gt; * 文档：http://mp.baomidou.com&lt;br&gt; */ @Bean pu...
Spring配置DataSource数据源
不积跬步无以至千里，不积小流无以成江海
05-16 3767
在Spring框架中有如下3种获得DataSource对象的方法: 1.从JNDI获得DataSource. 2.从第三方的连接池获得DataSource. 3.使用DriverManagerDataSource获得DataSource. 一、从JNDI获得DataSource SpringJNDI数据源配置信息：       java:comp/env/jcptDataS
springboot 整合MongoDB 使用aop切换使用多数据源
07-09
对于Spring Boot整合MongoDB并使用AOP切换多数据源的问题，您可以按照以下步骤进行操作： 1. 首先，您需要在`pom.xml`文件中添加MongoDB的依赖。例如，使用Spring Data MongoDB： ```xml <groupId>org.spring...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不能吃辣的JAVA程序猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值