Java PersistenceUnitProperties类代码示例

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
@Override
public Map<String, Object> getJpaPropertyMap() {
	Map<String, Object> jpaProperties = new HashMap<String, Object>();

	if (getDatabasePlatform() != null) {
		jpaProperties.put(PersistenceUnitProperties.TARGET_DATABASE, getDatabasePlatform());
	}
	else if (getDatabase() != null) {
		String targetDatabase = determineTargetDatabaseName(getDatabase());
		if (targetDatabase != null) {
			jpaProperties.put(PersistenceUnitProperties.TARGET_DATABASE, targetDatabase);
		}
	}

	if (isGenerateDdl()) {
		jpaProperties.put(PersistenceUnitProperties.DDL_GENERATION,
				PersistenceUnitProperties.CREATE_ONLY);
		jpaProperties.put(PersistenceUnitProperties.DDL_GENERATION_MODE,
				PersistenceUnitProperties.DDL_DATABASE_GENERATION);
	}
	if (isShowSql()) {
		jpaProperties.put(PersistenceUnitProperties.LOGGING_LEVEL, Level.FINE.toString());
	}

	return jpaProperties;
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
/**
 * Returns the singleton EntityManagerFactory instance for accessing the
 * default database.
 * 
 * @return the singleton EntityManagerFactory instance
 * @throws NamingException
 *             if a naming exception occurs during initialization
 * @throws SQLException
 *             if a database occurs during initialization
 * @throws IOException 
 */
public static synchronized EntityManagerFactory getEntityManagerFactory()
		throws NamingException, SQLException, IOException {
	if (entityManagerFactory == null) {
		InitialContext ctx = new InitialContext();
	    BasicDataSource ds = new BasicDataSource();
	    JsonNode credentials = readCredentialsFromEnvironment();
		ds.setDriverClassName(credentials.get("driver").asText());
	    ds.setUrl(credentials.get("url").asText());
	    ds.setUsername(credentials.get("user").asText());
	    ds.setPassword(credentials.get("password").asText());
		Map<String, Object> properties = new HashMap<String, Object>();
		properties.put(PersistenceUnitProperties.NON_JTA_DATASOURCE, ds);
		entityManagerFactory = Persistence.createEntityManagerFactory(
				PERSISTENCE_UNIT_NAME, properties);
	}
	return entityManagerFactory;
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
private Properties eclipseProperties(boolean fresh) {
    Properties properties = new Properties();
    properties.put(PersistenceUnitProperties.CACHE_SHARED_DEFAULT, "false");
    properties.put(PersistenceUnitProperties.WEAVING, "static");
    properties.put("eclipselink.logging.level.sql", "FINE");
    try {
        Class.forName("cz.encircled.joiner.eclipse.InheritanceJoiningSessionCustomizer");
        properties.put("eclipselink.session.customizer", "cz.encircled.joiner.eclipse.InheritanceJoiningSessionCustomizer");
    } catch (Exception e) {
        // ignore
    }
    if (fresh) {
        properties.put(PersistenceUnitProperties.DDL_GENERATION, "drop-and-create-tables");
    }
    return properties;
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
/**
   * {@inheritDoc}
   */
  @Override
  protected void loadCustomJpaDefaults(Map<String, String> jpaProperties) {
if (getPersistenceUnitManager().getDefaultJtaDataSource() != null
		&& !jpaProperties.containsKey(PersistenceUnitProperties.TARGET_SERVER)) {
          jpaProperties.put(PersistenceUnitProperties.TARGET_SERVER, JtaTransactionController.class.getName());
      }

if (!jpaProperties.containsKey(PersistenceUnitProperties.SESSION_CUSTOMIZER)) {
	jpaProperties.put(PersistenceUnitProperties.SESSION_CUSTOMIZER, KradEclipseLinkCustomizer.class.getName());
}

if (!jpaProperties.containsKey(PersistenceUnitProperties.CACHE_SHARED_DEFAULT)) {
	jpaProperties.put(PersistenceUnitProperties.CACHE_SHARED_DEFAULT, "false");
}
  }
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
@Override
protected Map<String, Object> getVendorProperties() {

    final Map<String, Object> properties = Maps.newHashMapWithExpectedSize(7);
    // Turn off dynamic weaving to disable LTW lookup in static weaving mode
    properties.put(PersistenceUnitProperties.WEAVING, "false");
    // needed for reports
    properties.put(PersistenceUnitProperties.ALLOW_NATIVE_SQL_QUERIES, "true");
    // flyway
    properties.put(PersistenceUnitProperties.DDL_GENERATION, "none");
    // Embeed into hawkBit logging
    properties.put(PersistenceUnitProperties.LOGGING_LOGGER, "JavaLogger");
    // Ensure that we flush only at the end of the transaction
    properties.put(PersistenceUnitProperties.PERSISTENCE_CONTEXT_FLUSH_MODE, "COMMIT");

    // Enable batch writing
    properties.put(PersistenceUnitProperties.BATCH_WRITING, "JDBC");
    // Batch size
    properties.put(PersistenceUnitProperties.BATCH_WRITING_SIZE, "500");

    return properties;
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
@Override
@Transactional
@Retryable(include = {
        ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX, backoff = @Backoff(delay = Constants.TX_RT_DELAY))
public void deleteTenant(final String t) {
    final String tenant = t.toUpperCase();
    cacheManager.evictCaches(tenant);
    rolloutStatusCache.evictCaches(tenant);
    tenantAware.runAsTenant(tenant, () -> {
        entityManager.setProperty(PersistenceUnitProperties.MULTITENANT_PROPERTY_DEFAULT, tenant);
        tenantMetaDataRepository.deleteByTenantIgnoreCase(tenant);
        tenantConfigurationRepository.deleteByTenant(tenant);
        targetRepository.deleteByTenant(tenant);
        targetFilterQueryRepository.deleteByTenant(tenant);
        rolloutRepository.deleteByTenant(tenant);
        targetTagRepository.deleteByTenant(tenant);
        distributionSetTagRepository.deleteByTenant(tenant);
        distributionSetRepository.deleteByTenant(tenant);
        distributionSetTypeRepository.deleteByTenant(tenant);
        softwareModuleRepository.deleteByTenant(tenant);
        artifactRepository.deleteByTenant(tenant);
        softwareModuleTypeRepository.deleteByTenant(tenant);
        return null;
    });
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
private static Properties _loadBBDDVendorProperties(final DBSpec spec) {
	Properties props = new Properties();
	
	props.put(PersistenceUnitProperties.TARGET_DATABASE,spec.getVendor().getCode());	// MySQLPlatformExtension.class.getCanonicalName()		
	
	// used when generating schema 
	props.put(PersistenceUnitProperties.SCHEMA_DATABASE_PRODUCT_NAME,spec.getVendor().getCode());
	props.put(PersistenceUnitProperties.SCHEMA_DATABASE_MAJOR_VERSION,spec.getMajorVersion());
	props.put(PersistenceUnitProperties.SCHEMA_DATABASE_MINOR_VERSION,spec.getMinorVersion());
	
	// enable innoDB tables in MySql (needed for full-text searching)
	if (spec.getVendor().is(DBVendor.MySQL)) {
		props.put("eclipselink.ddl.default-table-suffix","engine=InnoDB");
	}
	
	return props;
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
/**
 * Returns the {@link EntityManagerFactory}.
 * 
 * @return The {@link EntityManagerFactory}
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
protected EntityManagerFactory getEntityManagerFactory()
{
	EntityManagerFactory retVal = null;
	
	try
	{
		Map properties = new HashMap();
		
		DataSource ds = this.getDataSource();
		
        properties.put(PersistenceUnitProperties.NON_JTA_DATASOURCE, ds);
        
        retVal = Persistence.createEntityManagerFactory("application", properties);
	}
	catch (Exception ex)
	{
		ex.printStackTrace();
	}
	
	return retVal;
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
private void init() {

		DataSource ds;
		try {

			InitialContext ctx = new InitialContext();
			ds = (DataSource) ctx.lookup(DATA_SOURCE);

			Map<String, DataSource> properties = new HashMap<>();
			properties.put(PersistenceUnitProperties.NON_JTA_DATASOURCE, ds);
			setFactory(Persistence.createEntityManagerFactory(APPLICATION_NAME, properties));

		} catch (NamingException e) {

			LOGGER.error(ERROR_DATA_SOURCE_INITIALIZATION_FAILED_MESSAGE, e);
			throw new RuntimeException(ERROR_DATA_SOURCE_INITIALIZATION_FAILED_MESSAGE);
		}
	}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
public Configuration save(WriteContext ctx, Configuration configuration) throws Exception {
    EntityManager em = emf.createEntityManager();
    em.setProperty(PersistenceUnitProperties.MULTITENANT_PROPERTY_DEFAULT, ctx.getTenant());

    byte[] key = new byte[32];
    secureRandom.nextBytes(key);
    em.setProperty("key", key);

    byte[] encryptedKey = AsymmetricEncryptionUtils.encrypt(key, ctx.getPublicKey());
    configuration.setKey(encryptedKey);

    em.getTransaction().begin();
    Configuration newConfiguration = em.merge(configuration);
    em.getTransaction().commit();

    return newConfiguration;
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
public Optional<Configuration> findByName(ReadContext ctx, String name) {
    EntityManager em = emf.createEntityManager();
    em.setProperty(PersistenceUnitProperties.MULTITENANT_PROPERTY_DEFAULT, ctx.getTenant());
    em.setProperty("private-key", ctx.getPrivateKey());

    CriteriaBuilder cb = em.getCriteriaBuilder();

    CriteriaQuery<Configuration> q = cb.createQuery(Configuration.class);
    Root<Configuration> c = q.from(Configuration.class);
    ParameterExpression<String> p = cb.parameter(String.class);
    q.select(c).where(cb.equal(c.get("name"), p));

    TypedQuery<Configuration> query = em.createQuery(q);
    query.setParameter(p, name);

    Configuration configuration = query.getSingleResult();

    return Optional.ofNullable(configuration);
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
/**
 * Constructs new entity manager factory.
 *
 * @param persistenceUnit the persistence unit
 * @param propertiesCategory the properties category
 * @return the new entity manager factory.
 */
private static EntityManagerFactory newEntityManagerFactory(String persistenceUnit, String propertiesCategory) {
    final Map properties = new HashMap();
    properties.put(PersistenceUnitProperties.JDBC_DRIVER, PropertiesUtil.getProperty(
            propertiesCategory, PersistenceUnitProperties.JDBC_DRIVER));
    properties.put(PersistenceUnitProperties.JDBC_URL, PropertiesUtil.getProperty(
            propertiesCategory, PersistenceUnitProperties.JDBC_URL));
    properties.put(PersistenceUnitProperties.JDBC_USER, PropertiesUtil.getProperty(
            propertiesCategory, PersistenceUnitProperties.JDBC_USER));
    properties.put(PersistenceUnitProperties.JDBC_PASSWORD, PropertiesUtil.getProperty(
            propertiesCategory, PersistenceUnitProperties.JDBC_PASSWORD));
    properties.put(PersistenceUnitProperties.DDL_GENERATION, PropertiesUtil.getProperty(
            propertiesCategory, PersistenceUnitProperties.DDL_GENERATION));

    return Persistence.createEntityManagerFactory(
            persistenceUnit, properties);
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
private Map<String, Object> buildCfg()
{
    final Map<String, Object> cfg = new TreeMap<>();
    
    cfg.put(PersistenceUnitProperties.SCHEMA_GENERATION_DATABASE_ACTION, PersistenceUnitProperties.SCHEMA_GENERATION_NONE_ACTION);
    cfg.put(PersistenceUnitProperties.SCHEMA_GENERATION_SCRIPTS_ACTION, PersistenceUnitProperties.SCHEMA_GENERATION_CREATE_ACTION);
    cfg.put(PersistenceUnitProperties.SCHEMA_GENERATION_CREATE_SOURCE, PersistenceUnitProperties.SCHEMA_GENERATION_METADATA_SOURCE);
    cfg.put(PersistenceUnitProperties.SCHEMA_GENERATION_SCRIPTS_CREATE_TARGET, ddlTargetFile);
    cfg.put(PersistenceUnitProperties.SCHEMA_DATABASE_PRODUCT_NAME, databaseProductName);
    cfg.put(PersistenceUnitProperties.WEAVING, "false");
    
    if (databaseMajorVersion != null)
    {
        cfg.put(PersistenceUnitProperties.SCHEMA_DATABASE_MAJOR_VERSION, databaseMajorVersion);
    }
    
    if (databaseMinorVersion != null)
    {
        cfg.put(PersistenceUnitProperties.SCHEMA_DATABASE_MINOR_VERSION, databaseMinorVersion);
    }
    
    return cfg;
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
private static void initEntityManagerFactory(DataSource dataSource) {
	logger.debug(DEBUG_INITIALIZING_ENTITY_MANAGER_FACTORY);

	Map<Object, Object> properties = new HashMap<>();
	properties.put(PersistenceUnitProperties.NON_JTA_DATASOURCE, dataSource);

	EntityManagerFactoryProvider.entityManagerFactory = Persistence
			.createEntityManagerFactory(IndiaLocalizationPersistenceUnit.NAME, properties);

	logger.debug(DEBUG_ENTITY_MANAGER_FACTORY_INITIALIZED);
}
 

import org.eclipse.persistence.config.PersistenceUnitProperties; //导入依赖的package包/类
@Override
protected Map<String, Object> getVendorProperties() {
    final Map<String, Object> baseProperties = new HashMap<>();
    baseProperties.put(PersistenceUnitProperties.TABLE_CREATION_SUFFIX, ";");
    baseProperties.put(PersistenceUnitProperties.SESSION_CUSTOMIZER, UUIDSequence.class.getName());
    baseProperties.put("eclipselink.weaving", "false");
    if (environment.acceptsProfiles("debug")) {
        baseProperties.put(PersistenceUnitProperties.LOGGING_LEVEL, "ALL");
    }
    return newHashMap(baseProperties);
}