SpringBoot使用阿里数据库连接池Druid以及多数据源配置

最新推荐文章于 2024-07-09 15:13:39 发布
最新推荐文章于 2024-07-09 15:13:39 发布
阅读量1k 收藏 2
点赞数
文章标签： java 数据库 python
原文链接：https://my.oschina.net/lengchuan/blog/876429
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

SpringBoot使用阿里数据库连接池Druid以及多数据源配置

相关代码: github OSCchina

引入依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.29</version>
</dependency>

数据源配置

  • 1.数据源
    #master数据源
    spring.datasource.master.url=jdbc:mysql://localhost:3306/SpringBootMaster
    spring.datasource.master.username=root
    spring.datasource.master.password=1
    spring.datasource.master.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.master.masterMapperLocations=classpath:mapper/master/*.xml
    
    
    #cluster数据源
    spring.datasource.cluster.url=jdbc:mysql://localhost:3306/SpringBootCluster
    spring.datasource.cluster.username=root
    spring.datasource.cluster.password=1
    spring.datasource.cluster.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.cluster.clusterMapperLocations=classpath:mapper/cluster/*.xml
    
    
    #cluster1数据源
    spring.datasource.cluster1.url=jdbc:mysql://localhost:3306/SpringBootCluster1
    spring.datasource.cluster1.username=root
    spring.datasource.cluster1.password=1
    spring.datasource.cluster1.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.cluster1.clusterMapperLocations=classpath:mapper/cluster1/*.xml

master数据源:

    @Configuration
    @MapperScan(basePackages = {"com.lc.springBoot.druid.mapper.master"},
            sqlSessionFactoryRef = "masterSqlSessionFactory")
    public class MasterDruidDataSourceConfig {
    
        @Value("${spring.datasource.master.masterMapperLocations}")
        private String masterMapperLocations;
    
        @ConfigurationProperties(prefix = "spring.datasource.master")
        @Bean(name = "masterDataSource")
        @Primary
        public DataSource masterDataSource() {
            return new DruidDataSource();
        }
    
        /**
         * SqlSessionFactory配置
         *
         * @return
         * @throws Exception
         */
        @Bean(name = "masterSqlSessionFactory")
        @Primary
        public SqlSessionFactory masterSqlSessionFactory(
                @Qualifier("masterDataSource") DataSource dataSource
        ) throws Exception {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            sqlSessionFactoryBean.setDataSource(dataSource);
    
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            // 配置mapper文件位置
            sqlSessionFactoryBean.setMapperLocations(resolver.getResources(masterMapperLocations));
    
            //配置分页插件
            PageHelper pageHelper = new PageHelper();
            Properties properties = new Properties();
            properties.setProperty("reasonable", "true");
            properties.setProperty("supportMethodsArguments", "true");
            properties.setProperty("returnPageInfo", "check");
            properties.setProperty("params", "count=countSql");
            pageHelper.setProperties(properties);
    
            //设置插件
            sqlSessionFactoryBean.setPlugins(new Interceptor[]{pageHelper});
            return sqlSessionFactoryBean.getObject();
        }
    
        /**
         * 配置事物管理器
         *
         * @return
         */
        @Bean(name = "masterTransactionManager")
        @Primary
        public DataSourceTransactionManager masterTransactionManager(
                @Qualifier("masterDataSource") DataSource dataSource
        ) {
            DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
            dataSourceTransactionManager.setDataSource(dataSource);
            return dataSourceTransactionManager;
        }
    }

