druid 手动指定数据源_Springboot2.1.9+druid+mybatits（不重启项目动态添加mysql和oracle数据源）和数据监控...

最新推荐文章于 2024-04-25 21:10:41 发布
最新推荐文章于 2024-04-25 21:10:41 发布
阅读量271 收藏 1
点赞数
文章标签： druid 手动指定数据源 druid监控页面 jsp 动态添加一行数据

62c4a819c378d67457df26eeda1b3c9e.png

一、前言

最近公司来了一个项目，在理需求和编写接口文档的时候有一个比较有意思的需求：项目启动时不加载数据库，然后管理页面需要提供一个接口，用来配置数据库，配置成功后才连接数据库。于是我做了以下的尝试。

二、技术预研

1.我首先想到的是：不配置url 
2019-11-22 16:16:27.268 ERROR 90476 --- [           main] o.s.b.d.LoggingFailureAnalysisReporter   : 

***************************
APPLICATION FAILED TO START
***************************

Description:

Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.

Reason: Failed to determine a suitable driver class

这里表示如果需要spring容器管理dataSource就必须在配置文件中配置一个数据源，但是与我的需求不符合，失败。

2.然后我就想如果我排除spring自动配置数据源 
@SpringBootApplication(exclude = {DruidDataSourceAutoConfigure.class,
                                  DataSourceAutoConfiguration.class})

但是这里也存在一个问题，通过自动装配实现的mapper无法被识别和实例化，需要自己全部接管所有的sqlBeanFactory，这简直是一个灾难，所以这个宣告失败。

3.使用sqlite数据库当做默认数据库，让springboot帮我自动装配，然后调用接口的时候把这个bean从容器中移除

sqlite是一个文件，可以放在项目中，不需要开启服务，连接就能用，很方便，这个宣告成功，实现代码如下。

三、实现思路

  1. 在启动方法处获取spring上下文
  2. 注入到SpringContextUtil中
  3. 通过@Bean注入MyDynamicDataSource配置到容器中，并设置默认的数据源
  4. 重写AbstractRoutingDataSource类的determineCurrentLookupKey方法，实现数据源的切换
  5. ThreadLocal 保证当前线程安全的前提下设置当前线程的数据源

四、代码实现

  1. 配置文件配置
server.port=8081
server.tomcat.uri-encoding=utf-8
#指定连接地址和数据库
spring.datasource.url=jdbc:sqlite:classpath:static/defaultDataBase/default.db
spring.datasource.driver-class-name=org.sqlite.JDBC
#指定数据源为druid
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource 

# 如果没有进行第三步3的配置，下面的属性是不会生效的
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
spring.datasource.maxWait=6000
spring.datasource.timeBetweenEvictionRunsMillis=6000
spring.datasource.minEvictableIdleTimeMillis=30000
spring.datasource.validationQuery=SELECT 1 FROM DUAL
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
spring.datasource.poolPreparedStatements=true

# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
#filters=stat,wall,log4j
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
spring.datasource.useGlobalDataSourceStat=true
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

