如何使用多數據源,同時使用jpa和jdbctemplate

阿新 • • 發佈：2018-06-21

bsp nta utf8 npr gis 控制臺管理 iba ogg 需要

spring:
 datasource:
    first:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://xx.xx.xx.xx:xx/xx?characterEncoding=utf8
    driver-class-name: com.mysql.jdbc.Driver
    username: xx
    password: xx
    #配置監控統計攔截的filters，去掉監控界面sql將無法統計，‘wall‘用於防火墻
    filters: stat,wall,log4j
    #最大活躍數
    maxActive:  
20
    #初始化連接數
    initialSize: 1
    #最大連接等待超過時間
    maxWait: 60000
    #打開PSCache，並且指定每個連接PSCache的大小
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    #通過connectionProperties屬性來打開mergeSql功能；慢SQL記錄
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000 

    minIdle: 1
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: select 1 from dual
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
  sec:
     type: com.alibaba.druid.pool.DruidDataSource
     url: jdbc:mysql://xx.xx.xx.xx:3306/xx?characterEncoding=utf8 

     driver-class-name: com.mysql.jdbc.Driver
     username: xx
     password: xx
     #配置監控統計攔截的filters，去掉監控界面sql將無法統計，‘wall‘用於防火墻
     filters: stat,wall,log4j
     #最大活躍數
     maxActive: 20
     #初始化連接數
     initialSize: 1
     #最大連接等待超過時間
     maxWait: 60000
     #打開PSCache，並且指定每個連接PSCache的大小
     poolPreparedStatements: true
     maxPoolPreparedStatementPerConnectionSize: 20
     #通過connectionProperties屬性來打開mergeSql功能；慢SQL記錄
     connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
     minIdle: 1
     timeBetweenEvictionRunsMillis: 60000
     minEvictableIdleTimeMillis: 300000
     validationQuery: select 1 from dual
     testWhileIdle: true
     testOnBorrow: false
     testOnReturn: false

配置文件

@ServletComponentScan
@Configuration
public class DatasourceConfiguration {

    private Logger logger = LoggerFactory.getLogger(DatasourceConfiguration.class);

    @Value("${spring.datasource.first.url}")
    private String firstdevUrl;
    @Value("${spring.datasource.first.username}")
    private String firstUsername;
    @Value("${spring.datasource.first.password}")
    private String firstPassword;

    @Value("${spring.datasource.sec.url}")
    private String secUrl;
    @Value("${spring.datasource.sec.username}")
    private String secUsername;
    @Value("${spring.datasource.sec.password}")
    private String secPassword;



    @Value("com.mysql.jdbc.Driver")
    private String driverClassName;

    @Value("5")
    private int initialSize;

    @Value("5")
    private int minIdle;

    @Value("20")
    private int maxActive;

    @Value("60000")
    private int maxWait;

    /**
     * 配置間隔多久才進行一次檢測，檢測需要關閉的空閑連接，單位是毫秒
     */
    @Value("60000")
    private int timeBetweenEvictionRunsMillis;
    /**
     * 配置一個連接在池中最小生存的時間，單位是毫秒
     */
    @Value("300000")
    private int minEvictableIdleTimeMillis;

    @Value("SELECT 1 FROM DUAL")
    private String validationQuery;

    @Value("true")
    private boolean testWhileIdle;

    @Value("false")
    private boolean testOnBorrow;

    @Value("false")
    private boolean testOnReturn;

    /**
     * 打開PSCache，並且指定每個連接上PSCache的大小
     */
    @Value("true")
    private boolean poolPreparedStatements;

    @Value("20")
    private int maxPoolPreparedStatementPerConnectionSize;
    /**
     * 配置監控統計攔截的filters，去掉後監控界面sql無法統計，‘wall‘用於防火墻
     */
    @Value("stat,wall,log4j")
    private String filters;
    /**
     * 通過connectProperties屬性來打開mergeSql功能；慢SQL記錄
     */
    @Value("druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500")
    private String connectionProperties;


