@Primary
@Bean(name = "userEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(
        EntityManagerFactoryBuilder builder, @Qualifier("userDataSource") DataSource userDataSource) {

    Map<String, Object> properties = new HashMap<>();
    properties.put("hibernate.hbm2ddl.auto",
            env.getProperty("spring.jpa.hibernate.ddl-auto"));
    properties.put("hibernate.dialect",
            env.getProperty("spring.jpa.properties.hibernate.dialect"));
    return builder
            .dataSource(userDataSource)
            .properties(properties)
            .packages(UserRepository.class.getPackage().getName())
            .persistenceUnit("userPU")
            .build();
}
 

@Bean(name = "cardEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean cardEntityManagerFactory(
        EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(cardDataSource())
            .packages(Card.class)
            .build();
}
 

@Primary
@Bean(name = "memberEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean memberEntityManagerFactory(EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(memberDataSource())
            .packages(Member.class)
            .build();
}
 

@Bean(name = "cardHolderEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean cardHolderEntityManagerFactory(
        EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(cardholderDataSource())
            .packages(CardHolder.class)
            .build();
}
 

@Bean(name = "secondaryEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(@Qualifier("secondaryDataSource") DataSource secondaryDataSource, EntityManagerFactoryBuilder builder) {
    return builder.dataSource(secondaryDataSource)
            .properties(jpaProperties.getProperties())
            .packages("com.actionsky.txle.grpc.entity")
            .persistenceUnit("secondaryPersistenceUnit")
            .build();
}
 

@Primary
@Bean(name = "primaryEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(@Qualifier("primaryDataSource") DataSource primaryDataSource, EntityManagerFactoryBuilder builder) {
    return builder.dataSource(primaryDataSource)
            .properties(jpaProperties.getProperties())
            .packages("com.actionsky.txle.grpc.entity")
            .persistenceUnit("primaryPersistenceUnit")
            .build();
}
 

@Bean(destroyMethod = "", name = "entityManagerPrimary")
@Primary
public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
    return entityManagerFactoryPrimary(builder)
            .getObject()
            .createEntityManager();
}
 

@Bean(destroyMethod = "", name = "entityManagerFactoryPrimary")
@Primary
public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary(EntityManagerFactoryBuilder builder) {
    return builder.dataSource(r_ds)
            .properties(getVendorProperties(r_ds))
            .packages("cn.cib.entity.read")
            .persistenceUnit("primaryPersistenceUnit")
            .build();
}
 

@Bean(destroyMethod = "", name = "entityManagerFactorySecondary")
public LocalContainerEntityManagerFactoryBean entityManagerFactorySecondary(EntityManagerFactoryBuilder builder) {
    return builder.dataSource(w_ds)
            .properties(getVendorProperties(w_ds))
            .packages("cn.cib.entity.write")
            .persistenceUnit("secondaryPersistenceUnit").build();
}
 

@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder factory, DataSource dataSource, JpaProperties properties) {
  HibernateSettings settings = new HibernateSettings();
  settings.ddlAuto("create-drop");
  Map<String, Object> jpaProperties = new HashMap<>(properties.getHibernateProperties(settings));
  jpaProperties.put("hibernate.ejb.interceptor", hibernateInterceptor());
  return factory.dataSource(dataSource).packages("com.example").properties(jpaProperties).build();
}
 

@Autowired
@Bean
LocalContainerEntityManagerFactoryBean localContainerEntityManagerFactoryBean(@Qualifier(value =
        "EmbeddeddataSource") DataSource dataSource, EntityManagerFactoryBuilder builder) {
    return builder.dataSource(dataSource)
            .packages("com.mindata.blockchain.core.model")
            .properties(getVendorProperties(dataSource))
            .build();
}
 

@Primary
@Bean(name = "secondEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary (EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(dataSource)
            .properties(getVendorProperties(dataSource))
            .packages("com.wuwii.module.user.entity") //设置实体类所在位置
            .persistenceUnit("secondPersistenceUnit")
            .build();
}
 