# 指定全局配置文件的位置
mybatis.config-location=classpath:mybatis-config.xml
# 指定sql映射文件的位置
mybatis.mapper-locations=classpath:mappers/*.xml
2.pom引入 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.infosec</groupId>
    <artifactId>sra</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SRA</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.51</version>
        </dependency>

        <!--aop-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <!-- swagger -->
        <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>com.gizwits</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>

        <!-- 阿里连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!--mappers-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--ojdbc7驱动 -->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc7</artifactId>
            <version>12.1.0.2.2</version>
            <scope>system</scope>
            <systemPath>${pom.basedir}/src/main/resources/static/lib/ojdbc7-12.1.0.2.jar
            </systemPath>
        </dependency>
        <!--sqlite驱动-->
        <dependency>
            <groupId>org.xerial</groupId>
            <artifactId>sqlite-jdbc</artifactId>
            <version>3.23.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

这里有一个问题如果druid版本太低会出现以下的异常，解决办法是提高版本

Caused by: java.lang.NoClassDefFoundError: org/springframework/boot/autoconfigure/jdbc/metadata/DataSourcePoolMetadataProvider
 at java.lang.Class.getDeclaredMethods0(Native Method) ~[na:1.8.0_201]
 at java.lang.Class.privateGetDeclaredMethods(Class.java:2701) ~[na:1.8.0_201]
 at java.lang.Class.getDeclaredMethods(Class.java:1975) ~[na:1.8.0_201]
  1. druid配置类
package com.infosec.ra.configuration;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import com.infosec.ra.common.MyDynamicDataSource;
import com.infosec.ra.filter.SrmFilter;
import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;

import java.util.HashMap;

import java.util.Map;

@Slf4j
@Configuration
public class DruidConfig {


    /**
     * @return
     * @Bean 防止数据监控报错，无法查看数据源
     * @ConfigurationProperties 会把配置文件的参数自动赋值到dataSource里。
     * @Primary 用于标识默认使用的 DataSource Bean
     */
    @Bean(name = "masterDataSource")
    @ConfigurationProperties(prefix = "spring.datasource")
    @Primary
    public DataSource masterDataSource() {
        log.info("创建masterDataSource");
        //DruidDataSource druidDataSource = new DruidDataSource();
        DruidDataSource druidDataSource = DruidDataSourceBuilder.create().build();
        return druidDataSource;
    }

    @Bean(name = "dynamicDataSource")
    public DataSource dynamicDataSource() {
        MyDynamicDataSource myDynamicDataSource = new MyDynamicDataSource();
        // 配置多数据源
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("master", masterDataSource());
        myDynamicDataSource.setTargetDataSources(targetDataSources);
        return myDynamicDataSource;

    }



    /**
     * 配置 SqlSessionFactoryBean
     */
    @Bean(value = "sqlSessionFactoryBeanTest")
    @ConfigurationProperties(prefix = "mappers")
    public SqlSessionFactoryBean sqlSessionFactoryBean() {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        // 配置数据源，此处配置为关键配置，如果没有将 dynamicDataSource 作为数据源则不能实现切换
        sqlSessionFactoryBean.setDataSource(dynamicDataSource());
        return sqlSessionFactoryBean;

    }



    /**
     * 注入 DataSourceTransactionManager 用于事务管理
     */
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dynamicDataSource());
    }



    @Bean
    public ServletRegistrationBean statViewServlet() {
        //创建servlet注册实体
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        //设置ip白名单
        servletRegistrationBean.addInitParameter("allow", "");
        //设置ip黑名单
        servletRegistrationBean.addInitParameter("deny", "");
        //设置控制台管理用户__登录用户名和密码
        servletRegistrationBean.addInitParameter("loginUsername", "druid");
        servletRegistrationBean.addInitParameter("loginPassword", "123456");

        //是否可以重置数据
        servletRegistrationBean.addInitParameter("resetEnable", "false");
        return servletRegistrationBean;

    }

    /**
     * druid过滤器
     *
     * @return
     */
    @Bean
    public FilterRegistrationBean druidFilter() {

        //创建过滤器
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        //设置过滤器过滤路径
        filterRegistrationBean.addUrlPatterns("/*");
        //忽略过滤的形式
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.png,*.css,*.ico,/druid/*");
        return filterRegistrationBean;
    }

}
  1. 启动类

我这里是在windows开发，然后正式环境实在linux上的，所以为了避免频繁修改配置文件，我通过System类获取操作系统类型，判断是开发还是正式环境，自动切换配置文件。

package com.infosec.ra;

import com.infosec.ra.util.DataSourceUtil;
import com.infosec.ra.util.SpringContextUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.ConfigurableApplicationContext;

import java.util.Map;

@Slf4j
@SpringBootApplication
public class SraApplication extends SpringBootServletInitializer {

    //环境变量OS对应操作系统
    private static final String OS = "OS";
    //项目所处操作系统环境为windows
    private static final String WINDOWS = "Windows";
    //项目为开发环境
    private static final String DEVELOP = "develop";
    //项目为测试环境
    private static final String PRODUCT = "product";

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SraApplication.class).profiles(getProfile());
    }

    private static String getProfile(){
        //获取系统环境变量
        Map<String, String> env = System.getenv();
        //获取操作系统类型，支持windows和linux
        String profile = (env != null && env.get(OS).contains(WINDOWS) ? DEVELOP : PRODUCT);
        return profile;
    }

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = new SpringApplicationBuilder().sources(SraApplication.class).profiles(getProfile()).run(args);
        log.info("SpringBoot启动成功");
        SpringContextUtil.setApplicationContext(applicationContext);
        DataSourceUtil.initDataSource();
    }

}
5.数据源工具类 
package com.infosec.ra.util;




import com.alibaba.druid.pool.DruidDataSource;
import com.infosec.ra.common.MyDynamicDataSource;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
import java.util.Map;

/**
 * 初始化和添加数据源
 */
@Slf4j
public class DataSourceUtil {



    public static final Map<Object, Object> dataSourceMap = new HashMap<>();



    public static void initDataSource() {
        //获取masterDataSource
        DruidDataSource masterDataSource = (DruidDataSource) SpringContextUtil.getBean("masterDataSource");
        addDataSource("master", masterDataSource);
        //初始化其它数据源
        //initOthersDataSource();

        //刷新数据源
        flushDataSource();

    }



    public static void flushDataSource() {

        //获取spring管理的dynamicDataSource
        MyDynamicDataSource myDynamicDataSource = (MyDynamicDataSource) SpringContextUtil.getBean("dynamicDataSource");
        //将数据源设置到 targetDataSources
        myDynamicDataSource.setTargetDataSources(dataSourceMap);
        //将 targetDataSources 中的连接信息放入 resolvedDataSources 管理
        myDynamicDataSource.afterPropertiesSet();

    }



    public static void addDataSource(String key, DruidDataSource masterDataSource) {
        dataSourceMap.put(key, masterDataSource);
    }



    private static void initOthersDataSource() {
        //在此处可以查询出所有的数据源（例如，配置文件，数据库）然后添加
        String key = "slave";
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("123456");
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://10.100.61.160:3306/db1");
        //添加数据源到map
        addDataSource(key, druidDataSource);
    }

}
  1. spring上下文工具类
package com.infosec.ra.util;

import org.springframework.context.ApplicationContext;



public class SpringContextUtil {
    private static ApplicationContext applicationContext;



    //获取上下文
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }



    //设置上下文

    public static void setApplicationContext(ApplicationContext applicationContext) {
        SpringContextUtil.applicationContext = applicationContext;
    }



    //通过名字获取上下文中的bean
    public static Object getBean(String name) {
        return applicationContext.getBean(name);
    }



    //通过类型获取上下文中的bean
    public static Object getBean(Class<?> requiredType) {
        return applicationContext.getBean(requiredType);
    }

}
  1. 动态数据源MyDynamicDataSource