    @Bean(name = "secDatasource")
    @Qualifier("secDatasource")
    @ConfigurationProperties(prefix = "spring.datasource.sec")
    public DataSource secDataSource() {
        return getDruidDataSource(secUsername, secPassword, secUrl);
    }

    
    @Bean(name = "firstDatasource")
    @Qualifier("firstDatasource")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.first")
    public DataSource firstDataSource() {
        return getDruidDataSource(firstUsername, firstPassword, firstUrl);
    }

   

    private DruidDataSource getDruidDataSource(String username, String password, String url) {
        DruidDataSource datasource = new DruidDataSource();

        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);

        //configuration
        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);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            logger.error("druid configuration initialization filter : {0}", e);
        }
        datasource.setConnectionProperties(connectionProperties);
        return datasource;
    }

}

配置數據源

package com.ipinyou.mip.configuration;

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 com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;


/**
 * 這樣的方式不需要添加註解：@ServletComponentScan
 * Created by Administrator on 2018/2/28.
 */
@Configuration
public class DruidConfiguration {

    @Bean
    public ServletRegistrationBean statViewServlet(){
        //創建Servlet，註冊實體
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
        //設置ip白名單
        servletRegistrationBean.addInitParameter("allow","xx.xx.xx.xx");
        //設置ip黑名單，如果deny和allow共同存在時，deny優先於allow
        servletRegistrationBean.addInitParameter("deny","xx.xx.xx.xx");
        //設置控制臺管理用戶
        servletRegistrationBean.addInitParameter("loginUsername","xxx");
        servletRegistrationBean.addInitParameter("loginPassword","xxx");
        //是否可以重置數據
        servletRegistrationBean.addInitParameter("resetEnable","false");
        return servletRegistrationBean;
    }

    @Bean
    public FilterRegistrationBean statFilter(){
        //創建過濾器
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
        //設置過濾器過濾路徑
        filterRegistrationBean.addUrlPatterns("/*");
        //忽略過濾形式
        filterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return filterRegistrationBean;
    }
}

設置數據源的過濾器

package com.ipinyou.mip.configuration;

import java.util.Map;

import javax.persistence.EntityManager;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactoryPrimary",
        transactionManagerRef = "transactionManagerPrimary",
        basePackages = {"xx.xx.xxx","xx.xx.xx"})//設置dao（repo）所在位置
public class JpaConfiguration {

    @Autowired
    @Qualifier("firstDatasource")
    private DataSource firstDataSource;
    
    @Primary
    @Bean(name = "entityManagerFirst")
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactoryPrimary(builder).getObject().createEntityManager();
    }

    @Autowired
    private JpaProperties jpaProperties;

    private Map<String, Object> getVendorProperties() {
        return jpaProperties.getHibernateProperties(new HibernateSettings());
    }

    /**
     * 設置實體類所在位置
     */
    @Primary
    @Bean(name = "entityManagerFactoryPrimary")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(mipdevDataSource)
                .packages("xx.xx.xx.xx")
                .properties(getVendorProperties())
                .persistenceUnit("firstManageFactory")
                .properties(getVendorProperties())
                .build();
    }

    @Primary
    @Bean(name = "transactionManagerPrimary")
    public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
    }
}

firstJpaConfiguration 技術分享圖片

package com.ipinyou.mip.configuration;

import java.util.Map;

import javax.persistence.EntityManager;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactorySec",
        transactionManagerRef = "transactionManagerSec",
        basePackages = {"xx.xx.xx"})//設置dao（repo）所在位置
public class JpaSecConfiguration {

    @Autowired
    @Qualifier("secDatasource")
    private DataSource secDatasource;
    
