jpa配置双数据源

最新推荐文章于 2024-10-19 14:07:15 发布
最新推荐文章于 2024-10-19 14:07:15 发布
阅读量277 收藏
点赞数
分类专栏： Java 后端框架 文章标签： jpa 双数据源
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/shepherd_dirk/article/details/106212386
版权 
package com.yaotiao.mall.search.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
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.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
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 javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.Map;

@Configuration
@PropertySource( "classpath:application-${spring.profiles.active}.yml")
@EnableJpaRepositories(
        basePackages = {"com.yaotiao.mall.search.dao.source"},
        entityManagerFactoryRef = "sourceEntityManagerFactory",
        transactionManagerRef = "sourceTransactionManager"
        )
public class SourceConfig {

    @Autowired
    JpaProperties jpaProperties;

    @Autowired
    @Qualifier("druidSource")
    private DataSource druidDataSource;


    @Autowired
    private Environment env;


    @Bean(name = "sourceEntityManager")
    @Primary
    public EntityManager sourceEntityManager(EntityManagerFactoryBuilder builder) {
        return sourceEntityManagerFactory(builder).getObject().createEntityManager();
    }

    /**
     * 指定需要扫描的实体包实现与数据库关联
     * @param builder
     * @return
     */
    @Bean(name = "sourceEntityManagerFactory")
    @Primary
    public LocalContainerEntityManagerFactoryBean sourceEntityManagerFactory(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(druidDataSource)
                .properties(getVendorProperties())
                .packages("com.yaotiao.mall.search.entity.source")
                .persistenceUnit("persistenceUnitSpring")
                .build();
    }

    /**
     * 通过jpaProperties指定hibernate数据库方言以及在控制台打印sql语句
     * @param
     * @return
     */
    private Map<String, Object> getVendorProperties() {
        HibernateProperties hibernateProperties = new HibernateProperties();
        Map<String, Object> map = hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(),new HibernateSettings());
        map.put("hibernate.dialect", env.getProperty("spring.jpa.database-platform"));
        map.put("hibernate.show_sql", env.getProperty("spring.jpa.show-sql"));
        return map;
    }

    /**
     * 创建事务管理
     * @param builder
     * @return
     */
    @Bean(name = "sourceTransactionManager")
    @Primary
    PlatformTransactionManager sourceTransactionManager(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(sourceEntityManagerFactory(builder).getObject());
    }
}

package com.yaotiao.mall.search.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
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.PropertySource;
import org.springframework.core.env.Environment;
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 javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.Map;

@Configuration
@PropertySource( "classpath:application-${spring.profiles.active}.yml")
@EnableJpaRepositories(
        basePackages = {"com.yaotiao.mall.search.dao.target"},
        entityManagerFactoryRef = "targetEntityManagerFactory",
        transactionManagerRef = "targetTransactionManager"
)
public class TargetConfig {

    @Autowired
    JpaProperties jpaProperties;

    @Autowired
    @Qualifier("druidTarget")
    private DataSource druidDataSource;
    @Autowired
    private Environment env;

    @Bean(name = "targetEntityManager")
    public EntityManager targetEntityManager(EntityManagerFactoryBuilder builder) {
        return targetEntityManagerFactory(builder).getObject().createEntityManager();
    }

    /**
     * 指定需要扫描的实体包实现与数据库关联
     * @param builder
     * @return
     */
    @Bean(name = "targetEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean targetEntityManagerFactory(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(druidDataSource)
                .properties(getVendorProperties())
                .packages("com.yaotiao.mall.search.entity.target")
                .persistenceUnit("persistenceUnitSpring")
                .build();
    }

    /**
     * 通过jpaProperties指定hibernate数据库方言以及在控制台打印sql语句
     * @param
     * @return
     */
    private Map<String, Object> getVendorProperties() {
        HibernateProperties hibernateProperties = new HibernateProperties();
        Map<String, Object> map = hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(),new HibernateSettings());
        map.put("hibernate.dialect", env.getProperty("spring.jpa.database-platform"));
        map.put("hibernate.show_sql", env.getProperty("spring.jpa.show-sql"));
        map.put("hibernate.hbm2ddl.auto",env.getProperty("spring.jpa.hibernate.ddl-auto"));
        return map;
    }

    /**
     * 创建事务管理
     * @param builder
     * @return
     */
    @Bean(name = "targetTransactionManager")
    PlatformTransactionManager targetTransactionManager(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(targetEntityManagerFactory(builder).getObject());
    }
}


