Java SharedCacheMode类代码示例

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Bean
public EntityManagerFactory entityManagerFactory() {
    logger.debug("Configuring EntityManager");
    LocalContainerEntityManagerFactoryBean lcemfb = new LocalContainerEntityManagerFactoryBean();
    lcemfb.setPersistenceProvider(new HibernatePersistenceProvider());
    lcemfb.setPersistenceUnitName("persistenceUnit");
    lcemfb.setDataSource(dataSource());
    lcemfb.setJpaDialect(new HibernateJpaDialect());
    lcemfb.setJpaVendorAdapter(jpaVendorAdapter());
    lcemfb.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
    Properties jpaProperties = new Properties();
    jpaProperties.put("hibernate.generate_statistics", false);
    jpaProperties.put("hibernate.show_sql", Boolean.parseBoolean(databaseShowSQL));
    lcemfb.setJpaProperties(jpaProperties);
    lcemfb.setPackagesToScan("cn.org.once.cstack.model");
    lcemfb.afterPropertiesSet();
    return lcemfb.getObject();
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Bean
public EntityManagerFactory entityManagerFactory() {
    logger.debug("Configuring EntityManager");
    LocalContainerEntityManagerFactoryBean lcemfb = new LocalContainerEntityManagerFactoryBean();
    lcemfb.setPersistenceProvider(new HibernatePersistenceProvider());
    lcemfb.setPersistenceUnitName("persistenceUnit");
    lcemfb.setDataSource(dataSource());
    lcemfb.setJpaDialect(new HibernateJpaDialect());
    lcemfb.setJpaVendorAdapter(jpaVendorAdapter());
    lcemfb.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
    Properties jpaProperties = new Properties();
    jpaProperties.put("hibernate.generate_statistics", true);
    jpaProperties.put("hibernate.show_sql", Boolean.parseBoolean(databaseShowSQL));
    lcemfb.setJpaProperties(jpaProperties);
    lcemfb.setPackagesToScan("cn.org.once.cstack.model");
    lcemfb.afterPropertiesSet();
    return lcemfb.getObject();
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean() {
	Map<String, Object> properties = new Hashtable<>();
	properties.put("javax.persistence.schema-generation.database.action", "none");
	properties.put("hibernate.connection.characterEncoding", "utf8");
	properties.put("hibernate.connection.useUnicode", "true");
	properties.put("hibernate.connection.charSet", "utf8");
	properties.put("hibernate.search.default.directory_provider", "filesystem");
	properties.put("hibernate.search.default.indexBase", context.getInitParameter("indexDir"));

	HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
	adapter.setDatabasePlatform("org.hibernate.dialect.MySQL5InnoDBDialect");

	LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
	factory.setJpaVendorAdapter(adapter);
	factory.setDataSource(this.bookManagerDataSource());
	factory.setPackagesToScan("net.viperfish.bookManager");
	factory.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
	factory.setValidationMode(ValidationMode.NONE);
	factory.setJpaPropertyMap(properties);
	return factory;
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Bean
@DependsOn(value = {"simpleApplicationContextHolder"})
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
    final LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
    factoryBean.setDataSource(dataSource);
    factoryBean.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
    factoryBean.setValidationMode(ValidationMode.CALLBACK);
    factoryBean.setJpaVendorAdapter(jpaVendorAdapter);
    factoryBean.setPackagesToScan("com.devicehive.model");

    final Properties props = new Properties();
    props.putAll(this.properties.getHibernateProperties(this.dataSource));
    if (useNativeClient) {
        props.put("hibernate.cache.hazelcast.native_client_group", groupName);
        props.put("hibernate.cache.hazelcast.native_client_password", groupPassword);
        if (!CollectionUtils.isEmpty(clusterMembers)) {
            props.put("hibernate.cache.hazelcast.native_client_address", clusterMembers.get(0));
        }
    }

    factoryBean.setJpaProperties(props);
    return factoryBean;
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Override
public void endElement(String uri, String localName, String name) throws SAXException {
    String s = builder.toString().trim();
    // This step is VERY important, otherwise we pollute subsequent
    // elements
    builder = new StringBuilder();

    if ("".equals(s))
        return;

    PersistenceUnit pu = persistenceUnits.peek();

    if ("provider".equals(elementName))
        pu.setProviderClassName(s);
    else if ("jta-data-source".equals(elementName))
        pu.setJtaDataSourceName(s);
    else if ("non-jta-data-source".equals(elementName))
        pu.setNonJtaDataSourceName(s);
    else if ("class".equals(elementName))
        pu.addClassName(s);
    else if("mapping-file".equals(elementName))
    	pu.addMappingFile(s);
    else if ("exclude-unlisted-classes".equals(elementName))
        pu.setExcludeUnlisted(Boolean.parseBoolean(s));
    else if ("shared-cache-mode".equals(elementName))
        pu.setSharedCacheMode(SharedCacheMode.valueOf(s));
    else if ("validation-mode".equals(elementName))
        pu.setValidationMode(ValidationMode.valueOf(s));
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
private static Cache determineCacheSettings(XClass clazzToProcess, Mappings mappings) {
	Cache cacheAnn = clazzToProcess.getAnnotation( Cache.class );
	if ( cacheAnn != null ) {
		return cacheAnn;
	}

	Cacheable cacheableAnn = clazzToProcess.getAnnotation( Cacheable.class );
	SharedCacheMode mode = determineSharedCacheMode( mappings );
	switch ( mode ) {
		case ALL: {
			cacheAnn = buildCacheMock( clazzToProcess.getName(), mappings );
			break;
		}
		case ENABLE_SELECTIVE: {
			if ( cacheableAnn != null && cacheableAnn.value() ) {
				cacheAnn = buildCacheMock( clazzToProcess.getName(), mappings );
			}
			break;
		}
		case DISABLE_SELECTIVE: {
			if ( cacheableAnn == null || cacheableAnn.value() ) {
				cacheAnn = buildCacheMock( clazzToProcess.getName(), mappings );
			}
			break;
		}
		default: {
			// treat both NONE and UNSPECIFIED the same
			break;
		}
	}
	return cacheAnn;
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
/**
 * Create new EntityManagerFactory
 *
 * @param dataSource          the data source
 * @param hibernateProperties the hibernate properties
 * @return the entity manager factory
 */
@Bean
public EntityManagerFactory entityManagerFactory(final DataSource dataSource, final Properties hibernateProperties) {
    final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
    em.setDataSource(dataSource);
    em.setPackagesToScan(entitymanagerPackagesToScan);
    em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
    em.setJpaProperties(hibernateProperties);
    em.setPersistenceUnitName("nestedbird");
    em.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
    em.setPersistenceProviderClass(HibernatePersistenceProvider.class);
    em.afterPropertiesSet();

    return em.getObject();
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean() {
    Map<String, Object> properties = new HashMap<>();
    // properties.put("javax.persistence.schema-generation.database.action", "none"); // 没有update选项，只有：none、create、drop-and-create、drop，不满足开发需求
    // properties.put("hibernate.hbm2ddl.auto", "update"); // 使用adapter.setGenerateDdl(true)，避免拼写错误;
    properties.put("hibernate.ejb.use_class_enhancer", "true");
    properties.put("hibernate.search.default.directory_provider", "filesystem");
    properties.put("hibernate.search.lucene_version", "5.3.1"); // 避免控制台警告，默认使用LUCENE_CURRENT
    properties.put("hibernate.search.default.indexBase", "../amanda/searchIndexes");

    // properties.put("hibernate.show_sql", "true");
    // properties.put("hibernate.format_sql", "true");
    properties.put("hibernate.use_sql_comments", "true");
    properties.put("hibernate.physical_naming_strategy", "com.timeyang.amanda.core.jpa.naming.PhysicalNamingStrategyImpl");

    LocalContainerEntityManagerFactoryBean factory =
            new LocalContainerEntityManagerFactoryBean();
    factory.setDataSource(this.dataSource);
    factory.setJpaVendorAdapter(jpaVendorAdapter());
    factory.setPackagesToScan(AmandaApplication.class.getPackage().getName());
    factory.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
    factory.setValidationMode(ValidationMode.NONE);
    factory.setLoadTimeWeaver(this.loadTimeWeaver()); // TODO: remove when SPR-10856 fixed
    factory.setJpaPropertyMap(properties);
    return factory;
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Override
public SharedCacheMode getSharedCacheMode() {
    // for develop
    return SharedCacheMode.NONE;
    // for production
    // return SharedCacheMode.ENABLE_SELECTIVE;
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
private PersistenceUnitInfo createPersistenceUnitInfo() {
    PersistenceUnitInfo persistenceUnitInfo = mock(PersistenceUnitInfo.class);
    when(persistenceUnitInfo.getPersistenceUnitRootUrl()).thenReturn(createPersistenceUnitRootUrl());
    when(persistenceUnitInfo.getPersistenceUnitName()).thenReturn("annotation-based-field-access");
    when(persistenceUnitInfo.getTransactionType())
        .thenReturn(PersistenceUnitTransactionType.RESOURCE_LOCAL);
    when(persistenceUnitInfo.getValidationMode()).thenReturn(ValidationMode.AUTO);
    when(persistenceUnitInfo.getSharedCacheMode()).thenReturn(SharedCacheMode.UNSPECIFIED);
    when(persistenceUnitInfo.getJtaDataSource()).thenReturn(null);
    when(persistenceUnitInfo.getNonJtaDataSource()).thenReturn(null);
    when(persistenceUnitInfo.getNewTempClassLoader()).thenReturn(null);
    when(persistenceUnitInfo.getMappingFileNames()).thenReturn(Collections.<String>emptyList());
    when(persistenceUnitInfo.getJarFileUrls()).thenReturn(Collections.<URL>emptyList());
    when(persistenceUnitInfo.getPersistenceProviderClassName())
        .thenReturn(SecurePersistenceProvider.class.getName());
    when(persistenceUnitInfo.getClassLoader())
        .thenReturn(Thread.currentThread().getContextClassLoader());
    when(persistenceUnitInfo.getManagedClassNames()).thenReturn(Arrays.asList(
        FieldAccessAnnotationTestBean.class.getName(),
        FieldAccessMapKey.class.getName(),
        FieldAccessMapValue.class.getName()
    ));
    when(persistenceUnitInfo.excludeUnlistedClasses()).thenReturn(true);
    Properties properties = new Properties();
    properties.put("org.jpasecurity.persistence.provider", "org.hibernate.ejb.HibernatePersistence");
    properties.put("org.jpasecurity.security.context",
                   "org.jpasecurity.security.authentication.TestSecurityContext");
    properties.put("org.jpasecurity.security.rules.provider",
                   "org.jpasecurity.security.rules.XmlAccessRulesProvider");
    properties.put("hibernate.hbm2ddl.auto", "create-drop");
    properties.put("hibernate.dialect", "org.hibernate.dialect.HSQLDialect");
    properties.put("hibernate.connection.driver_class", "org.hsqldb.jdbcDriver");
    properties.put("hibernate.connection.url", "jdbc:hsqldb:mem:test");
    properties.put("hibernate.connection.username", "sa");
    properties.put("hibernate.connection.password", "");
    when(persistenceUnitInfo.getProperties()).thenReturn(properties);
    return persistenceUnitInfo;
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean()
		throws ConfigurationException, IOException {
	Map<String, Object> properties = new Hashtable<>();
	String indexPath = this.configuration().getString(GlobalConfig.INDEX_PATH);
	if (indexPath == null) {
		indexPath = GlobalConfig.INDEX_PATH_DEFAULT;
	}
	properties.put("javax.persistence.schema-generation.database.action", "none");
	properties.put("hibernate.connection.characterEncoding", "utf8");
	properties.put("hibernate.connection.useUnicode", "true");
	properties.put("hibernate.connection.charSet", "utf8");
	properties.put("hibernate.search.default.directory_provider", "filesystem");
	properties.put("hibernate.search.default.indexBase", indexPath);

	HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
	adapter.setDatabasePlatform("org.hibernate.dialect.MySQL5InnoDBDialect");

	LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
	factory.setJpaVendorAdapter(adapter);
	factory.setDataSource(this.chatDataSource());
	factory.setPackagesToScan("net.viperfish.chatapplication");
	factory.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
	factory.setValidationMode(ValidationMode.NONE);
	factory.setJpaPropertyMap(properties);
	return factory;
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Override
public SharedCacheMode getSharedCacheMode() {
    if (definition.cachingType.isEmpty()) {
        return SharedCacheMode.UNSPECIFIED;
    }
    return SharedCacheMode.valueOf(definition.cachingType);
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Override
public SharedCacheMode getSharedCacheMode() {
    PersistenceUnitCachingType sharedCacheMode = persistenceUnitXml.getSharedCacheMode();
    if (sharedCacheMode == null) {
        return null;
    }

    return SharedCacheMode.valueOf(sharedCacheMode.name());
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Bean
public EntityManagerFactory entityManagerFactory() {
   LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
   emf.setDataSource(dataSource());
   emf.setPackagesToScan(new String[] {"pl.edu.icm.saos.persistence"});
   emf.setSharedCacheMode(SharedCacheMode.ENABLE_SELECTIVE);
   HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
   emf.setJpaVendorAdapter(vendorAdapter);
   emf.setJpaProperties(hibernateProperties());
   emf.afterPropertiesSet();
   emf.setJpaDialect(new DefaultIsolationLevelJpaDialect());
   return emf.getObject();
}
 

import javax.persistence.SharedCacheMode; //导入依赖的package包/类
@Override
public SharedCacheMode getSharedCacheMode() {
	PersistenceUnitCachingType sharedCacheMode = persistenceUnitXml.getSharedCacheMode();
	if (sharedCacheMode == null)
		return null;

	return SharedCacheMode.valueOf(sharedCacheMode.name());
}