@Bean(name = "secondEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary(EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(secondDataSource())
            .properties(getVendorProperties(secondDataSource()))
            .packages("com.wuwii.module.user.entity") //设置该数据源锁对应的实体类所在的位置
            .persistenceUnit("secondPersistenceUnit")
            .build();
}
 

@Primary
@Bean(name = "firstEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary(EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(firstDataSource())
            .properties(getVendorProperties(firstDataSource()))
            .packages("com.wuwii.module.system.entity") //设置该数据源对应的实体类所在位置
            .persistenceUnit("firstPersistenceUnit")
            .build();
}
 

/**
 * 实体管理对象
 * @param builder 由spring注入这个对象，首先根据type注入（多个就取声明@Primary的对象），否则根据name注入
 * @return
 */
@Bean
@Primary
public LocalContainerEntityManagerFactoryBean firstEntityManagerFactory(
        EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(firstDataSource())
            .packages("com.luotuo.entity")
            .persistenceUnit("firstDs")
            .build();
}
 

/**
 * 实体管理对象
 * @param builder 由spring注入这个对象，首先根据type注入（多个就取声明@Primary的对象），否则根据name注入
 * @return
 */
@Bean(name = "secondEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean secondEntityManagerFactory(
        EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(secondDataSource())
            .packages("com.luotuo.user.entity")
            .persistenceUnit("secondDs")
            .build();
}
 

/**
 * EntityManagerFactory类似于Hibernate的SessionFactory,mybatis的SqlSessionFactory
 * 总之,在执行操作之前,我们总要获取一个EntityManager,这就类似于Hibernate的Session,
 * mybatis的sqlSession.
 * @return
 */
@Bean(name = "readEntityManagerFactoryBean")
public LocalContainerEntityManagerFactoryBean readEntityManagerFactoryBean(EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(readDruidDataSource)
            .properties(jpaProperties.getProperties())
            .packages("com.lengchuan.springBoot.jpa.entity") //设置实体类所在位置
            .persistenceUnit("readPersistenceUnit")//持久化单元名称
            .build();
    //.getObject();
}
 

/**
 * 我们通过LocalContainerEntityManagerFactoryBean来获取EntityManagerFactory实例
 * @return
 */
@Bean(name = "writeEntityManagerFactoryBean")
@Primary
public LocalContainerEntityManagerFactoryBean writeEntityManagerFactoryBean(EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(writeDruidDataSource)
            .properties(jpaProperties.getProperties())
            .packages("com.lengchuan.springBoot.jpa.entity") //设置实体类所在位置
            .persistenceUnit("writePersistenceUnit")
            .build();
    //.getObject();//不要在这里直接获取EntityManagerFactory
}
 

public EntityManagerFactoryBuilder getEntityManagerFactoryBuilder(DataSource dataSource) {
	JpaVendorAdapter jpaVendorAdapter = getJpaVendorAdapter(dataSource);
	EntityManagerFactoryBuilder builder = new EntityManagerFactoryBuilder(
			jpaVendorAdapter, properties.getProperties(),
			this.persistenceUnitManager);
	return builder;
}
 

@Bean
public EntityManagerFactoryBuilder entityManagerFactoryBuilder(
    JpaVendorAdapter jpaVendorAdapter,
    ObjectProvider<PersistenceUnitManager> persistenceUnitManager) {
  return new EntityManagerFactoryBuilder(
      jpaVendorAdapter, jpaProperties.getProperties(),
      persistenceUnitManager.getIfAvailable());
}
 

/**
 * 获取主库实体管理工厂对象
 *
 * @param secondDataSource 注入名为secondDataSource的数据源
 * @param jpaProperties    注入名为secondJpaProperties的jpa配置信息
 * @param builder          注入EntityManagerFactoryBuilder
 * @return 实体管理工厂对象
 */
@Bean(name = "secondEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(@Qualifier("secondDataSource") DataSource secondDataSource, @Qualifier("secondJpaProperties") JpaProperties jpaProperties, EntityManagerFactoryBuilder builder) {
    return builder
            // 设置数据源
            .dataSource(secondDataSource)
            // 设置jpa配置
            .properties(jpaProperties.getProperties())
            // 设置实体包名
            .packages(ENTITY_PACKAGE)
            // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
            .persistenceUnit("secondPersistenceUnit").build();
}
 