package com.yaotiao.mall.search.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@PropertySource( "classpath:application-${spring.profiles.active}.yml")
public class DruidSourceConfig {

    @Value("${spring.datasource.driver-class-name}")
    String driverClassName;
    @Value("${spring.datasource.source.url}")
    String url;
    @Value("${spring.datasource.source.username}")
    String username;
    @Value("${spring.datasource.source.password}")
    String password;


    @Value("${spring.datasource.initialSize}")
    int initialSize;
    @Value("${spring.datasource.minIdle}")
    int minIdle;
    @Value("${spring.datasource.maxActive}")
    int maxActive;
    @Value("${spring.datasource.maxWait}")
    int maxWait;
    @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
    int timeBetweenEvictionRunsMillis;
    @Value("${spring.datasource.validationQuery}")
    String validationQuery;
    @Value("${spring.datasource.testWhileIdle}")
    boolean testWhileIdle;
    @Value("${spring.datasource.testOnBorrow}")
    boolean testOnBorrow;
    @Value("${spring.datasource.testOnReturn}")
    boolean testOnReturn;
    @Value("${spring.datasource.poolPreparedStatements}")
    boolean poolPreparedStatements;
    @Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
    int maxPoolPreparedStatementPerConnectionSize;
    @Value("${spring.datasource.filters}")
    String filters;
    @Value("${spring.datasource.connectionProperties}")
    String connectionProperties;
    @Value("${spring.datasource.useGlobalDataSourceStat}")
    boolean useGlobalDataSourceStat;

    @Bean(name = "druidSource", initMethod = "init", destroyMethod = "close")
    @Primary
    @Qualifier("druidDataSource")
    public DataSource dataSource() throws Exception {
        DruidDataSource druidDataSource = new DruidDataSource();

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

        druidDataSource.setInitialSize(initialSize);
        druidDataSource.setMaxActive(maxActive);
        druidDataSource.setMinIdle(minIdle);
        druidDataSource.setMaxWait(maxWait);
        druidDataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
//        druidDataSource.setMinEvictableIdleTimeMillis();
        druidDataSource.setValidationQuery(validationQuery);
        druidDataSource.setTestWhileIdle(testWhileIdle);
        druidDataSource.setTestOnBorrow(testOnBorrow);
        druidDataSource.setTestOnReturn(testOnReturn);
        druidDataSource.setPoolPreparedStatements(poolPreparedStatements);
        druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        druidDataSource.setFilters(filters);
        try {
            if (null != druidDataSource) {
//                druidDataSource.setFilters("wall,stat");
                druidDataSource.setUseGlobalDataSourceStat(true);
                Properties properties = new Properties();
                properties.setProperty("decrypt", "true");
                druidDataSource.setConnectProperties(properties);
                druidDataSource.init();
            }
        } catch (Exception e) {
            throw new RuntimeException(
                    "load datasource error, dbProperties is :", e);
        }
        return druidDataSource;
    }
}


package com.yaotiao.mall.search.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@PropertySource( "classpath:application-${spring.profiles.active}.yml")
public class DruidTargetConfig {

    @Value("${spring.datasource.driver-class-name}")
    String driverClassName;
    @Value("${spring.datasource.target.url}")
    String url;
    @Value("${spring.datasource.target.username}")
    String username;
    @Value("${spring.datasource.target.password}")
    String password;


