精华内容
下载资源
问答
  • 本人应用场景:原来项目数据库用的mysql,后台框架用的是spring3.x+hibernate3.x(版本比较老) ,现在该项目的配套产品数据库用的是sqlserver.本以为hibernate是万能,起码能兼容主流数据库吧。实践的时候,配好数据库...

    原帖地址:http://blog.csdn.net/sinat_29774479/article/details/75642932

    本人应用场景:原来项目数据库用的mysql,后台框架用的是spring3.x+hibernate3.x(版本比较老) ,现在该项目的配套产品数据库用的是sqlserver.本以为hibernate是万能,起码能兼容主流数据库吧。实践的时候,配好数据库链接,切换驱动包,项目启动到时没有问题,但是执行HQL查询的时候报错了,还有sqlserver 的表字段时间类型用的datetime ,代码实体用java.util.date ,并注解@Temporal ,死活还是报错。奔溃,泪

    后面一想,不对啊,怎么能改数据库呢,万一在扩展一个异库套产品呢。于是疯狂的搜一个项目配置两个数据源的资料,最简单粗暴的就是关于数据源的,sessionfactory,transationManger的都多配置一份。经过一番配置之后,以为大功告成,项目一启动,各种报错,大概是说默认的sessionfactory是单例的,不同同时存在两个sessionfactory,又经过一番调节之后,发现可以配多个数据源,但是不能配多个sessionfactory.心想,妈的,人家怎么行呢?同样的是spring,又疯狂搜资料,还是没有答案。

    最后将sping和hibernate提升至4+,偶然发现,项目启动没有报错,经测试增删查改也没有错!!!

     

    注意使用hibernate这个用resource指定id注入

    @Resource(name="hibernateTemplate")
    protected HibernateTemplate hibernateTemplate;

    @Resource(name="sqlServer_hibernateTemplate")
    protected HibernateTemplate hibernateTemplate;

    展开全文
  • Java动态数据源配置、动态连接池配置、多数据源负载均衡 大家好,今天给大家推荐一自产的连接池插件。废话不多说,本文接口分为以下主题: 1. 插件开发背景; 2. 插件提供的能力; 3. 插件的使用介绍; 4. ...

    Java动态数据源配置、动态连接池配置、多数据源负载均衡

    大家好,今天给大家推荐一个自产的连接池插件。废话不多说,本文接口分为以下主题:

    1. 插件开发背景;

    2. 插件提供的能力;

    3. 插件的使用介绍;

    4. 插件的使用实例;

    5. 插件的源码。

     

    PS: 该插件已经提交到中央仓库,可以在maven配置中直接引用。截止当前时间,最新版本v1.1.0。获取该项目最新消息及源码,

    请移步: 源码地址

    <dependency>
        <groupId>com.xieahui.springboot</groupId>
        <artifactId>spring-boot-easy-connection-pool</artifactId>
        <version>1.1.0-RELEASE</version>
    </dependency>

     

    1. 插件的开发背景?

    由于公司筹建数据中台服务,数据中台服务其中有个环节需要整合数据以及对外提供数据。数据中台项目中有两个特别明确的服务,一个是进数据的服务、一个是出数据的服务。这种服务通常都有一个特点,需要对外提供各种各样的数据,由于不同类型的数据存放在不同的数据源中,所以会导致该服务需要对接多种多样的数据源。如果想要设计一套以不变应万变的数据服务,那么动态管理数据源就变得尤其重要了。常规MySql数据负载的解决方案较多,但是向我们的Clickhouse、Impala等数据库可以通用的支持动态构建数据库连接池的组件就不是特别多了。基于这个场景,我决定自研这套支持JDBC驱动、可以动态从配置文件中读取、动态从数据库中读取、可以根据业务标识手动设置的、独立的、分组的动态数据源构建连接池插件。

     

    2. 插件提供的能力?

    • 支持动态从properties中获取数据配置;
    • 支持动态从db中获取数据库配置;
    • 可根据配置动态构建连接池;
    • 可以从配置文件或db中动态构建分组连接池;
    • 分组连接池支持负载均衡策略;
      • 随机负载均衡;
      • 轮询负载均衡;
    • 支持根据实际业务动态扩展。

     

    3. 插件的使用介绍?

    插件简介

    基于上述项目背景,统一封装了多数据源连接池动态化配置插件,连接池使用的是业界号称"最快的"Hikari(SpringBoot2默认的连接池);只需在项目中引入插件,在属性文件中添加必要的数据源连接配置信息及连接池参数,就可以通过注解进而动态切换数据源;无论是读写分离、主从配置还是一主多从的数据源均可通过此动态配置生成DataSource连接池。 项目中各部分注释比较详细,对于二次开发扩展也非常方便,同时在启动过程会打印出详细的连接池配置流程以及连接池中的表信息:

     

    插件功能特点

    1. 动态支持多数据源连接池配置
    2. 理论上支持无限多个数据源连接池
    3. 通过注解切换数据源
    4. 对于数据库读写分离、一主多从等业务场景非常适用
    5. 代码逻辑简单,扩展来自原生Spring接口;注释详细,易于二次开发
    

    使用实例

    和该项目配置的实例项目 可以点击查看

    V1.1.0 - 更新说明

    主要增加如下:
     1. 更新数据库脚本;
     2. 更新注解TargetDataSource;
     3. 更新逻辑指定配置DynamicDbSource; 
     4. 增加数据源连接分组;
     5. 增加负载均衡策略:
        A. 随机负载均衡策略;
        B. 轮询负载均衡策略;

    新增功能演示实例

    该版本对应的演示实例:

    easy-connection-pool-demo -> easy-jdbctemplate -> com.xieahui.easy.jdbctemplate.controller.GroupDSController

    链接为: GroupDSController.java

    更新数据库脚本

    新增分组名称字段group_name、负载均衡类型字段balance_type、增加连接池名称pool_name非空唯一限制。 脚本路径:

    resources->script->db_entity.sql

    更新注解TargetDataSource

    更新注解TargetDataSource适配分组、负载逻辑; 新增注解配置分组groupName、注解配置连接池名称poolName、注解配置负载均衡策略balanceType

    更新逻辑指定配置DynamicDbSource

    更新逻辑指定配置DynamicDbSource适配分组、负载逻辑; 新增指定(分组名称)方法setGroupName、指定(分组,具体数据源名称)方法setGroupNamePoolName、指定(分组,数据源名称,负载策略)方法setGroupNamePoolNameBalanceType

    增加数据源连接分组

    数据源加载优先级:

    db -> properties

    数据源使用优先级:

    properties -> properties-group -> db -> db-group

    增加负载均衡策略

    分组后会涉及到分组数据源的选取策略,1.1.0版本实现了随机、轮询两种较常见的负载均衡策略。默认使用轮询策略。

    V1.0.1 - 更新说明

    新增从默认数据库中获取数据源连接信息,使用说明。

    1. 开启从数据库中加载数据源属性设置:

    spring.datasource.db.open=true

    2. 创建数据库数据源表

    最新脚本路径:

    resources->script->db_entity.sql
    CREATE TABLE `db_entity` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `driver_class_name` varchar(45) DEFAULT 'com.mysql.cj.jdbc.Driver' COMMENT '驱动类',
      `jdbc_url` varchar(45) DEFAULT NULL COMMENT '数据库连接地址<jdbc:mysql://ip:port/db>,必填!',
      `pool_name` varchar(45) NOT NULL COMMENT '连接池名称,必填!',
      `username` varchar(45) DEFAULT NULL COMMENT '用户名',
      `password` varchar(45) DEFAULT NULL COMMENT '密码',
      `minimum_idle` int(11) DEFAULT '5' COMMENT '最小空闲连接数',
      `maximum_pool_size` int(11) DEFAULT '10' COMMENT '最大连接数',
      `connection_test_query` varchar(45) DEFAULT 'SELECT 1' COMMENT '测试连接是否有效SQL',
      `group_name` varchar(45) DEFAULT NULL COMMENT '分组名',
      `balance_type` varchar(45) DEFAULT NULL COMMENT '负载均衡类型',
      PRIMARY KEY (`id`),
      UNIQUE KEY `pool_name_UNIQUE` (`pool_name`)
    ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
    
    

    该表结构在resources/script/db_entity.sql文件中

    3. 添加动态数据源注解

    设置在执行的方法上:

    @TargetDataSource

    4. 动态指定数据源

    // DynamicDbSource.set("db3");
    
    @TargetDataSource
    public List<MyDb3> findAll() throws InterruptedException {
        //动态数据源设置
        DynamicDbSource.set("db3");
        TimeUnit.SECONDS.sleep(60);
        return myDb3Dao.findAll();
    }

    PS: DynamicDbSource.set("连接池名称"),可以根据自己的实际业务逻辑设置数据源名称。例如我们需要根据请求的pk获取当前连接对应的数据源配置, 获取到名字后在这里设置为数据源名字即可。

    5. 实例地址

    https://github.com/xieyucan/easy-connection-pool-demo/blob/master/easy-jdbctemplate/src/main/java/com/xieahui/easy/jdbctemplate/service/MyDb3Service.java

    启动信息

    系统优先使用注解方法上的属性配置,注解方法上没有配置的情况下会读取DynamicDbSource设置的数据源配置。系统启动时会日志中会打印出当前创建连接 池的情况,以及连接池中的数据表。

    com.zaxxer.hikari.HikariDataSource       : HikariCP1 - Starting...
    com.zaxxer.hikari.HikariDataSource       : HikariCP1 - Start completed.
    c.x.s.config.DynamicDataSourceRegister   : *** Create DataSource Default Success! ***
    c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-Start***:
    c.x.s.config.DynamicDataSourceRegister   : db
    c.x.s.config.DynamicDataSourceRegister   : db_entity
    c.x.s.config.DynamicDataSourceRegister   : hibernate_sequence
    c.x.s.config.DynamicDataSourceRegister   : student
    c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-End***.
    
    com.zaxxer.hikari.HikariDataSource       : db3 - Starting...
    com.zaxxer.hikari.HikariDataSource       : db3 - Start completed.
    c.x.s.config.DynamicDataSourceRegister   : *** Create DataSource db3 Success! ***
    c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-Start***:
    c.x.s.config.DynamicDataSourceRegister   : my_db3
    c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-End***.
    
    com.zaxxer.hikari.HikariConfig           : HikariCP2 - idleTimeout has been set but has no effect because the pool is operating as a fixed size pool.
    com.zaxxer.hikari.HikariDataSource       : HikariCP2 - Starting...
    com.zaxxer.hikari.HikariDataSource       : HikariCP2 - Start completed.
    c.x.s.config.DynamicDataSourceRegister   : *** Create DataSource db1 Success! ***
    c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-Start***:
    c.x.s.config.DynamicDataSourceRegister   : hibernate_sequence
    c.x.s.config.DynamicDataSourceRegister   : student
    c.x.s.config.DynamicDataSourceRegister   : teacher
    c.x.s.config.DynamicDataSourceRegister   : user
    c.x.s.config.DynamicDataSourceRegister   : ***Print-Tables-End***.
    
    c.x.s.config.DynamicDataSourceRegister   : Dynamic DataSource Registry

    在MyBatis中的用法

    演示项目 easy-mybatis

    演示用例 easy-mybatis-MyBatisApplicationTest

    在JPA中的用法

    演示项目 easy-jpa

    演示用例 easy-jpa-JpaApplicationTest

    在JdbcTemplate中的用法

    演示项目 easy-jdbctemplate

    演示用例 easy-jpa-JdbcTemplateApplicationTest

    使用说明

    插件是基于SpringBoot开发maven管理的,使用步骤如下:

    1.添加插件maven依赖

    <dependency>
        <groupId>com.xieahui.springboot</groupId>
        <artifactId>spring-boot-easy-connection-pool</artifactId>
        <version>1.0.1-RELEASE</version>
    </dependency>

    2.在启动类上添加注解开启动态数据源

    @EnableDynamicDataSource

    3.必要的连接属性配置 说明:spring.datasource.names属性配置数据资源名(如果连接的数据源较少,请在此处移除掉)。默认数据源使用了JPA,使用的持久层技术有JdbcUtils,Hibernate,IBatis和MyBatis,JdbcTemplate,Jpa(现有项目最常用的持久层技术是JPA+JdbcTemplate;持久层技术方案众多,好坏只有自己去品)。能解决业务场景问题、开发效率高用的开心就好。

    server.port=8080
    #db,数据源名字
    spring.datasource.names=db1,db2,db3
    spring.datasource.type=com.zaxxer.hikari.util.DriverDataSource
    #jpa
    spring.jpa.database=mysql
    spring.jpa.show-sql=true
    spring.jpa.generate-ddl=true
    spring.jpa.hibernate.ddl-auto=update
    #mysql-1
    #表示使用基于DriverManager的配置
    spring.datasource.hikari.jdbcUrl=jdbc:mysql://localhost:3306/db
    #数据库连接用户名
    spring.datasource.hikari.username=root
    #数据库连接密码
    spring.datasource.hikari.password=root
    #数据库连接驱动
    spring.datasource.hikari.driverClassName=com.mysql.cj.jdbc.Driver
    #池中维护的最小空闲连接数,如果空闲连接低于此值并且总连接数小于maximumPoolSize,则HC将快速有效的添加其他连接
    spring.datasource.hikari.minimumIdle=10
    #池中维护的最大连接数
    spring.datasource.hikari.maximumPoolSize=15
    #控制连接是否自动提交事务
    spring.datasource.hikari.autoCommit=true
    #空闲连接闲置时间
    spring.datasource.hikari.idleTimeout=30000
    #连接池名称
    spring.datasource.hikari.poolName=HikariCP1
    #连接最长生命周期,如果不等于0且小于30秒则会被重置回30秒
    spring.datasource.hikari.maxLifetime=1800000
    #从池中获取连接的最大等待时间默认30000毫秒,如果小于250毫秒则被重置会30秒
    spring.datasource.hikari.connectionTimeout=30000
    #测试连接有效性最大超时时间,默认5秒如果小于250毫秒,则重置回5秒
    spring.datasource.hikari.validationTimeout=5000
    #测试连接是否有效SQL,PS:不同数据库的测试SQL有可能不一样!
    spring.datasource.hikari.connectionTestQuery=SELECT 1
    #控制默认情况下从池中获取的Connections是否处于只读模式
    spring.datasource.hikari.readOnly=false
    #是否在其自己的事务中隔离内部池查询,例如连接活动测试。通常使用默认值,默认值:false
    spring.datasource.hikari.isolateInternalQueries=false
    #此属性控制是否注册JMX管理Bean
    spring.datasource.hikari.registerMbeans=false
    #此属性控制是否可以通过JMX(Java Management Extensions,即Java管理扩展,它提供了一种在运行时动态管理资源的体系结构)挂起和恢复池
    spring.datasource.hikari.allowPoolSuspension=false
    #mysql-2
    spring.datasource.db1.hikari.jdbcUrl=jdbc:mysql://localhost:3306/db1
    spring.datasource.db1.hikari.username=root
    spring.datasource.db1.hikari.password=root
    spring.datasource.db1.hikari.driverClassName=com.mysql.cj.jdbc.Driver
    spring.datasource.db1.hikari.minimumIdle=10
    spring.datasource.db1.hikari.maximumPoolSize=15
    spring.datasource.db1.hikari.autoCommit=true
    spring.datasource.db1.hikari.idleTimeout=30000
    spring.datasource.db1.hikari.poolName=HikariCP2
    spring.datasource.db1.hikari.maxLifetime=1800000
    spring.datasource.db1.hikari.connectionTimeout=30000
    spring.datasource.db1.hikari.validationTimeout=5000
    spring.datasource.db1.hikari.connectionTestQuery=SELECT 1
    spring.datasource.db1.hikari.readOnly=false
    spring.datasource.db1.hikari.isolateInternalQueries=false
    spring.datasource.db1.hikari.registerMbeans=false
    spring.datasource.db1.hikari.allowPoolSuspension=false
    #mysql-2
    spring.datasource.db2.hikari.jdbcUrl=jdbc:mysql://localhost:3306/db2
    spring.datasource.db2.hikari.username=root
    spring.datasource.db2.hikari.password=root
    spring.datasource.db2.hikari.driverClassName=com.mysql.cj.jdbc.Driver
    spring.datasource.db2.hikari.minimumIdle=10
    spring.datasource.db2.hikari.maximumPoolSize=15
    spring.datasource.db2.hikari.autoCommit=true
    spring.datasource.db2.hikari.idleTimeout=30000
    spring.datasource.db2.hikari.poolName=HikariCP3
    spring.datasource.db2.hikari.maxLifetime=1800000
    spring.datasource.db2.hikari.connectionTimeout=30000
    spring.datasource.db2.hikari.validationTimeout=5000
    spring.datasource.db2.hikari.connectionTestQuery=SELECT 1
    spring.datasource.db2.hikari.readOnly=false
    spring.datasource.db2.hikari.isolateInternalQueries=false
    spring.datasource.db2.hikari.registerMbeans=false
    spring.datasource.db2.hikari.allowPoolSuspension=false
    #clickHouse-1
    spring.datasource.db3.hikari.jdbcUrl=jdbc:clickhouse://
    spring.datasource.db3.hikari.username=root
    spring.datasource.db3.hikari.password=root
    spring.datasource.db3.hikari.driverClassName=ru.yandex.clickhouse.ClickHouseDriver
    spring.datasource.db3.hikari.minimumIdle=5
    spring.datasource.db3.hikari.maximumPoolSize=10
    spring.datasource.db3.hikari.autoCommit=true
    spring.datasource.db3.hikari.idleTimeout=30000
    spring.datasource.db3.hikari.poolName=HikariCP4
    spring.datasource.db3.hikari.maxLifetime=1800000
    spring.datasource.db3.hikari.connectionTimeout=30000
    spring.datasource.db3.hikari.validationTimeout=5000
    spring.datasource.db3.hikari.connectionTestQuery=SELECT 1
    spring.datasource.db3.hikari.readOnly=false
    spring.datasource.db3.hikari.isolateInternalQueries=false
    spring.datasource.db3.hikari.registerMbeans=false
    spring.datasource.db3.hikari.allowPoolSuspension=false

    4.代码中应用 由于数据源动态切换是使用Aspect+注解完成的,所以调用时需要将Bean交给Spring的IOC容器管理。只有这样Spring才能通过AOP加强,触发我们的切换逻辑。

    Controller:
    @Resource
    private StudentService studentService;
    	
    @GetMapping("/fcn")
    public List<String> findCHNames() {
    	return studentService.findClickHouseColumnName();
    }
    
    Service:
    @Resource
    private JdbcTemplate jdbcTemplate;
    
    @TargetDataSource("db3")
    public List<String> findClickHouseColumnName() {
    	String sql = "show tables";
    	List<String> strings = jdbcTemplate.queryForList(sql, String.class);
    return strings;
    }

     

    4. 插件的使用实例?

    简介

    EasyConnectionPoolDemo是SpringBoot动态配置多数据源连接池spring-boot-easy-connection-pool项目的实例。

    EasyConnectionPoolDemo项目中分别演示了使用常见Jpa、JdbcTemplate、MyBatis作为持久层框架的项目案例。

    按理说spring-boot-easy-connection-pool处理的是DataSource,对各种持久层框架而言是透明的,使用场景也是很类似,比较简单。但是为了更加具体详细的说明演示 ,就做了这个项目。此项目中分别使用了两个数据、两个表进行演示;理论上而言:如果项目中添加了支持JDBC协议驱动的数据源配置,则可实现数据源动态切换逻辑。 该连接池项目还有一个特点:在启动阶段会打印详细的连接信息以及连接表信息,如下图所示:

     

    V1.0.1 - 更新说明

    新增从默认数据库中获取数据源连接信息,使用说明。

    1. 实例地址

    https://github.com/xieyucan/easy-connection-pool-demo/blob/master/easy-jdbctemplate/src/main/java/com/xieahui/easy/jdbctemplate/service/MyDb3Service.java

    准备

    该项目演示使用的是MySql数据库,所以运行项目的前提是要有MySql数据库。新建数据库及表

    1. easy_pool_demo - student
    2. db1 - user

    easy_pool_demo作为了默认数据库,建表语句在项目根目录的script中。

    MyBatis框架中的用法

    MyBatis是一款非常优秀的持久层框架,尤其是在互联网企业中使用的人群超级多。

    演示项目 easy-mybatis

    演示用例 easy-mybatis-MyBatisApplicationTest

    JPA中的用法

    JPA是SpringBoot默认集成的持久层框架,如果使用过Hibernate,那么对JPA则很快上手。使用JPA开发CRUD,可以说是非常的迅速、顺手。 在管理项目中做功能开发没有比JPA开发效率更高的了,如果你觉得使用起来不是很方便,那一定是没有找到正确的用法。这个项目中只是为了演示spring-boot-easy-connection-pool项目 如何支持JPA的开发,并没有对JPA技术进行详细介绍。

    演示项目 easy-jpa

    演示用例 easy-jpa-JpaApplicationTest

    JdbcTemplate中的用法

    JdbcTemplate很早之前就在SpringJdbc中出现了。由于它只对原生数据连接操作使用模板模式进行简单包装(如果没有任何封装,那么使用起来是非常蹩脚的),所以更接近原生操作;这也注定了它比其他几个框架更加灵活且学习成本更低。我们则更容易根据自己的业务场景、使用习惯封装出独特的持久层方案。

    演示项目 easy-jdbctemplate

    演示用例 easy-jpa-JdbcTemplateApplicationTest

    以上,如有问题可以邮件联系我。祝好!

    插件实例源码地址

    5. 插件的源码?

    插件源码在github上,代码量很少并且有详细的注释。如果对您有所帮助,辛苦您帮我点个start。感谢!

    源码地址

    展开全文
  • Java数据源配置

    千次阅读 2017-03-28 15:15:17
    今天是2017年3月28日,天气晴,空闲了好几天,今天终于接受到一个任务,笼统的说是一个数据抽取吧,其中涉及到一个知识点,就是要配置个数据源,身为一名刚毕业不到一年的菜鸟,立马去请教了组长这该如何做,组长...

    今天是2017年3月28日,天气晴,空闲了好几天,今天终于接受到一个任务,笼统的说是一个数据抽取吧,其中涉及到一个知识点,就是要配置多个数据源,身为一名刚毕业不到一年的菜鸟,立马去请教了组长这该如何做,组长很给力,直接给了我一个样例,让我跟着做,其中缘由是如何的呢,还需我自己查阅资料慢慢消化,在此,我也先记录一下Java配置多数据源的用法,一共需要配置四个地方,很简单。

    注:这个知识点必须在对Java框架有一定了解的基础下学习才行。

    第一步,是最重要的配置文件,在此我给它取名为spring-lt.xml,它是一个独立的配置文件,就是你需要配置数据源的适配器,代码如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:cache="http://www.springframework.org/schema/cache"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
            http://www.springframework.org/schema/cache
            http://www.springframework.org/schema/cache/spring-cache-3.2.xsd ">
    
            <description>这里设置大表远传的适配器。</description>
    
            <bean id="sqlSessionFactoryLT" class="org.mybatis.spring.SqlSessionFactoryBean">
                <property name="dataSource" ref="ltDataSource"></property>  <!-- ltDataSource 对应的是spring-core.xml中bean的id -->
                <property name="configLocation" value="classpath:mybatis-config.xml"></property>
                <property name="mapperLocations" value="classpath:com/wx/app/ygp/dao/externalConnection/*.xml">  </property>  <!-- 此路径就是*mapper.xml文件对应的路径 -->
            </bean>
    
            <bean id="myLtPlugs" class="org.mybatis.spring.mapper.MapperFactoryBean">
                <property name="mapperInterface" value="com.wx.app.ygp.dao.externalConnection.LtPlugs" />  <!-- 此路径就是dao接口的路径 -->
                <property name="sqlSessionFactory" ref="sqlSessionFactoryLT" />
            </bean>
    
    </beans>

    第二步,是在spring-core.xml中增加对这个数据源的配置,主要的作用是获取db.properties中的数据源的值,代码如下:

        <!-- 加载配置属性文件 -->
        <context:property-placeholder
                ignore-unresolvable="true" location="classpath*:db.properties"/>
    
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
              destroy-method="close">
            <property name="url" value="${base.url}"/>
            <property name="username" value="${base.username}"/>
            <property name="password" value="${base.password}"/>
            <property name="driverClassName" value="${base.driver}"/>
        </bean>      <!-- 数据库1 -->
    
        <bean id="htDataSource" class="com.alibaba.druid.pool.DruidDataSource"
              destroy-method="close">
            <property name="url" value="${ht.url}"/>
            <property name="username" value="${ht.username}"/>
            <property name="password" value="${ht.password}"/>
            <property name="driverClassName" value="${ht.driver}"/>
        </bean>   <!-- 数据库2 -->
    
        <bean id="ltDataSource" class="com.alibaba.druid.pool.DruidDataSource"
              destroy-method="close">
            <property name="url" value="${lt.url}"/>
            <property name="username" value="${lt.username}"/>
            <property name="password" value="${lt.password}"/>
            <property name="driverClassName" value="${lt.driver}"/>
        </bean>  <!-- 数据库3 -->
    
        <bean id="multipleDataSource" class="com.wx.app.ygp.comm.MultipleDataSource">
            <property name="defaultTargetDataSource" ref="dataSource"/>
            <property name="targetDataSources">
                <map>
                    <entry key="ygp" value-ref="dataSource"/>
                    <entry key="ht" value-ref="htDataSource"/>
                    <entry key="lt" value-ref="ltDataSource"/>
                </map>
            </property>
        </bean>

    第三步,是在web.xml文件中增加spring-lt.xml的引入,代码如下:

        <!-- Spring和mybatis的配置文件 -->
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                classpath:spring-core.xml;
                classpath:spring-mybatis.xml;
                classpath:spring-ht.xml;
                classpath:spring-lt.xml;
                classpath:spring-task.xml
            </param-value>
        </context-param>

    最后一步,就是在db.properties文件中配置你的数据源,像账号,密码,啥的。。

    lt.driver=com.mysql.jdbc.Driver
    lt.url=jdbc:mysql://127.0.0.1:3306/ygp?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
    lt.username=root
    lt.password=admin

    完毕,这样就可以在项目中使用多个数据库啦~

    展开全文
  • 在使用spring 管理cp30数据源的时候, 建了BaseDAO 用于创建hinetnatefactory的session对象 发现BaseDAO在初始时是可以创建session对象的 但是再次调用时数据源关闭了,无法继续使用session 请问是什么原因 ...
  • 参考: https://my.oschina.net/simpleton/blog/916108 ... 需求描述 近期被分配了一需.

    参考:

    需求描述

    近期被分配了一个需求:

    • 在项目里同时连接多个数据源
    • 用户可以输入数据库连接信息动态建立连接

    JDBC 与 DATASOURCE

    在配置动态数据源前,必须先回顾一下jdbcdatasource,这对后面的功能实现有很大帮助

    以下是jdbc伪代码

    //注册driver
    Class.forName("com.mysql.jdbc.Driver");
    //建立数据库对象
    Connection conn  = DriverManager.getConnection(url_encrypt,user,password);
    //建立操作对象
    Statement stmt= conn.createStatement();
    //结果集
    ResultSet rs = stmt.executeQuery("select * from information");
    //依次关闭结果集,操作对象,数据库对象
    if(rs!=null){
        rs.close();
    }
    if(stmt!=null){
        stmt.close();
    }
    if(conn!=null){
        conn.close();
    }
    

    可以看出,使用jdbc的步骤简单归纳如下:

    1. 加载数据库驱动driver
    2. 建立数据库连接connection
    3. 创建statement
    4. 通过statement执行sql,获得结果集ResultSet
    5. 依次关闭ResultSetstatementconnection

    但是,每次通过jdbc建立连接不但繁琐,而且频繁建立和释放连接对系统资源消耗也很大,因此发展出了datasource
    datasource是个接口,它只有两个方法

    //无参数获取Connection
    Connection getConnection() throws SQLException;
    //通过username和password获取Connection
    Connection getConnection(String username, String password) throws SQLException;
    

    可以看出,这两个方法都可以获得connection,因此connection的创建与回收都由datasource管理而不用用户操心,而且通过数据库连接池也避免了connection的频繁创建与销毁,提升了系统性能

    那么想要实现动态数据源,思路有两种:

    1. 同时创建多个datasource,不同的接口(或方法)采用不同的datasource
    2. 采用动态数据源,根据需要动态提供不同的connection

    mybatis

    现在我们已经有了初步思路,下一步就是如何把这个思路应用于mybatis上,这样就需要了解下mybatisdatasource间的关系

    我们知道,使用mybatis时,我们做了以下工作:

    1. mapper接口
    2. .xml文件
    3. 通过@MapperScan指定mapper接口的扫描路径
    4. 配置mapper-locations指定.xml文件路径

    这中间,mybatis做了很多工作,但这不是我们这篇文章的重点,但我们只需要了解以下内容:

    1. mybatis会根据mapper接口与.xml文件生成mapper接口的实现类
    2. 这个mapper实现类会使用SqlSessionTemplate去执行SQL命令
    3. 如果某mapper想使用某特定数据库,就让它使用某特定的SqlSessionTemplate
    4. SqlSessionTemplate可通过SqlSessionFactory去创建
    5. SqlSessionFactory通过SqlSessionFactoryBean创建
    6. SqlSessionFactoryBean可以通过setDataSource设置datasource,通过setMapperLocations设置.xml文件地址

    梳理一下:

    1. 创建一个SqlSessionFactoryBean,设置datasourcexml文件路径
    2. 通过SqlSessionFactoryBean创建SqlSessionFactory
    3. 通过SqlSessionFactory创建SqlSessionTemplate
    4. 把这个SqlSessionTemplate“关联”到mapper接口

    ps:以上总结是基于spring+mybatis,如果没有spring,链路如下:
    datasource >> Environment >> Configuration >> SqlSessionFactoryBuilder >> SqlSessionFactory >> SqlSession

    多数据源配置

    现在我们先实现同时配置多个数据源吧

    配置文件

    spring:
      datasource:
        default:
          url: jdbc:postgresql://localhost:5432/default
          username: user
          password: pass
          driver-class-name: org.postgresql.Driver
          type: com.alibaba.druid.pool.DruidDataSource
        demo:
          url: jdbc:postgresql://localhost:5432/demo
          username: user
          password: pass
          driver-class-name: org.postgresql.Driver
        druid:
          url: jdbc:postgresql://localhost:5432/default
          username: user
          password: pass
          driver-class-name: org.postgresql.Driver
          type: com.alibaba.druid.pool.DruidDataSource
          # 下面为连接池的补充设置,应用到上面所有数据源中
          # 初始化大小,最小,最大
          initial-size: 5
          min-idle: 5
          max-active: 20
          # 配置获取连接等待超时的时间
          max-wait: 60000
          # 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
          time-between-eviction-runs-millis: 60000
          # 配置一个连接在池中最小生存的时间,单位是毫秒
          min-evictable-idle-time-millis: 300000
          validation-query: SELECT 1
          test-while-idle: true
          test-on-borrow: false
          test-on-return: false
          # 打开PSCache,并且指定每个连接上PSCache的大小
          pool-prepared-statements: true
          #   配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
          max-pool-prepared-statement-per-connection-size: 20
          use-global-data-source-stat: true
          # 通过connectProperties属性来打开mergeSql功能;慢SQL记录
          filter:
            config:
              enabled: true
            stat:
              enabled: true
            wall:
              enabled: false
          connect-properties:
            druid.stat.mergeSql: true
            druid.stat.slowSqlMillis: 5000
          # 配置监控服务器
          stat-view-servlet:
            login-username: admin
            login-password: admin
            reset-enable: false
            url-pattern: /druid/*
            # 添加IP白名单
            #allow:
            # 添加IP黑名单,当白名单和黑名单重复时,黑名单优先级更高
            #deny:
            enabled: true
          web-stat-filter:
            # 添加过滤规则
            url-pattern: /*
            # 忽略过滤格式
            exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
            enabled: true
          default-auto-commit: false
          connection-error-retry-attempts: 2
          break-after-acquire-failure: true
    

    数据源

    DefaultDataSourceConfig

    @Configuration
    @MapperScan(value = {"com.hy.mapper.default"},sqlSessionTemplateRef="sqlSessionTemplate")
    public class DefaultDataSourceConfig {
        private Logger logger = LoggerFactory.getLogger(this.getClass().getName());
    
    	//获取通用的DruidDataSource
    	//注意:
    	//	1.由于springbean默认是单例,而这个bean是其他datasource的“模版”,必须每次调用都生成新的对象,因此添加@Scope("prototype")注解
    	//	2.通过@ConfigurationProperties(prefix = "spring.datasource.druid")读取配置文件spring.datasource.druid下的所有属性到DruidDataSource里
        @Bean(name="getDruidDataSource")
        @ConfigurationProperties(prefix = "spring.datasource.druid")
        @Scope("prototype")
        public DruidDataSource getDruidDataSource(){
            DataSourceBuilder<DruidDataSource> dataSourceBuilder = DataSourceBuilder.create().type(DruidDataSource.class);
            DruidDataSource dataSource = dataSourceBuilder.build();
            //不能自动提交
            dataSource.setDefaultAutoCommit(false);
            return dataSource;
        }
    
    	//默认的数据源
    	//在通用数据源的基础上,读取spring.datasource.default下的配置
        @Bean(name="defaultDruidDataSource",initMethod = "init",destroyMethod = "close")
        @ConfigurationProperties(prefix = "spring.datasource.default")
        public DruidDataSource defaultDruidDataSource(){
            return getDruidDataSource();
        }
    
        @Bean(name = "sqlSessionFactoryBean")
        public SqlSessionFactoryBean sqlSessionFactoryBean(@Qualifier("defaultDruidDataSource") DataSource dataSource) throws Exception {
            SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
            sessionFactory.setDataSource(dataSource);
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            // 扫描映射文件
            sessionFactory.setMapperLocations(resolver.getResources("classpath*:mapper/default/*.xml"));
            return sessionFactory;
        }
    
        @Bean(name = "sqlSessionTemplate")
        public SqlSessionTemplate sqlSessionTemplate(
            @Qualifier("sqlSessionFactoryBean") SqlSessionFactoryBean sqlSessionFactory) throws Exception {
            return new SqlSessionTemplate(sqlSessionFactory.getObject());
        }
    
    
        @Bean(name="transactionManager")
        public PlatformTransactionManager transactionManager(@Qualifier("dataSource") DataSource dataSource) {
            // 配置事务管理, 使用事务时在方法头部添加@Transactional注解即可
            return new DataSourceTransactionManager(dataSource);
        }
    }
    
    

    DemoDataSourceConfig

    @Configuration
    @MapperScan(value = {"com.hy.mapper.demo"},sqlSessionTemplateRef="sqlSessionTemplateForDemo")
    public class DemoDataSourceConfig {
    
    	//DEMO数据源
    	//在通用数据源的基础上,读取spring.datasource.demo下的配置
        @Bean(name="demoDruidDataSource",initMethod = "init",destroyMethod = "close")
        @ConfigurationProperties(prefix = "spring.datasource.demo")
        public DruidDataSource demoDruidDataSource(@Qualifier("getDruidDataSource") DruidDataSource dataSource){
            return dataSource;
        }
    
        @Bean(name = "sqlSessionFactoryBeanForDemo")
        public SqlSessionFactoryBean sqlSessionFactoryBeanForDemo(@Qualifier("demoDruidDataSource") DataSource demoDataSource) throws Exception {
            SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
            sessionFactory.setDataSource(demoDataSource);
            PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            // 扫描映射文件
            sessionFactory.setMapperLocations(resolver.getResources("classpath*:mapper/demo/*.xml"));
            return sessionFactory;
        }
    
        @Bean(name = "sqlSessionTemplateForDemo")
        public SqlSessionTemplate sqlSessionTemplateForDemo(
            @Qualifier("sqlSessionFactoryBeanForDemo") SqlSessionFactoryBean sqlSessionFactory) throws Exception {
            return new SqlSessionTemplate(sqlSessionFactory.getObject());
        }
    
    
        @Bean(name="transactionManagerForDemo")
        public PlatformTransactionManager transactionManagerForDemo(@Qualifier("demoDruidDataSource") DataSource demoDataSource) {
            // 配置事务管理, 使用事务时在方法头部添加@Transactional注解即可
            return new DataSourceTransactionManager(demoDataSource);
        }
    }
    
    

    以上代码,就已经把mapper接口与特定数据源关联上了,可以随便写个service去验证

    //student与teacher分别处于demo库与default库
    @AutoWired
    private StudentMapper studentMapper;
    @AutoWired
    private TeacherMapper teacherMapper;
    
    @Override
    public Student getStudentById(Integer id) {
        return studentMapper.searchById(id);
    }
    
    @Override
    public Teacher getTeacherById(Integer id) {
        return teacherMapper.searchById(id);
    }
    
    

    这两个查询方法都可以顺利查询到数据

    动态数据源

    之前已经实现了多数据源配置,那现在我们进行动态数据源配置

    这部分内容我完全参考:
    JAVA中使用代码创建多数据源,并实现动态切换(一)

    这位写的应该比我好得多,所以大家直接看这篇就行

    展开全文
  • java j2ee多数据源配置

    2016-09-12 09:41:22
    这里主要介绍两种多数据源方式,一种是SpringMVC+MYbatis注解的方式,一种spring JNDI方式; 总体大概流程: 1. 拷贝所需jar 2.写一数据库切换的工具类:DataSourceContextHolder,用来切换数据库 3.写一...
  • 原创整理不易,转载请注明出处:java开源框架SpringSide3数据源配置的方法详解 代码下载地址:http://www.zuidaima.com/share/1781579130801152.htm 在SpringSide 3社区中,不断有人提出多数据源配置的问题,...
  • 1.数据源扫描的mapper路径要对应:分包配置,两种包格式 2.数据源读取对应的配置名称要对应 3.主配置数据源和主事务一定加 @Priamry ... 2.resources/application.properties 配置个数据源...
  • 在Spring中,不但可以通过JNDI获取应用服务器的数据源,也可以直接在Spring容器中配置数据源,此外,还可以通过代码的方式创建一个数据源,以便进行无依赖的单元测试。 配置数据源 Spring在第三方依赖包中包含了...
  • 数据源配置文件中的配置 [java] view plain copy  print? "code" class="java">"1.0" encoding="UTF-8"?>  "http://www.springframework.org/schema/beans"   xmlns:xsi=...
  • 本文采取java配置类来配置spring,整合了c3p0连接池和Mybatis,只需要以下6部分即可配置完成。 注:dao接口、mapper映射文件、实体类、数据库的库和表没有在此给出。 1. maven配置 <properties> <java....
  • Spring3+Hibernate3(Jpa) 配置个数据源的解决方案(基于注解) 昨天在技术问答区,发出了这个问题,首先感谢大家给出的回复,但是还没能解决问题。刚刚又仔细的思考下,并查了些资料,终于解决了。下面贴出...
  • 完成动态切换双数据源有些时间了,刚刚又接入了第三个数据源,顺便把这块的逻辑梳理、记录、分享一下; 交代下项目环境:springboot2.0.1, mybatis3,jdk1.8,druid 1.1.0 下面主要是贴代码了,并配以简单说明,从...
  • 使用Spring配置数据源

    千次阅读 2017-09-29 17:20:13
    利用Spring提供的AbstractRoutingDataSource抽象类配置个数据源。在运行时利用SpringAOP 在事物开启之前,根据某个key值动态的改变数据源。 二、配置个数据源 1.配置第一个数据源 2.配置第二个数据源 3.配置...
  • springboot配置数据源

    2020-08-17 17:43:53
    springboot配置数据源 1.配置数据源相关 使用阿里巴巴的 druid 数据源,并配置数据源 2.如果mysql-connector-java用的6.0以上的,使用如下...3.多数据源就是要有name区分开来 #数据源1 spring.datasource.one.url=
  • 落雨 cas 单点登录 本篇将讲解cas-server端的认证方式 ...2.配置Oracle的jdbc数据源,通过spring动态查询数据库 ...4.配置oracle和mysql的数据源,以及添加一个Java类,三者认证,有一满足就立...
  • 如果项目要求必须只能存在一事务管理,解决方案可参考:http://today.java.net/pub/a/today/2006/08/31/jotm-transactions-in-spring-and-hibernate.html----------------配置文件 ------------------
  • spring+jpa 两个数据源配置

    千次阅读 2015-11-21 16:47:44
    采用jpa+spring技术配置数据源 persistence.xml配置数据源 xml version="1.0"?> persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ...
  • 今天在使用Spring配置c3p0数据源时,使用的数据库是mysql,服务器是tomcat,运行时报了一 java.lang.NoClassDefFoundError: com/mchange/v2/ser/Indirector 网络上找了很久都没有解决,最后发现是因为: C3P0少...
  • 下面贴出自己的解决方法:主要是配置文件和如何写注解 ----------------配置文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;persistence xmlns="...
  • 配置文件,做一全局配置的是测试or 生产环境 3.写配置类在配置类中通过 全局的测试生产判断调用哪个配置 static final String PACKAGE = "com.superman.globaldao.ds2"; st...
  • java数据源实例

    千次阅读 2016-10-07 23:19:25
    主要需要解决的问题 1,数据源的切换 2,数据源切换aop 必须在 spring事务 aop ...4,数据源切换的切面在 service 层,不能再dao 层,因为事务的aop 在service层一, 配置文件内容<?xml version="1.0" encoding="UTF
  • 这里使用AOP拦截注解来切换数据源。1. 在数据源配置文件context.xml中增加新的数据源信息,使存在多数据库服务可以访问。注意区别开jndi名称。...3. 新建多数据源类(比如MultipleDataSource.java),需要继承自o...
  • 这里使用AOP拦截注解来切换数据源。1. 在数据源配置文件context.xml中增加新的数据源信息,使存在多数据库服务...3. 新建多数据源类(比如MultipleDataSource.java),需要继承自org.springframework.jdbc.d...
  • 1、spring-mybatis.xml中配置个数据源 2、使用Spring提供的AbstractRoutingDataSource类来根据请求路由到不同的数据源 3、ThreadLocal解决线程安全问题 详情参考: 【Java】一次SpringMVC+ Mybatis 配置多数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,113
精华内容 445
关键字:

java配置3个数据源

java 订阅