/**
 * 获取主库实体管理工厂对象
 *
 * @param primaryDataSource 注入名为primaryDataSource的数据源
 * @param jpaProperties     注入名为primaryJpaProperties的jpa配置信息
 * @param builder           注入EntityManagerFactoryBuilder
 * @return 实体管理工厂对象
 */
@Primary
@Bean(name = "primaryEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(@Qualifier("primaryDataSource") DataSource primaryDataSource, @Qualifier("primaryJpaProperties") JpaProperties jpaProperties, EntityManagerFactoryBuilder builder) {
    return builder
            // 设置数据源
            .dataSource(primaryDataSource)
            // 设置jpa配置
            .properties(jpaProperties.getProperties())
            // 设置实体包名
            .packages(ENTITY_PACKAGE)
            // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
            .persistenceUnit("primaryPersistenceUnit").build();
}
 

/**
 * 我们通过LocalContainerEntityManagerFactoryBean来获取EntityManagerFactory实例
 *
 * @return
 */
@Bean(name = "dataEntityManagerFactoryBean")
public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(dataSource)
            .properties(jpaProperties.getProperties())
            //设置实体类所在位置
            .packages("org.superboot.entity.jpa")
            .persistenceUnit("dataPersistenceUnit")
            .build();
}
 

public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(String name, final DataSource dataSource) {
    EntityManagerFactoryBuilder emfBuilder = new EntityManagerFactoryBuilder(
            vendorAdapter(), getProperties(), null);
    Builder builder = emfBuilder
            .dataSource(dataSource)
            .persistenceUnit(name)
            .properties(hibernate.determineHibernateProperties(getProperties(), new HibernateSettings()))
            .jta(false);
    if (ArrayUtils.isNotEmpty(annotatedClasses)) {
        builder.packages(annotatedClasses);
    } else {
        builder.packages(packageToScan);
    }
    return builder.build();
}
 

@Bean(name = "companyEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(
        EntityManagerFactoryBuilder builder, @Qualifier("companyDataSource") DataSource companyDataSource) {
    Map<String, Object> properties = new HashMap<>();
    properties.put("hibernate.hbm2ddl.auto",
            env.getProperty("spring.jpa.hibernate.ddl-auto"));
    properties.put("hibernate.dialect",
            env.getProperty("spring.jpa.properties.hibernate.dialect"));
    return builder
            .dataSource(companyDataSource)
            .properties(properties)
            .packages(CompanyRepository.class.getPackage().getName())
            .persistenceUnit("companyPU")
            .build();
}
 

public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(String name, final DataSource dataSource) {
    EntityManagerFactoryBuilder emfBuilder = new EntityManagerFactoryBuilder(
            vendorAdapter(), getProperties(), null);
    Builder builder = emfBuilder
            .dataSource(dataSource)
            .persistenceUnit(name)
            .properties(hibernate.determineHibernateProperties(getProperties(), new HibernateSettings()))
            .jta(false);
    if (ArrayUtils.isNotEmpty(annotatedClasses)) {
        builder.packages(annotatedClasses);
    } else {
        builder.packages(packageToScan);
    }
    return builder.build();
}
 

protected void setupEntityManagerFactory() {
    DataSource ds = EntityTestFactory.dataSource();
    Map<String, String> props = new HashMap<>();
    props.put(AvailableSettings.HBM2DDL_AUTO, "create-drop");
    Builder builder = new EntityManagerFactoryBuilder(new HibernateJpaVendorAdapter(), props, null)
            .dataSource(ds)
            .jta(false);
    if (!targetEntities.isEmpty()) {
        builder.packages(targetEntities.toArray(new Class<?>[0]));
    }
    LocalContainerEntityManagerFactoryBean emfBean = builder.build();
    emfBean.afterPropertiesSet();
    emf = emfBean.getObject();
    txm = new JpaTransactionManager(emf);
}
 

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

@Bean(destroyMethod = "", name = "entityManagerSecondary")
public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
    return entityManagerFactorySecondary(builder).getObject().createEntityManager();
}
 

@Bean(destroyMethod = "", name = "transactionManagerSecondary")
PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {
    return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
}