package com.infosec.ra.common;


import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.util.StringUtils;


@Slf4j
public class MyDynamicDataSource extends AbstractRoutingDataSource {

    @Override
    public Object determineCurrentLookupKey() {

        //获取当前线程的数据源，如果不存在使用master数据源
        String datasource = DBContextHolder.getDataSource();
        if (StringUtils.isEmpty(datasource)) {
            datasource = "master";

        }
        logger.info("datasource=" + datasource);
        return datasource;

    }

}
8.数据源切换类 
package com.infosec.ra.common;


import com.infosec.ra.util.DataSourceUtil;

public class DBContextHolder {

    // 对当前线程的操作-线程安全的
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();

    // 调用此方法，切换数据源
    public static void setDataSource(String dataSource) {
        if (DataSourceUtil.dataSourceMap.containsKey(dataSource)) {
            contextHolder.set(dataSource);
        } else {
            throw new RuntimeException("数据源:" + dataSource + "不存在");
        }
    }

    // 获取数据源
    public static String getDataSource() {
        return contextHolder.get();

    }

    // 删除数据源
    public static void clearDataSource() {
        contextHolder.remove();
    }

}
9.mapper类 
package com.infosec.ra.mapper;

import com.infosec.ra.entity.Role;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface RoleMapper {
    @Select("select * from ROLE")
    List<Role> getRoles();
}
10.controller类 
package com.infosec.ra.controller;