    @Value("${spring.datasource.initialSize}")
    int initialSize;
    @Value("${spring.datasource.minIdle}")
    int minIdle;
    @Value("${spring.datasource.maxActive}")
    int maxActive;
    @Value("${spring.datasource.maxWait}")
    int maxWait;
    @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
    int timeBetweenEvictionRunsMillis;
    @Value("${spring.datasource.validationQuery}")
    String validationQuery;
    @Value("${spring.datasource.testWhileIdle}")
    boolean testWhileIdle;
    @Value("${spring.datasource.testOnBorrow}")
    boolean testOnBorrow;
    @Value("${spring.datasource.testOnReturn}")
    boolean testOnReturn;
    @Value("${spring.datasource.poolPreparedStatements}")
    boolean poolPreparedStatements;
    @Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
    int maxPoolPreparedStatementPerConnectionSize;
    @Value("${spring.datasource.filters}")
    String filters;
    @Value("${spring.datasource.connectionProperties}")
    String connectionProperties;
    @Value("${spring.datasource.useGlobalDataSourceStat}")
    boolean useGlobalDataSourceStat;

    @Bean(name = "druidTarget", initMethod = "init", destroyMethod = "close")
    @Qualifier("druidDataSource")
    public DataSource dataSource() throws Exception {
        DruidDataSource druidDataSource = new DruidDataSource();

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

        druidDataSource.setInitialSize(initialSize);
        druidDataSource.setMaxActive(maxActive);
        druidDataSource.setMinIdle(minIdle);
        druidDataSource.setMaxWait(maxWait);
        druidDataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
//        druidDataSource.setMinEvictableIdleTimeMillis();
        druidDataSource.setValidationQuery(validationQuery);
        druidDataSource.setTestWhileIdle(testWhileIdle);
        druidDataSource.setTestOnBorrow(testOnBorrow);
        druidDataSource.setTestOnReturn(testOnReturn);
        druidDataSource.setPoolPreparedStatements(poolPreparedStatements);
        druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        druidDataSource.setFilters(filters);
        try {
            if (null != druidDataSource) {
//                druidDataSource.setFilters("wall,stat");
                druidDataSource.setUseGlobalDataSourceStat(true);
                Properties properties = new Properties();
                properties.setProperty("decrypt", "true");
                druidDataSource.setConnectProperties(properties);
                druidDataSource.init();
            }
        } catch (Exception e) {
            throw new RuntimeException(
                    "load datasource error, dbProperties is :", e);
        }
        return druidDataSource;
    }
}


