Java EntityManagerFactoryBuilder类代码示例

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public EntityManagerFactoryBuilder entityManagerFactoryBuilder(
		JpaVendorAdapter jpaVendorAdapter,
		ObjectProvider<PersistenceUnitManager> persistenceUnitManagerProvider) {
	EntityManagerFactoryBuilder builder = new EntityManagerFactoryBuilder(
			jpaVendorAdapter, this.properties.getProperties(),
			persistenceUnitManagerProvider.getIfAvailable());
	builder.setCallback(getVendorCallback());
	return builder;
}
 

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory(
    EntityManagerFactoryBuilder factoryBuilder)
{
    Map<String, Object> vendorProperties = getVendorProperties();
    customizeVendorProperties(vendorProperties);
    LocalContainerEntityManagerFactoryBean emfb = factoryBuilder.dataSource(getDataSource())
        .packages(getPackagesToScan())
        .persistenceUnit("default")
        .properties(vendorProperties)
        .jta(isJta())
        .build();

    emfb.setPersistenceUnitPostProcessors(new JPosPersistentUnitPostProcessor());
    return emfb;
}
 

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
/**
 * Create a {@Link LocalContainerEntityManagerFactoryBean} for the workflow datasource.
 */
@Bean
@WorkflowPersistenceUnit
public LocalContainerEntityManagerFactoryBean workflowEntityManagerFactory(
    EntityManagerFactoryBuilder builder,
    @WorkflowPersistenceUnit DataSource workflowDatasource) {

  LocalContainerEntityManagerFactoryBean factoryBean = builder
      .dataSource(workflowDatasource)
      .packages((String[]) null)
      .persistenceUnit(Constants.PERSISTENCE_UNIT_NAME)
      .jta(true)
      .build();

  // JBPM needs them
  factoryBean.getJpaPropertyMap().put("hibernate.max_fetch_depth", "3");
  factoryBean.getJpaPropertyMap().put("hibernate.id.new_generator_mappings", "false");

  return factoryBean;
}
 

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
@Primary
@Bean(name = "oneEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder builder) {
	DataSource dataSource = dataSource();

	return builder.dataSource(dataSource).packages("com.easynetcn.cloud.one.web.data.entity")
			.persistenceUnit("onePersistenceUnit").build();
}
 

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
@Bean(name = "entityManagerFactoryUser")
public LocalContainerEntityManagerFactoryBean entityManagerFactoryUser (EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(userDataSource)
            .properties(getVendorProperties(userDataSource))
            .packages(new String[]{ "com.myspringboot.repository.user", "com.myspringboot.entity" }) //设置应用userDataSource的基础包名
            .persistenceUnit("userPersistenceUnit")
            .build();
}
 

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
@Primary
@Bean(name = "entityManagerFactoryBook")
public LocalContainerEntityManagerFactoryBean entityManagerFactoryBook (EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(bookDataSource)
            .properties(getVendorProperties(bookDataSource))
            .packages(new String[]{"com.myspringboot.repository.book", "com.myspringboot.entity"}) //设置应用bookDataSource的基础包名
            .persistenceUnit("bookPersistenceUnit")
            .build();
}
 

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
@Bean(name = "entityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(
        EntityManagerFactoryBuilder factory) {
    return factory.dataSource(dataSource())
            .packages("com.nixmash.blog.jpa")
            .properties(getVendorProperties(dataSource()))
            .build();
}
 

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

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

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
/**
 * 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.lc.springBoot.jpa.entity") //设置实体类所在位置
            .persistenceUnit("readPersistenceUnit")//持久化单元名称
            .build();
    //.getObject();
}
 

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

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
@Bean(name = "secondaryEntityManager")
public LocalContainerEntityManagerFactoryBean secondaryEntityManagerFactoryBean(EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(secondaryDataSource())
            .properties(hibernateProperties())
            .packages("com.xiaofeng.domain") //设置实体类所在位置
            .persistenceUnit("secondaryPersistenceUnit")
            .build();
}
 

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
@Primary
@Bean(name = "primaryEntityManager")
public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactoryBean(EntityManagerFactoryBuilder builder) {
    return builder
            .dataSource(primaryDataSource())
            .properties((hibernateProperties()))
            .packages("com.xiaofeng.domain") //设置实体类所在位置
            .persistenceUnit("primaryPersistenceUnit")
            .build();
}
 

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(String name, final DataSource dataSource) {
    EntityManagerFactoryBuilder emfBuilder = new EntityManagerFactoryBuilder(
            vendorAdapter(), getProperties(), null);
    Builder builder = emfBuilder
            .dataSource(dataSource)
            .persistenceUnit(name)
            .properties(getHibernateProperties(dataSource))
            .jta(false);
    if (ArrayUtils.isNotEmpty(annotatedClasses)) {
        builder.packages(annotatedClasses);
    } else {
        builder.packages(packageToScan);
    }
    return builder.build();
}
 

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; //导入依赖的package包/类
@Bean
@Primary
@ConditionalOnMissingBean({ LocalContainerEntityManagerFactoryBean.class,
		EntityManagerFactory.class })
public LocalContainerEntityManagerFactoryBean entityManagerFactory(
		EntityManagerFactoryBuilder factoryBuilder) {
	Map<String, Object> vendorProperties = getVendorProperties();
	customizeVendorProperties(vendorProperties);
	return factoryBuilder.dataSource(this.dataSource).packages(getPackagesToScan())
			.properties(vendorProperties).jta(isJta()).build();
}