import com.alibaba.druid.pool.DruidDataSource;
import com.infosec.ra.common.DBContextHolder;
import com.infosec.ra.entity.Role;
import com.infosec.ra.mapper.RoleMapper;
import com.infosec.ra.util.DataSourceUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

@RestController
public class DataSourceController {

    @Autowired
    private RoleMapper roleMapper;

    @GetMapping("/role")
    public List<Role> getRoles(){
        //double random = Math.random();
        /*if((random*10)%2==0){
            DBContextHolder.setDataSource("master");
        }else{
            DBContextHolder.setDataSource("slave2");
        }*/
        DBContextHolder.setDataSource("master");
        return roleMapper.getRoles();
    }

    @GetMapping("/roles")
    public List<Role> getRoless(){
        DBContextHolder.setDataSource("slave2");
        return roleMapper.getRoles();
    }

    @PostMapping("/test")
    public String addDataSource(String token,String userName,String password,String driver,String url,String key){
        Map<String, String> map = new HashMap<>();
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUsername(userName);
        druidDataSource.setPassword(password);
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        //添加数据源到map
         DataSourceUtil.addDataSource(key, druidDataSource);
        // 刷新
        DataSourceUtil.flushDataSource();
        map.put("msg", "数据源数量:" + DataSourceUtil.dataSourceMap.size());

        return "添加成功："+DataSourceUtil.dataSourceMap.size();
    }
}

五、结果展示

  1. 刚启动，前端没有配置数据源，所以看不到数据源

db8ffed49978da2d5a1a0d12bfdf0165.png
2.通过swagger调用接口，配置数据源

再加一个mybatits数据库

d76da4ea37060fa6608ed6234f58e505.png 
userName: root
pwd: 123456
driver: com.mysql.jdbc.Driver
url: jdbc:mysql://10.100.61.160:3306/db1
key: master
  1. 再次查看数据源,可以在数据源中找到两个，一个是mysql，一个是oracle

425e38fdb59fefa2fd3c90afb1d81d04.png
  1. 查询结果
#mysql
[
  {
    "id": 1,
    "name": "test"
  }
]

#oracle
[
  {
    "id": 1,
    "name": "安全管理员"
  },
  {
    "id": 2,
    "name": "系统管理员"
  },
  {
    "id": 3,
    "name": "日志管理员"
  }
]

这里需要先执行查询方法，然后在数据源中才能看到刚刚添加的数据源，如果碰到问题，欢迎提问！

自我推荐

这个是我的微信公众号，欢迎扫码关注，谢谢！