    @Bean(name = "entityManagerAmp")
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactoryAmp(builder).getObject().createEntityManager();
    }

    @Autowired
    private JpaProperties jpaProperties;

    private Map<String, Object> getVendorProperties() {
        return jpaProperties.getHibernateProperties(new HibernateSettings());
    }

    /**
     * 設置實體類所在位置
     */
    @Bean(name = "entityManagerFactorySec")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryAmp(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(secDatasource)
                .packages("xx.xx.xx")
                .properties(getVendorProperties())
                .persistenceUnit("secManageFactory")
                .properties(getVendorProperties())
                .build();
    }

    @Bean(name = "transactionManagerSec")
    public PlatformTransactionManager transactionManagerAmp(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactorySec(builder).getObject());
    }
}

secJpaConfiguration 技術分享圖片

package com.ipinyou.mip.configuration;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.jdbc.core.JdbcTemplate;

@Configuration
@Import(DatasourceConfiguration.class)
public class JdbcTemplateConfiguration {
    @Bean(name = "secJdbcTemplate")
    public JdbcTemplate primaryJdbcTemplate(
            @Qualifier("secDatasource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }


    @Bean(name = "firstJdbcTemplate")
    public JdbcTemplate threeJdbcTemplate(
            @Qualifier("firstDatasource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

JdbcTemplateConfiguration 技術分享圖片

/**
 * 提供了一系列數據庫查詢方法
 *
 * @author guodong.zhang
 */
public class CommonDao<E, PK extends Serializable> {

    @PersistenceContext(unitName = "secManageFactory")
    protected EntityManager em;
   /**
     * 相當於jdbctemplate的queryForlist 返回List<Map<String, Object>>
     *
     * @param sql
     * @return
     */
    public List<Map<String, Object>> queryForList(String sql) {
        Query nativeQuery = em.createNativeQuery(sql);
        nativeQuery.unwrap(SQLQuery.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List<Map<String,Object>> resultList = nativeQuery.getResultList();
        return resultList;
    }
}

具體使用

如何使用多數據源,同時使用jpa和jdbctemplate

bsp nta utf8 npr gis 控制臺管理 iba ogg 需要 spring: datasource: first: type: com.alibaba.druid.pool.DruidDataSource url: jdbc:my

springboot2.0.3使用jpa和hibernate的方式配置多數據源(sqlite和mysql)

自動 username urn ini sqli tps www 不同的 sqlite數據庫 application.properties配置: #數據庫配置 mysql.spring.datasource.jdbc-url =jdbc:mysql://127.0.0.1

Spring配置動態數據源-讀寫分離和多數據源

brush ride 常開 resolve ttr 表達 customer 事務管理 cda 　　在現在互聯網系統中，隨著用戶量的增長，單數據源通常無法滿足系統的負載要求。因此為了解決用戶量增長帶來的壓力，在數據庫層面會采用讀寫分離技術和數據庫拆分等技術。讀寫分離就是就是一

JdbcTemplate 配置多數據源(完全照抄,完整)

framework -i into repos .so not scrip version org <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.

springboot+jpa+mybatis 多數據源支持

nta brush frame pattern auth tis autowire tor class import org.springframework.beans.factory.annotation.Qualifier; import org.springfr

spring boot jpa 多數據源配置

drive hiberna hashmap pac initial config ini enable 2個在實際項目中往往會使用2個數據源，這個時候就需要做額外的配置了。下面的配置在2.0.1.RELEASE 測試通過 1、配置文件　　配置兩個數據源 spring.

工具篇-Spring boot JPA多數據源

api version ons gap you run illegal report caused 寫這篇博文是因為這個東西坑太多，首先說明下邊實現的多數據源不是動態切換的，應該算是靜態的。坑一、pom文件 pom中spring boot以及mysql con

java SSM 框架多數據源代碼生成器 websocket即時通訊 shiro redis 後臺框架源碼

sql編輯器 quartz 自定義表單 SSM springmvc 獲取【下載地址】 QQ: 313596790 官網 http://www.fhadmin.org/ A 調用攝像頭拍照，自定義裁剪編輯頭像，頭像圖片色度調節 B 集成代碼生成器 [正反雙向](單表、主表、明細

java SSM 框架代碼生成器 websocket 即時通訊 shiro redis 多數據源後臺框架源碼

idt 下載到本地 exp 綁定鏈接數據庫連接池展示地圖工具重排序 A 調用攝像頭拍照，自定義裁剪編輯頭像，頭像圖片色度調節B 集成代碼生成器 [正反雙向](單表、主表、明細表、樹形表，快速開發利器)+快速表單構建器 freemaker模版技術，0個代碼不用寫，

java SSM框架多數據源代碼生成器 websocket即時通訊 shiro redis 後臺框架源碼

sql編輯器 quartz 自定義表單 springmvc ssm 獲取【下載地址】 QQ: 313596790官網 http://www.fhadmin.org/A 調用攝像頭拍照，自定義裁剪編輯頭像，頭像圖片色度調節B 集成代碼生成器 [正反雙向](單表、主表、明細表、樹形表，快速

myBatis多數據源

scanner comm comment per spa prop 一個 data start <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory"> 　　

springMVC+spring+mybatis多數據源配置

expr init mybatis onf exp 超時 png wait http 1.application.properties配置 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http

spring基於通用Dao的多數據源配置

一個 file html try xtend target fig classname val 有時候在一個項目中會連接多個數據庫,須要在spring中配置多個數據源,近期就遇到了這個問題,因為我的項目之前是基於通用Dao的，配置的時候問題不斷。這樣的方式和資源文件沖突

Spring整合多數據源實現動態切換

sna apach 動態數據 innodb des lis 項目 void getc 在實際項目中時常需要連接多個數據庫，而且不同的業務需求在實現過程當中往往需要訪問不同的數據庫。 jdbc.properties配置文件,配置多個dataSource ##########

第九章 springboot + mybatis + 多數據源（AOP實現）

app aps 基礎上 default round mapper lan efault epo 在第八章 springboot + mybatis + 多數據源代碼的基礎上，做兩點修改 1、ShopDao package com.xxx.firstboot.da

[轉]SpringMVC+ Mybatis 配置多數據源 + 手動切換數據源

cat ons 接口 data ppi 研究 www contex ans 正確可行的解決方法：使用Spring提供的AbstractRoutingDataSource類來根據請求路由到不同的數據源。具體做法是先設置兩個不同的dataSource代表不同的數據源，再建一個總

SpringMVC hibernate增加多數據源（SSHE/SYPRO增加多數據源為例）

ram idle tasks 一個 pen san t_sql rem 一次 SpringMVC hibernate增加多數據源（以類SSHE/SYPRO增加多數據源為例作說明）註：適用與SpringMVC + Hibernat

Spring動態切換多數據源解決方案

http aso 解決目標可能 bcp pro start map spring動態配置多數據源，即在大型應用中對數據進行切分，並且采用多個數據庫實例進行管理，這樣可以有效提高系統的水平伸縮性。而這樣的方案就會不同於常見的單一數據實例的方案，這就要程序在運行時根據當時的

多數據源動態關聯報表的制作（birt為例）

處理 center 關閉主表等價兩個數據 fonts img 使用Jasper或BIRT等報表工具時，常會碰到一些很規的統計，用報表工具本身或SQL都難以處理，比方與主表相關的子表分布在多個數據庫中，報表要展現這些數據源動態關聯的結果。集算器具

java實現mysql數據庫讀寫分離之定義多數據源方式

修改 protect frame auto ret 更新數據 logs cannot initial 該示例是基於spring提供的AbstractRoutingDataSource，實現了一個動態數據源的功能，在spring配置中定義多個數據庫分為主、從數據庫，實現效

如何使用多數據源,同時使用jpa和jdbctemplate

相關推薦