cluster数据源:

    @Configuration
    @MapperScan(basePackages = {"com.lc.springBoot.druid.mapper.cluster"},
            sqlSessionFactoryRef = "clusterSqlSessionFactory")
    public class ClusterDruidDataSourceConfig {
    
        @Value("${spring.datasource.cluster.clusterMapperLocations}")
        private String clusterMapperLocations;
    
        @ConfigurationProperties(prefix = "spring.datasource.cluster")
        @Bean(name = "clusterDataSource")
        public DataSource clusterDataSource() {
            return new DruidDataSource();
        }
    
        /**
         * SqlSessionFactory配置
         *
         * @return
         * @throws Exception
         */
        @Bean(name = "clusterSqlSessionFactory")
        public SqlSessionFactory clusterSqlSessionFactory(
                @Qualifier("clusterDataSource") DataSource dataSource
        ) throws Exception {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            sqlSessionFactoryBean.setDataSource(dataSource);
    
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            //配置mapper文件位置
            sqlSessionFactoryBean.setMapperLocations(resolver.getResources(clusterMapperLocations));
    
            //配置分页插件
            PageHelper pageHelper = new PageHelper();
            Properties properties = new Properties();
            properties.setProperty("reasonable", "true");
            properties.setProperty("supportMethodsArguments", "true");
            properties.setProperty("returnPageInfo", "check");
            properties.setProperty("params", "count=countSql");
            pageHelper.setProperties(properties);
    
            //设置插件
            sqlSessionFactoryBean.setPlugins(new Interceptor[]{pageHelper});
            return sqlSessionFactoryBean.getObject();
        }
    
        /**
         * 配置事物管理器
         *
         * @return
         */
        @Bean(name = "clusterTransactionManager")
        public DataSourceTransactionManager clusterTransactionManager(
                @Qualifier("clusterDataSource") DataSource dataSource
        ) {
            DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
            dataSourceTransactionManager.setDataSource(dataSource);
            return dataSourceTransactionManager;
        }
    }

cluster1数据源:

    @Configuration
    @MapperScan(basePackages = {"com.lc.springBoot.druid.mapper.cluster1"},
            sqlSessionFactoryRef = "cluster1SqlSessionFactory")
    public class Cluster1DruidDataSourceConfig {
    
        @Value("${spring.datasource.cluster1.clusterMapperLocations}")
        private String cluster1MapperLocations;
    
        @ConfigurationProperties(prefix = "spring.datasource.cluster1")
        @Bean(name = "cluster1DataSource")
        public DataSource cluster1DataSource() {
            return new DruidDataSource();
        }
    
        /**
         * SqlSessionFactory配置
         *
         * @return
         * @throws Exception
         */
        @Bean(name = "cluster1SqlSessionFactory")
        public SqlSessionFactory cluster1SqlSessionFactory(
                @Qualifier("cluster1DataSource") DataSource dataSource
        ) throws Exception {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            sqlSessionFactoryBean.setDataSource(dataSource);
    
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            //配置mapper文件位置
            sqlSessionFactoryBean.setMapperLocations(resolver.getResources(cluster1MapperLocations));
    
            //配置分页插件
            PageHelper pageHelper = new PageHelper();
            Properties properties = new Properties();
            properties.setProperty("reasonable", "true");
            properties.setProperty("supportMethodsArguments", "true");
            properties.setProperty("returnPageInfo", "check");
            properties.setProperty("params", "count=countSql");
            pageHelper.setProperties(properties);
    
            //设置插件
            sqlSessionFactoryBean.setPlugins(new Interceptor[]{pageHelper});
            return sqlSessionFactoryBean.getObject();
        }
    
        /**
         * 配置事物管理器
         *
         * @return
         */
        @Bean(name = "cluster1TransactionManager")
        public DataSourceTransactionManager cluster1TransactionManager(
                @Qualifier("cluster1DataSource") DataSource dataSource
        ) {
            DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
            dataSourceTransactionManager.setDataSource(dataSource);
            return dataSourceTransactionManager;
        }
    }

  • 2.相关注解说明

    @MapperScan:basePackages属性配置需要扫描的mybatis的mapper文件位置,sqlSessionFactory属性配置具体的 sqlSessionFactory.

    @ConfigurationProperties:读取并且设置我们在application.properties配置的内容.

    @Primary:这个注解用来标识当存在多个相同的类型的bean时,优先选用哪个bean注入,需要注意的是,配置多数据源的时候,必须有一个且只能有一个@Primary注解.

读写分离实现