1532d8cca6e529de544fbfde6eb054a6.png
weixin_39614262
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
01-12
总结起来，通过SpringBoot、Mybatis-Plus和Druid，我们可以方便地实现双数据源配置，使得应用能同时处理MySQL和Oracle数据库的数据。在实际开发中，要根据业务场景灵活切换数据源，确保数据操作的正确性和效率。同时...
springboot多数据源,DruidDataSource多数据源切换，不重启项目，修改数据库名解决方案
01-04
项目背景： 1. Springboot项目 2. 一个主数据源，数据名称库不变。 3. 一个副数据源，数据库名称每天都在...4.不重启项目切换数据源。 5.项目介绍： https://blog.csdn.net/qq_38105536/article/details/122296977
史上最全SpringBoot教程，从零开始带你深入♂学习（九）——配置Druid数据源
爱分享的板栗老哥
07-19 162
Springboot（九）——配置Druid数据源 Druid数据源简介 白嫖资料 Java程序很大一部分要操作数据库，为了提高性能操作数据库的时候，又不得不使用数据库连接池。 Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP 等 DB 池的优点，同时加入了日志监控。 Druid 可以很好的监控 DB 池连接和 SQL 的执行情况，天生就是针对监控而生的 DB 连接池。 Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。 Spring B
druid 手动指定数据源_Springboot集成 Druid
weixin_40001275的博客
11-21 641
前言对于数据访问层，无论是Sql还是NoSql，SpringBoot默认采用整合SpringData的方式进行统一管理，添加大量的自动配置，屏蔽了很多设置。引入了各种XxxTemplate和XxxRepository来简化我们队数据访问层的操作。SpringBoot2.0默认是用com.zaxxer.hikari.HikariDataSource作为数据源。2.0以下默认采用的是org.apach...
druid.properties 配置以及 Java 示例代码
最新发布
辰海的博客
04-25 301
以上是使用druid.properties文件配置Druid连接池的基本方法。根据你的具体需求，你可以添加更多的配置项来优化连接池的性能和行为。文件中，你可以添加Druid连接池的各种配置项，每个配置项由键值对的形式表示。文件：在你的项目中创建一个名为druid.properties的文件，代码如下。下面是配置Druid连接池的。文件放置在类路径下，通常是放置在。文件放置到正确的位置：将。
SpringBoot项目报错解决：“Error starting ApplicationContext. To display the conditions report re-run ...”
drnrrwfs的博客
06-12 4万+
SpringBoot项目报错：以下方案80%可以帮助您解决这些个‘可恶的’问题报错内容和截图如下： ( ( )___ | '_ | '| | ’ / ` | / )| |)| | | | | || (| | ) ) ) ) ’ || .__|| ||| |, | / / / / =========||==============|/=///_/ :: Spring Boot :: (v2.3.10.RELEASE) ——在看到这些个问题的时候，日志基本都会告诉你错误的地方，所以我们大部分
spring启动时加载外部配置并实现在不重启应用的情况下修改druid连接池的配置
weixin_42304484的博客
03-18 1520
spring启动时加载外部配置并实现在不重启应用的情况下修改druid连接池的配置
SpringBoot数据库连接池Druid报错
qq_56489154的博客
06-16 1203
Spring Boot应用程序初始化Druid连接池时发生的错误信息。
springboot+mysql+oracle+druid 双数据库进行数据同步
08-13
总的来说，这个项目展示了如何利用SpringBoot的灵活性和强大功能，结合Oracle和MySQL的特点，以及Druid的数据连接池优势，实现大规模数据的双数据库同步，同时通过流处理策略有效地避免了内存溢出的问题。...
通过springboot+mybatis+druid配置动态数据源
08-25
通过 SpringBoot、MyBatis 和 Druid 配置动态数据源是一种常见的解决方案，它可以帮助开发者轻松地管理多个数据源，并提供了动态切换数据源的能力。在本文中，我们将通过示例代码详细介绍如何使用 SpringBoot、...
SpringBoot+mybatis+Druid 运行时动态多数据源
09-18
SpringBoot、MyBatis和Druid的组合提供了一个高效且灵活的解决方案，尤其是在实现运行时动态多数据源方面。本篇文章将深入探讨如何利用这些技术来实现这一目标。 首先，**SpringBoot** 是一个基于Spring框架的高度...
在Spring框架中实现属性配置动态刷新，不需要重启应用。
架构师修炼道路
03-19 2223
相当于增加一份配置文件，它可以来源于文件或网络，这取决于你如何拿到数据。下面是一个示例，这个属性源有一个名字：myPropertySource，里面只包含了一个属性：abc_123。/*** 自定义属性源} }事实上你可以从外部网络，比如某个HTTP接口获取一堆属性值，对于你来说无非是将它们映射成KV结构。当然你用其它结构也可以，但是要保证能将一堆属性存储下来，并且能够根据名字（键）快速查找出来。/*** 自定义属性源，从HTTP接口获取配置属性集。
spring boot如何实现动态数据源
niehida的博客
10-24 1379
1,首先动态数据源需要可配置,可以动态修改,可以不需要重启相关服务器程序,达到配置修改后即及时生效. 2,所以排除了修改注解这一种方式,因为以现在的认知,注解是与代码绑定,需要修改代码,并且重新编译发布. 3,第二种xml配置,集中式管理配置,减少与代码的耦合,虽然springboot + devtools（热部署）可提供这种使应用不用重启可xml生效的能力,但不太适合提供增加的免费云数据源/服务器/虚拟主机,如原来就有的张三丰A数据源,后面动态增加B云数据,就得有三丰A,B云数据源.,数据库连接:h
druid 手动指定数据源_SpringBoot整合Mybatis+Druid
weixin_39636718的博客
11-26 334
1.SpringBoot 作为一款约定大于配置的微服务框架，得到了业界的大量推广和应用。对SpringBoot的学习使用可以有效的帮助开发简化开发流程，配置过程，部署过程。2.数据库的交互是开发过程中很常见的一种业务，数据层的接入方式众多，JDBC，Spring JdbcTemplate,Hibernate,Mybatis等等。传统的JDBC因为模板代码众多，侵入式的事物操作极容易出现问题。老牌的...
springboot+jpa异步任务事物丢失问题
u012848484的专栏
12-01 999
在springboot中使用异步任务@Async 或 使用Quartz任务调度时，出现事务丢失问题，事物丢失不会影响数据查询（SELECT），但是当进行增删改操作时，因为事物问题，无法执行结果到数据库。 使用@Transactional注解也无法注入事务。 发现问题如下： 我们在配置事务时，默认会使用DataSourceTransactionManager @Bean public DataSourceTransactionManager tra...
Springboot1.5.6整合druid（不重启项目动态添加数据源）和数据监控，附源码
阿瑟与非
09-24 8429
一、要点： 1.重写AbstractRoutingDataSource类的determineCurrentLookupKey方法，实现数据源的切换 2.ThreadLocal 保证当前线程安全的前提下设置当前线程的数据源 3.application.properties文件配置数据源为spring.datasource.type=com.alibaba.druid.pool.DruidDat...
Spring Boot 2.x 自定义数据源 DruidDataSource（操作 mysql 数据库）
热门推荐
蚩尤后裔-汪茂雄
08-20 8万+
目录 DRUID 简介 配置参数 自定义数据源 Druid 引入数据源 切换 Druid 数据源 配置 Druid 数据源参数 配置 Druid 数据源监控 配置 Druid 后台管理 Servlet 配置 Druid web 监控 filter DRUID 简介 1、Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP、PROXOOL 等 DB ...
spring boot 源码解析25-DataSourcePoolMetadata与DataSourcePoolMetadataProvider
qq_26000415的博客
01-15 1万+
前言我们在上篇文章 spring boot 源码解析24-HealthEndpoint解析中 在解析DataSourceHealthIndicator的时候发现其使用到了DataSourcePoolMetadataProviders.我们就在本文中分析一下吧,还是比较简单的解析spring boot 中 关于jdbc metadata的实现都在org.springframework.boot.aut
数据库连接池_DataSource_数据源（简单介绍C3P0和Druid）
liaowenxiong的博客
11-18 3507
文章目录概念好处实现C3P0基本使用配置文件druid下载 jar 包演示代码定义工具类示例代码 概念 数据库连接池其实就是一个容器，而这个容器其实就是一个集合，这个集合存放着多个数据库连接对象。 系统在初始化的时候，将创建一定数量的数据库连接放到连接池中。当应用程序要访问数据库的时候，会向连接池请求连接对象，访问结束后会将连接对象还给连接池。当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。 好处 节约资源 数据库访问高效 实现 标准接口：DataSource，在 javax
druid 多数据源_Springboot+mybatis(plus)+druid多数据源
05-14
在Spring Boot项目中使用MyBatis Plus和Druid多数据源的步骤如下： 1. 添加依赖 在`pom.xml`文件中添加以下依赖： ```xml <!-- MyBatis Plus --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.3.1</version> </dependency> <!-- Druid --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.2.6</version> </dependency> ``` 2. 配置Druid数据源 在`application.yml`中添加Druid数据源的配置： ```yaml spring: datasource: # 主数据源 druid: url: jdbc:mysql://localhost:3306/main_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8 username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver # Druid配置 initialSize: 5 minIdle: 5 maxActive: 20 testOnBorrow: false testOnReturn: false testWhileIdle: true timeBetweenEvictionRunsMillis: 60000 validationQuery: SELECT 1 FROM DUAL # 从数据源 druid2: url: jdbc:mysql://localhost:3306/sub_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8 username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver # Druid配置 initialSize: 5 minIdle: 5 maxActive: 20 testOnBorrow: false testOnReturn: false testWhileIdle: true timeBetweenEvictionRunsMillis: 60000 validationQuery: SELECT 1 FROM DUAL ``` 3. 配置MyBatis Plus 在`application.yml`中添加MyBatis Plus的配置： ```yaml mybatis-plus: # 主数据源配置 mapper-locations: classpath:mapper/main/*.xml type-aliases-package: com.example.main.entity global-config: db-config: id-type: auto field-strategy: not_empty logic-delete-value: 1 logic-not-delete-value: 0 configuration: map-underscore-to-camel-case: true log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 从数据源配置 multi-datasource: main: mapper-locations: classpath:mapper/main/*.xml type-aliases-package: com.example.main.entity sub: mapper-locations: classpath:mapper/sub/*.xml type-aliases-package: com.example.sub.entity ``` 4. 配置数据源路由 在`com.example.config`包下创建`DynamicDataSourceConfig`类，用于配置数据源路由： ```java @Configuration public class DynamicDataSourceConfig { @Bean @ConfigurationProperties("spring.datasource.druid") public DataSource mainDataSource() { return DruidDataSourceBuilder.create().build(); } @Bean @ConfigurationProperties("spring.datasource.druid2") public DataSource subDataSource() { return DruidDataSourceBuilder.create().build(); } @Bean public DataSource dynamicDataSource() { DynamicDataSource dynamicDataSource = new DynamicDataSource(); Map<Object, Object> dataSourceMap = new HashMap<>(2); dataSourceMap.put("main", mainDataSource()); dataSourceMap.put("sub", subDataSource()); // 将主数据源作为默认数据源 dynamicDataSource.setDefaultTargetDataSource(mainDataSource()); dynamicDataSource.setTargetDataSources(dataSourceMap); return dynamicDataSource; } @Bean public SqlSessionFactory sqlSessionFactory() throws Exception { MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean(); sqlSessionFactoryBean.setDataSource(dynamicDataSource()); sqlSessionFactoryBean.setTypeAliasesPackage("com.example.main.entity"); sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/main/*.xml")); return sqlSessionFactoryBean.getObject(); } @Bean public SqlSessionTemplate sqlSessionTemplate() throws Exception { return new SqlSessionTemplate(sqlSessionFactory()); } } ``` 5. 配置数据源切换 在`com.example.config`包下创建`DynamicDataSource`类，用于实现数据源切换： ```java public class DynamicDataSource extends AbstractRoutingDataSource { @Override protected Object determineCurrentLookupKey() { return DataSourceContextHolder.getDataSource(); } } ``` 在`com.example.config`包下创建`DataSourceContextHolder`类，用于存储当前数据源： ```java public class DataSourceContextHolder { private static final ThreadLocal<String> DATASOURCE_CONTEXT_HOLDER = new ThreadLocal<>(); public static void setDataSource(String dataSource) { DATASOURCE_CONTEXT_HOLDER.set(dataSource); } public static String getDataSource() { return DATASOURCE_CONTEXT_HOLDER.get(); } public static void clearDataSource() { DATASOURCE_CONTEXT_HOLDER.remove(); } } ``` 在`com.example.aop`包下创建`DataSourceAspect`类，用于切换数据源： ```java @Aspect @Component public class DataSourceAspect { @Pointcut("@annotation(com.example.annotation.DataSource)") public void dataSourcePointCut() { } @Before("dataSourcePointCut()") public void before(JoinPoint joinPoint) { MethodSignature signature = (MethodSignature) joinPoint.getSignature(); DataSource dataSource = signature.getMethod().getAnnotation(DataSource.class); if (dataSource != null) { String value = dataSource.value(); DataSourceContextHolder.setDataSource(value); } } @After("dataSourcePointCut()") public void after(JoinPoint joinPoint) { DataSourceContextHolder.clearDataSource(); } } ``` 6. 使用多数据源 在需要使用从数据源的方法上加上`@DataSource("sub")`注解，如： ```java @Service public class UserServiceImpl implements UserService { @Autowired private UserMapper userMapper; @Override public List<User> listUsers() { DataSourceContextHolder.setDataSource("sub"); List<User> users = userMapper.selectList(null); DataSourceContextHolder.clearDataSource(); return users; } } ``` 这样就完成了Spring Boot项目中使用MyBatis Plus和Druid多数据源的配置。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值