标签：hibernate return springboot 数据源 builder 配置 datasource name

spring boot 链接两个数据源，操作两个数据库

本文章使用的是持久化框架为JPA，所以数据源也是基于JPA。采用的是SpringBoot2 + SpringDataJPA + MySQL + 双数据源！

 

一、双数据源的适用场景：

1、主从库分离（数据库读写分离）

2、数据迁移

3、系统版本升级，数据库升级到另外一款

 

二、application.properties中配置

#mysql数据源
spring.datasource.one.type= com.alibaba.druid.pool.DruidDataSource
spring.datasource.one.jdbc-url= jdbc:mysql://localhost:3306/hongtianyu_sync?useSSL=false&serverTimezone=Asia/Shanghai
spring.datasource.one.username= root
spring.datasource.one.password= root
spring.datasource.one.driver-class-name= com.mysql.cj.jdbc.Driver
#spring.datasource.one.database:mysql
#sqlserver数据源
#spring.datasource.two.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.two.jdbc-url = jdbc:mariadb://192.168.7.22:3309/power?useSSL=false&serverTimezone=Asia/Shanghai
spring.datasource.two.username = zhongfu
spring.datasource.two.password = zhongfu
spring.datasource.two.driver-class-name = org.mariadb.jdbc.Driver

 

 

三、读取application.properties配置的两个数据源，并将其注入到Spring的IOC容器中

 

@Configuration
public class DataSourceConfig {
​
    /**
     * 
     * @return
     * @explains mysql 数据源
     */
    @Primary
    @Bean(name = "oneDataSource")
    @Qualifier(value = "oneDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.one")
    public DataSource mysqlDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    /**
     * 
     * @return
     * @explains mariaDB数据源
     */
    @Bean(name = "twoDataSource")
    @Qualifier(value = "twoDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.two")
    public DataSource mariaDataSource() {
        return DataSourceBuilder.create().build();
    }
}

注解解释：

@Configuration：SpringBoot启动将该类作为配置类，同配置文件一起加载

@Bean：将该实体注入到IOC容器中

@Qualifier：指定数据源名称，与Bean中的name属性原理相同，主要是为了确保注入成功

@Primary：指定主数据源

@ConfigurationProperties：将配置文件中的数据源读取到方法中，进行build

 

 

四、以类的方式配置两个数据源

 

（1）主数据源（对应DataSourceConfig类中的oneDataSource）

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "entityManagerFactoryOne",//EntityManagerFactory引用
        transactionManagerRef = "transactionManagerOne",//transactionManager引用
        basePackages = {"com.diyuan.sync.dao"}) //设置oneDataSource应用到的包,设置DAO接口层所在包位置
public class OneDataSourceConfig {
    /**
     * @explains 注入mysql数据源
     */
    @Autowired
    @Qualifier("oneDataSource")
    private DataSource oneDataSource;
    /**
     * @explains 注入jpa配置实体
     */
    @Autowired
    private JpaProperties jpaProperties;
    @Autowired
    private HibernateProperties hibernateProperties;
    
    @Primary
    @Bean(name = "entityManagerOne")
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactoryOne(builder).getObject().createEntityManager();
    }
    /**
     * 
     * @param builder
     * @return 实体管理工厂
     * @explains 配置EntityManagerFactory实体
     * packges 扫描@Entity注释软件包名称
     * persistenceUnit 持久性单元的名称 如果只建立一个EntityManagerFactory 可以省略。如果有多个 则应该给不同的名字
     * properties 标准jpa或供应商特定配置的通用属性 这些属性覆盖构造函数中提供的任何值
     */
    @Primary
    @Bean(name = "entityManagerFactoryOne")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryOne(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(oneDataSource)
                .properties(getVendorProperties())//获取jpa配置
                //.properties(hibernateProperties.determineHibernateProperties(getVendorProperties2(oneDataSource), new HibernateSettings()))
                .packages("com.diyuan.sync.model")//设置实体类所在位置
                .persistenceUnit("onePersistenceUnit")//持久化单位名称
                //.persistenceUnit("primaryPersistenceUnit")
                .build();
    }
    /**
     * 
     * @return
     * @explains 
     */
//  private Map<String, String> getVendorProperties2(DataSource dataSource){
//      jpaProperties.setDatabase(Database.MYSQL);
//      Map<String, String> map = new HashMap<>();
//          map.put("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect");
//          map.put("hibernate.hbm2ddl.auto", "update");
//          map.put("hibernate.physical_naming_strategy", "org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl");
//          //jpaProperties.setProperties(map);
//          //hibernateProperties.determineHibernateProperties(map, new HibernateSettings());
//          return  map;
//  }
    //获取Properties设置中的jpa设置
    private Map<String, Object> getVendorProperties(){
        Map<String,Object> ret = hibernateProperties.determineHibernateProperties(
                jpaProperties.getProperties(), new HibernateSettings());
        ret.put("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect");
        ret.put("hibernate.cglib.use_reflection_optimizer", "false");
        return ret;
    }
    /**
     * 
     * @param builder
     * @return 事务管理器
     * @explains 配置事务transactionManager
     */
    @Primary
    @Bean(name = "transactionManagerOne")
    public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactoryOne(builder).getObject());
    }
}
​

（2）从（次）数据源

​
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "entityManagerFactoryTwo",
        transactionManagerRef = "transactionManagerTwo",
        basePackages = {"com.diyuan.sync.transferDao"})
public class TwoDataSourceConfig {
    @Resource
    @Qualifier("twoDataSource")
    private DataSource twoDataSource;
    @Resource
    private JpaProperties jpaProperties;
    @Resource
    private HibernateProperties hibernateProperties;
    
    @Bean(name = "entityManagerTwo")
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactoryTwo(builder).getObject().createEntityManager();
    }
    @Bean(name = "entityManagerFactoryTwo")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryTwo(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(twoDataSource)
                .properties(getVendorProperties())
                .packages("com.diyuan.sync.transferModel")
                .persistenceUnit("twoPersistenceUnit")
                //.persistenceUnit("primaryPersistenceUnit")
                .build();
    }
    private Map<String, Object> getVendorProperties(){
        Map<String,Object> ret = hibernateProperties.determineHibernateProperties(
                jpaProperties.getProperties(), new HibernateSettings());
        ret.put("hibernate.dialect", "org.hibernate.dialect.MariaDBDialect");
        ret.put("hibernate.cglib.use_reflection_optimizer", "false");
        return ret;
    }
    @Bean(name = "transactionManagerTwo")
    public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactoryTwo(builder).getObject());
    }
}

 

这两个类主要配置每个数据源，包括事务管理器、以及实体管理器等配置。

注：必须要指定DAO接口所在的包以及实体类所在的包。每个数据源主要操作它指定的资源（DAO接口CURD、实体类）

 

 

五、注意点：

1、SpringBoot启动类必须关闭 --程序启动加载的仓库（@EnableJpaRepositories），因为在数据源配置类中已经开启了。如果没有去掉，程序会跑不起来！

2、如果需要对数据源连接的表进行DDL（正向生成表、程序启动动态更新表），需要在PrimaryConfig类中 / SecondaryConfig类中的getVendorProperties()方法中进行手动设置（此教程都已设置好了！）

标签：hibernate,return,springboot,数据源,builder,配置,datasource,name
来源： https://www.cnblogs.com/xiaomodaydayup/p/15135787.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。