read数据源配置

    @Configuration
    @MapperScan(basePackages = {"com.lc.springBoot.druid.mapper.read1"},
            sqlSessionFactoryRef = "read1SqlSessionFactory")
    public class Read1DruidDataSourceConfig {
    
        @Value("${spring.datasource.read1.read1MapperLocations}")
        private String read1MapperLocations;
    
        @ConfigurationProperties(prefix = "spring.datasource.read1")
        @Bean(name = "read1DataSource")
        public DataSource read1DataSource() {
            return new DruidDataSource();
        }
    
        /**
         * SqlSessionFactory配置
         *
         * @return
         * @throws Exception
         */
        @Bean(name = "read1SqlSessionFactory")
        public SqlSessionFactory read1SqlSessionFactory(
                @Qualifier("read1DataSource") DataSource dataSource
        ) throws Exception {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            sqlSessionFactoryBean.setDataSource(dataSource);
    
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            // 配置mapper文件位置
            sqlSessionFactoryBean.setMapperLocations(resolver.getResources(read1MapperLocations));
    
            //配置分页插件
            PageHelper pageHelper = new PageHelper();
            Properties properties = new Properties();
            properties.setProperty("reasonable", "true");
            properties.setProperty("supportMethodsArguments", "true");
            properties.setProperty("returnPageInfo", "check");
            properties.setProperty("params", "count=countSql");
            pageHelper.setProperties(properties);
    
            //设置插件
            sqlSessionFactoryBean.setPlugins(new Interceptor[]{pageHelper});
            return sqlSessionFactoryBean.getObject();
        }
    
        /**
         * 配置事物管理器
         *
         * @return
         */
        @Bean(name = "read1TransactionManager")
        public DataSourceTransactionManager read1TransactionManager(
                @Qualifier("read1DataSource") DataSource dataSource
        ) {
            DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
            dataSourceTransactionManager.setDataSource(dataSource);
            return dataSourceTransactionManager;
        }
    }

write数据源配置

    @Configuration
    @MapperScan(basePackages = {"com.lc.springBoot.druid.mapper.write"},
            sqlSessionFactoryRef = "writeSqlSessionFactory")
    public class WriteDruidDataSourceConfig {
    
        @Value("${spring.datasource.write.writeMapperLocations}")
        private String writeMapperLocations;
    
        @ConfigurationProperties(prefix = "spring.datasource.write")
        @Bean(name = "writeDataSource")
        public DataSource writeDataSource() {
            return new DruidDataSource();
        }
    
        /**
         * SqlSessionFactory配置
         *
         * @return
         * @throws Exception
         */
        @Bean(name = "writeSqlSessionFactory")
        public SqlSessionFactory writeSqlSessionFactory(
                @Qualifier("writeDataSource") DataSource dataSource
        ) throws Exception {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            sqlSessionFactoryBean.setDataSource(dataSource);
    
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            // 配置mapper文件位置
            sqlSessionFactoryBean.setMapperLocations(resolver.getResources(writeMapperLocations));
            return sqlSessionFactoryBean.getObject();
        }
    
        /**
         * 配置事物管理器
         *
         * @return
         */
        @Bean(name = "writeTransactionManager")
        public DataSourceTransactionManager writeTransactionManager(
                @Qualifier("writeDataSource") DataSource dataSource
        ) {
            DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
            dataSourceTransactionManager.setDataSource(dataSource);
            return dataSourceTransactionManager;
        }
    }

自定义注入AbstractRoutingDataSource

    @Configuration
    public class DataSourceConfig {
    
        private final static String WRITE_DATASOURCE_KEY = "writeDataSource";
        private final static String READ1_DATASOURCE_KEY = "read1DataSource";
        private final static String READ2_DATASOURCE_KEY = "read2DataSource";
    
        @Bean
        public AbstractRoutingDataSource routingDataSource(
                @Qualifier("writeDataSource") DataSource  writeDataSource,
                @Qualifier("read1DataSource") DataSource  read1DataSource,
                @Qualifier("read2DataSource") DataSource  read2DataSource
        ) {
            DynamicDataSource dataSource = new DynamicDataSource();
            Map<Object, Object> targetDataSources = new HashMap();
            targetDataSources.put(WRITE_DATASOURCE_KEY, writeDataSource);
            targetDataSources.put(READ1_DATASOURCE_KEY, read1DataSource);
            targetDataSources.put(READ2_DATASOURCE_KEY, read2DataSource);
            dataSource.setTargetDataSources(targetDataSources);
            dataSource.setDefaultTargetDataSource(writeDataSource);
            return dataSource;
        }
    }

自定义注解

    @Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface TargetDataSource {
        String dataSource() default "";//数据源
    }

使用ThreadLocal使数据源与线程绑定

    public class DynamicDataSourceHolder {
        //使用ThreadLocal把数据源与当前线程绑定
        private static final ThreadLocal<String> dataSources = new ThreadLocal<String>();
    
        public static void setDataSource(String dataSourceName) {
            dataSources.set(dataSourceName);
        }
    
        public static String getDataSource() {
            return (String) dataSources.get();
        }
    
        public static void clearDataSource() {
            dataSources.remove();
        }
    }

    public class DynamicDataSource extends AbstractRoutingDataSource {
        @Override
        protected Object determineCurrentLookupKey() {
    
            //可以做一个简单的负载均衡策略
            String lookupKey = DynamicDataSourceHolder.getDataSource();
            System.out.println("------------lookupKey---------"+lookupKey);
    
            return lookupKey;
        }
    }