package com.yaotiao.mall.search.config;

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Configuration
@EnableAsync
public class ThreadConfig implements AsyncConfigurer {
    /**
     *
     * @return
     */
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(100);
        executor.setMaxPoolSize(100);
        executor.setQueueCapacity(99999);
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return null;
    }

}
springboot +jpa配置双数据源
往生的博客
04-29 894
业务需求需要在一个项目里配置两个数据源。项目使用的是springboot，springDataJpa。研究一下目前可以正常运行，还没有出现什么bug。 一。配置文件中配置多数据源 spring: devtools: restart: enabled: false http: multipart: max-file-size: 1000Mb ...
spring+jpa 两个数据源配置
ning313180989的专栏
02-22 1万+
1. META-INF/persistence.xml ：   http://java.sun.com/xml/ns/persistence"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://java.sun.com/xml/ns/persistencehttp
spirng data JPA教程(四) 双数据源的配置
独钓寒江雪
01-15 2098
spirng data JPA教程(四) 双数据源的配置 因为jpa是基于实体类的，所以双数据源的配置和mybaties 稍有不同，需要配置两套domain,两套repository 项目地址 项目的目录如下： DataSourceConfig.java中配置双数据源 @Configuration public class DataSourceConfig { @Bean(name =...
SpringBoot Jpa多数据源(MySQL+Oracle不同数据库) 双数据源
tanzongbiao的专栏
03-22 4439
注意：@Transactional非默认数据库时需放在Repo层 否则会报错： 默认数据库无此问题 TransactionRequiredException: Executing an update/delete query 解决方法：@Transactional从Impl移到Repo import javax.transaction.Transactional; //删除ById(JPQL) @Transactional @Modifying @Query(value = "update Me
（原）springboot jpa 配置多数据源（多数据源:大于等于2个数据库）
qq_27954241的博客
07-17 776
异常：dataSource或dataSourceClassName或jdbcUrl是必需的。【下面有介绍】 因为光速没有URL属性（但是确实有一个JDBCURL属性）。在这种情况下，您必须重写您的配置如下 spring.datasource.primary.url=jdbc:mysql://IP地址/drp_db spring.datasource.primary.jdbc-url=jdb...
Springboot JPA实现多数据源配置
随心居
02-20 858
要实现一个MES系统的web-API接口，MES系统是购买的商业软件，厂商的接口报价过高，因此由内部IT团队开发实现这个接口。考虑到系统的追溯性，因此设计一个中间库，第三方报工系统传过来的数据同时存放在中间库和MES系统里。搜索查阅了很多博文及实验后，终于实现了多数据库的访问，调试时遇到了几个问题，在搜索后也找到了解决方案并修正。这样就完成了多数据源的配置，以后在相应的db目录下创建相关的entity和repository。
SpringJPA+Druid配置多数据源
wtopps的专栏
08-07 566
SpringJPA配置多数据源
spring+Jpa多数据源配置的方法示例
08-27
Spring+JPA多数据源配置方法示例 Spring+JPA多数据源配置是指在 Spring 框架中使用 JPA（Java Persistence API）来访问多个数据源的配置方法。该配置方法允许开发者在一个应用程序中访问多个数据库，实现数据的集成...
springboot+jpa配置多数据源（Oracle+SqlServer）
Amy_Victoria的博客
09-21 2863
springboot+jpa配置多数据源（Oracle+SqlServer）
spring-boot jpa 配置两个数据源
艾@七的专栏
05-02 1万+
spring-boot jpa 配置两个数据源 内容简介 1、配置两个mysql数据库 2、配置一个mysql,一个h2内存数据库 如何配置两个mysql数据库 1、配置文件 首先，连接数据的配置文件需要改变，即增加第二个数据库的url，username,password 下面给出我的测试配置，仅供参考: spring: datasource:
springboot springjpa 支持多个数据源
热门推荐
ba5189tsl的专栏
08-07 2万+
1.SpringBoot的程序启动类 import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.builder.SpringApplicatio
SpringBoot、SpringData JPA 双数据源，记录一下
qq_35341771的博客
12-16 188
关闭数据源和事务的自动配置，启动类上 @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class}) 1、pom.xml配置 spring: profiles: active: d...
Spring Boot 多数据源配置（JPA）
09-02 2762
一般一个系统至少有一个数据源，用来持久化业务数据以及查询。单个数据源的系统很常见，在 Spring Boot 框架下配置也很简单。在约定大于配置这个思想下，只需要在配置文件中简单配置下数据库连接信息就行了。除了单数据源系统，在实际工作中，还会遇到多数据源系统。
springboot+jpa 配置多数据源
最新发布
weixin_42934205的博客
10-19 1174
项目结构是。
[spring jpa] 解决SimpleJpaRepository的多数据源配置问题
qq_38472451的博客
05-06 234
[spring jpa] 解决SimpleJpaRepository的多数据源配置问题
Spring Data JPA 之 多数据源配置
曾小二的博客
08-14 6634
我们都知道 DataSource 的本质是获得数据库连接，⽽ AbstractRoutingDataSource 帮我们实现了动态获得数据源的可能性。
Springboot 之 JPA 多数据源实现
天行健，君子以自强不息；地势坤，君子以厚德载物。
09-10 1991
简介微服务推崇单服务单数据库；但是还是免不了存在一个微服务连接多个数据库的情况，今天介绍一下如何使用 JPA 的多数据源。主要采用将不同数据库的 Repository 接口分别存放到不同的 package，Spring 去扫描不同的包，注入不同的数据源来实现多数据源。创建 jpa-multip-datasource 项目分别创建db01和db02数据库学生表 t_studentCREATETAB...
JPA 配置多数据源
qq_26182553的博客
07-13 325
1. META-INF/persistence.xml   <persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/pers
Tomcat + JPA多数据源实现
lhd85的博客
07-16 1297
JPA多数据源配置
Springboot双数据源配置与实践指南
本知识点详细探讨了在Spring Boot项目中配置双数据源的多种实现方式，并提供了相应的代码示例。通过这些知识点的学习，开发者可以更好地掌握在实际项目中灵活使用多个数据源的技巧。这些配置对于处理复杂的业务逻辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值