定义切面

    @Aspect
    @Component
    public class DynamicDataSourceAspect {
        @Around("execution(public * com.lc.springBoot.druid.service..*.*(..))")
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
            MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
            Method targetMethod = methodSignature.getMethod();
            if (targetMethod.isAnnotationPresent(TargetDataSource.class)) {
                String targetDataSource = targetMethod.getAnnotation(TargetDataSource.class).dataSource();
                System.out.println("----------数据源是:" + targetDataSource + "------");
                DynamicDataSourceHolder.setDataSource(targetDataSource);
            }
            Object result = pjp.proceed();//执行方法
            DynamicDataSourceHolder.clearDataSource();
    
            return result;
        }
    }

注解使用

    @Service
    public class StudentService {
    
        @Autowired
        private StudentMapper studentMapper;
    
        @Transactional
        @TargetDataSource(dataSource = "writeDataSource")
        public boolean createUser(Student student) {
            studentMapper.insert(student);
    
            //事务测试
    //        int i = 1 / 0;
            return true;
        }
    
        @TargetDataSource(dataSource = "read1DataSource")
        public List<Student> getByPage(int page, int rows) {
            Page<Student> studentPage = PageHelper.startPage(page, rows, true);
            List<Student> students = studentMapper.getBypage();
            System.out.println("-------------------" + studentPage.toString() + "-----------");
            return students;
        }
    }

druid监控功能配置

配置过滤器

    /**
     * 配置过滤器,需要拦截哪些url,忽略哪些url,初始化参数等
     *
     * @author lsj <lishuijun1992@gmail.com>
     * @date 17-4-7
     */
    @WebFilter(filterName = "druidStatFilter",//过滤器名称
            urlPatterns = "/",//需要拦截的url
            initParams = {//filter初始化信息
                    //需要忽略的资源
                    @WebInitParam(name = "exclusions", value = "*.js,*.gif,*.jpg," +
                            "*.bmp,*.png,*.css,*.ico,/druid/*"),
                    @WebInitParam(name = "sessionStatEnable", value = "true"),
                    @WebInitParam(name = "profileEnable", value = "true")})
    public class DruidStatFilter extends WebStatFilter {
    }

配置servlet

//表明这是一个servlet
@WebServlet(urlPatterns = "/druid/*",//通过哪个url访问
        initParams = {
                @WebInitParam(name = "loginUsername", value = "lengchuan"),//用户名
                @WebInitParam(name = "loginPassword", value = "123456"), //密码
                @WebInitParam(name = "resetEnable", value = "true"),//是否可以重置
                // @WebInitParam(name = "allow",value = "127.0.0.1"),//白名单
                // @WebInitParam(name = "deny",value = "192.168.1.1")//黑名单
        })
public class DruidStatViewServlet extends StatViewServlet {
}

配置Spring监控

@Configuration
public class MyDruidStatInterceptor {

    private static final String[] patterns = new String[]{"com.lc.springBoot.druid.service.*"};

    @Bean
    public DruidStatInterceptor druidStatInterceptor() {
        return new DruidStatInterceptor();
    }

    /**
     * 切入点
     * @return
     */
    @Bean
    public JdkRegexpMethodPointcut druidStatPointcut() {
        JdkRegexpMethodPointcut druidStatPointcut = new JdkRegexpMethodPointcut();
        druidStatPointcut.setPatterns(patterns);
        return druidStatPointcut;
    }

    /**
     * 配置aop
     * @return
     */
    @Bean
    public Advisor druidStatAdvisor() {
        return new DefaultPointcutAdvisor(druidStatPointcut(), druidStatInterceptor());
    }
}

访问监控页面

配置完成后启动项目,访问loccalhost:8080/druid/就可以看到我们的监控页面了,用户名配置的是lengchuan,密码是123456这里需要注意的是,我们只有在
执行了一次数据库操作后,才能获取到我们的数据源信息.

转载于:https://my.oschina.net/lengchuan/blog/876429

weixin_34391854
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
druid多数据源配置
KuangJvm的博客
03-28 1万+
druid多数据源配置
SpringBoot开发案例之配置Druid数据库连接池的示例
08-27
SpringBoot开发案例之配置Druid数据库连接池的示例 在本篇文章中，我们将学习如何在Spring Boot应用程序中配置Druid数据库连接池。Druid是一个来自阿里系的开源连接池，提供了非常优秀的监控功能。我们将了解如何在...
SpringBoot+Druid+Mybatis配置多数据源
weixin_33824363的博客
08-18 505
我们在开发一个项目的时候，可能会遇到需要对多个数据库进行读写的需求，这时候就得在项目中配置多个数据源了。在Java项目的开发中，目前最常用的数据操作框架是 Mybatis，开发框架也都基本用上了SpringBoot。而Druid号称最好的数据库连接池，自然也是被广泛使用。 所以本文将演示一下，SpringBoot+Druid+Mybatis如何去配置多数据源。首先在IDEA中创建一个SpringB...
SpringBoot+dynamic+druid的多数据源配置
最新发布
qq_74842675的博客
07-09 448
多数据源加载Mapper.xml文件
阿里云Druid连接池配置多个数据源 SSM框架
akuq88038的博客
04-26 953
1.创建一个类,使用注解的形式，方便使用，该注解使用在Service层 @Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface DataSource { String value(); } 2.创建一个切面方法，用于拦截...
Spring Boot 之 Druid 多数据源配置
bluemysky的博客
11-13 3658
Spring Boot 之 Druid 多数据源配置
springboot整合druid连接池、mybatis实现多数据源动态切换
weixin_30820077的博客
07-31 410
demo环境： JDK 1.8 ，Spring boot 1.5.14 一 整合durid 1.添加druid连接池maven依赖 　 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> ...
SpringBoot使用Druid数据源的配置方法
08-27
Spring Boot 使用 Druid 数据源的配置方法是指在 Spring Boot 项目中配置 Druid 数据源的步骤，Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP、PROXOOL 等 DB 池的优点，同时加入了日志监控，...
SpringBoot+mybatis+Druid 运行时动态多数据源
09-18
**Druid** 是阿里巴巴开源的一个数据库连接池组件，它不仅提供了基本的连接池功能，如连接验证、监控、扩展性，还具备SQL解析和执行性能优化的能力。在动态数据源的场景下，Druid的灵活性和强大的监控特性使其成为...
springboot 配置DRUID数据源的方法实例分析
08-25
SpringBoot 配置 Druid 数据源的方法实例分析 SpringBoot 是一个基于 Java 的开源框架，提供了多种方式来配置数据源...Druid 数据源提供了高性能和多功能的数据库连接池解决方案，适合大型应用程序的数据库连接需求。
springboot+mysql+oracle+druid 双数据库进行数据同步
08-13
**Druid**：Druid是阿里巴巴开源的一个数据库连接池组件，它提供了强大的监控和扩展功能。在数据同步场景下，Druid可以帮助优化数据库连接，提高数据读写效率，同时其监控能力可以帮助我们实时查看数据同步的性能...
Springboot+Mybatis+Druid多数据源配置
01-14
多数据源配置,使用了数据库连接池,并且是多数据源,分也不要多了,2分,有什么疑问可以指出,或者不足也可以一起学习
spring boot + mybatis(通用mapper) druid多数据源切换配置
08-14
1.配置数据源，2.动态数据源切换，3.注册动态数据源，4.动态数据源注解切点，5.通过切点切换数据源，6.在service层通过注解切换不同数据源，7.启动项目
Springboot+mybatis+druid多数据源配置（oracle+mybatis）
07-29
技术架构：springboot2.0 + mybatis + druid, 数据库：Oracle，Mysql 数据库分离调试，针对不同数据库情况
springboot集成druid配置多数据源连接
weixin_33841722的博客
12-27 535
2019独角兽企业重金招聘Python工程师标准>>> ...
druid多数据源配置和使用
tianjingsha_persume的博客
01-19 2535
多数据源切换
使用Druid，以jdbc方式配置多数据源
记录并分享一些日常工作和学习笔记
08-09 1534
通过以上配置和代码，你可以在Spring Boot项目中实现多数据源的使用。每个数据源都有单独的Druid配置，并通过JdbcTemplate对象进行数据库操作。如果大家遇到类似问题，欢迎评论区讨论，如有错误之处，敬请留言。
基于Druid的多数据源配置（最简单的方式）
热门推荐
记录并分享一些日常工作和学习笔记
06-30 1万+
多数据源的配置方式，只需三步搞定
SpringBoot整合Druid配置多数据源
menghuannvxia的专栏
06-07 6938
springboot项目通过druid配置多数据源
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值