javax.persistence.SharedCacheMode Java Examples

@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;
}
 

/**
 * @param igniteInstanceName Node name.
 * @param dfltAccessType Default cache access type.
 * @return Properties map.
 */
static Map<String, String> hibernateProperties(String igniteInstanceName, String dfltAccessType) {
    Map<String, String> map = new HashMap<>();

    map.put(HBM2DDL_AUTO, "create");
    map.put(JPA_SHARED_CACHE_MODE, SharedCacheMode.ALL.name());
    map.put(GENERATE_STATISTICS, "true");
    map.put(USE_SECOND_LEVEL_CACHE, "true");
    map.put(USE_QUERY_CACHE, "true");
    map.put(CACHE_REGION_FACTORY, HibernateRegionFactory.class.getName());
    map.put(RELEASE_CONNECTIONS, "on_close");
    map.put(IGNITE_INSTANCE_NAME_PROPERTY, igniteInstanceName);
    map.put(DFLT_ACCESS_TYPE_PROPERTY, dfltAccessType);

    return map;
}
 

@ManagedOperation
@Description("change the shared cache mode if possible (value is ok)")
public void setSharedCacheMode(final String value) {
    try {
        final String v = value.trim().toUpperCase();
        final SharedCacheMode mode = v.isEmpty() ? SharedCacheMode.UNSPECIFIED : SharedCacheMode.valueOf(v);
        reloadableEntityManagerFactory.setSharedCacheMode(mode);
    } catch (final Exception iae) {
        // ignored
    }
}
 

public synchronized void setSharedCacheMode(final SharedCacheMode mode) {
    final PersistenceUnitInfoImpl info = entityManagerFactoryCallable.getUnitInfo();
    info.setSharedCacheMode(mode);

    final Properties properties = entityManagerFactoryCallable.getUnitInfo().getProperties();
    if (properties.containsKey(JAVAX_PERSISTENCE_SHARED_CACHE_MODE)) {
        properties.setProperty(JAVAX_PERSISTENCE_SHARED_CACHE_MODE, mode.name());
    }
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
    return SharedCacheMode.UNSPECIFIED;
}
 

public SharedCacheMode getSharedCacheMode() {
    return (sharedCacheMode == null) ? SharedCacheMode.UNSPECIFIED : sharedCacheMode;
}
 

public SharedCacheMode getSharedCacheMode()
{
    return delegate.getSharedCacheMode();
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
    return SharedCacheMode.UNSPECIFIED;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
    return SharedCacheMode.UNSPECIFIED;
}
 

/**
 * @param sharedCacheMode the sharedCacheMode to set
 */
public void setSharedCacheMode(final SharedCacheMode sharedCacheMode) {
    this.sharedCacheMode = (null != sharedCacheMode ? sharedCacheMode : SharedCacheMode.UNSPECIFIED);
}
 

public SharedCacheMode getSharedCacheMode() {
    return this.sharedCacheMode;
}
 

public void setSharedCacheMode(final SharedCacheMode sharedCacheMode) {
    this.sharedCacheMode = sharedCacheMode;
}
 

public PersistenceUnitInfoBuilder setSharedCacheMode(final SharedCacheMode sharedCacheMode) {
    this.sharedCacheMode = sharedCacheMode;
    return this;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
    return SharedCacheMode.UNSPECIFIED;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
	return null;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
    return SharedCacheMode.UNSPECIFIED;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
   return SharedCacheMode.NONE;
}
 

public PersistenceUnitInfo toInfo() {
    if (providerClass == null) {
        providerClass = ServiceLoader.load(PersistenceProvider.class).iterator().next().getClass().getName();
    }
    requireNonNull(dataSource, "datasource not provided");
    return new PersistenceUnitInfo() {
        @Override
        public String getPersistenceUnitName() {
            return unitName;
        }

        @Override
        public String getPersistenceProviderClassName() {
            return providerClass;
        }

        @Override
        public PersistenceUnitTransactionType getTransactionType() {
            return transactionType;
        }

        @Override
        public DataSource getJtaDataSource() {
            return jtaDataSource;
        }

        @Override
        public DataSource getNonJtaDataSource() {
            return dataSource;
        }

        @Override
        public List<String> getMappingFileNames() {
            return mappingFiles;
        }

        @Override
        public List<URL> getJarFileUrls() {
            return jarFiles;
        }

        @Override
        public URL getPersistenceUnitRootUrl() {
            return rootUrl;
        }

        @Override
        public List<String> getManagedClassNames() {
            return managedClasses;
        }

        @Override
        public boolean excludeUnlistedClasses() {
            return excludeUnlistedClasses;
        }

        @Override
        public SharedCacheMode getSharedCacheMode() {
            return sharedCacheMode;
        }

        @Override
        public ValidationMode getValidationMode() {
            return validationMode;
        }

        @Override
        public Properties getProperties() {
            return properties;
        }

        @Override
        public String getPersistenceXMLSchemaVersion() {
            return version;
        }

        @Override
        public ClassLoader getClassLoader() {
            return loader;
        }

        @Override
        public void addTransformer(final ClassTransformer transformer) {
            // no-op: not supported
        }

        @Override
        public ClassLoader getNewTempClassLoader() {
            return new URLClassLoader(new URL[0], Thread.currentThread().getContextClassLoader());
        }
    };
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
	return descriptor.getSharedCacheMode();
}
 

public SharedCacheMode getSharedCacheMode() {
    return sharedCacheMode;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
	return this.sharedCacheMode;
}
 

public void setSharedCacheMode(SharedCacheMode sharedCacheMode) {
	this.sharedCacheMode = sharedCacheMode;
}
 

/**
 * Parse the unit info DOM element.
 */
protected SpringPersistenceUnitInfo parsePersistenceUnitInfo(Element persistenceUnit, String version, URL rootUrl)
		throws IOException {

	SpringPersistenceUnitInfo unitInfo = new SpringPersistenceUnitInfo();

	// set JPA version (1.0 or 2.0)
	unitInfo.setPersistenceXMLSchemaVersion(version);

	// set persistence unit root URL
	unitInfo.setPersistenceUnitRootUrl(rootUrl);

	// set unit name
	unitInfo.setPersistenceUnitName(persistenceUnit.getAttribute(UNIT_NAME).trim());

	// set transaction type
	String txType = persistenceUnit.getAttribute(TRANSACTION_TYPE).trim();
	if (StringUtils.hasText(txType)) {
		unitInfo.setTransactionType(PersistenceUnitTransactionType.valueOf(txType));
	}

	// evaluate data sources
	String jtaDataSource = DomUtils.getChildElementValueByTagName(persistenceUnit, JTA_DATA_SOURCE);
	if (StringUtils.hasText(jtaDataSource)) {
		unitInfo.setJtaDataSource(this.dataSourceLookup.getDataSource(jtaDataSource.trim()));
	}

	String nonJtaDataSource = DomUtils.getChildElementValueByTagName(persistenceUnit, NON_JTA_DATA_SOURCE);
	if (StringUtils.hasText(nonJtaDataSource)) {
		unitInfo.setNonJtaDataSource(this.dataSourceLookup.getDataSource(nonJtaDataSource.trim()));
	}

	// provider
	String provider = DomUtils.getChildElementValueByTagName(persistenceUnit, PROVIDER);
	if (StringUtils.hasText(provider)) {
		unitInfo.setPersistenceProviderClassName(provider.trim());
	}

	// exclude unlisted classes
	Element excludeUnlistedClasses = DomUtils.getChildElementByTagName(persistenceUnit, EXCLUDE_UNLISTED_CLASSES);
	if (excludeUnlistedClasses != null) {
		String excludeText = DomUtils.getTextValue(excludeUnlistedClasses);
		unitInfo.setExcludeUnlistedClasses(!StringUtils.hasText(excludeText) || Boolean.valueOf(excludeText));
	}

	// set JPA 2.0 shared cache mode
	String cacheMode = DomUtils.getChildElementValueByTagName(persistenceUnit, SHARED_CACHE_MODE);
	if (StringUtils.hasText(cacheMode)) {
		unitInfo.setSharedCacheMode(SharedCacheMode.valueOf(cacheMode));
	}

	// set JPA 2.0 validation mode
	String validationMode = DomUtils.getChildElementValueByTagName(persistenceUnit, VALIDATION_MODE);
	if (StringUtils.hasText(validationMode)) {
		unitInfo.setValidationMode(ValidationMode.valueOf(validationMode));
	}

	parseProperties(persistenceUnit, unitInfo);
	parseManagedClasses(persistenceUnit, unitInfo);
	parseMappingFiles(persistenceUnit, unitInfo);
	parseJarFiles(persistenceUnit, unitInfo);

	return unitInfo;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
    return SharedCacheMode.UNSPECIFIED;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
    return SharedCacheMode.UNSPECIFIED;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
    return SharedCacheMode.UNSPECIFIED;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
    return SharedCacheMode.UNSPECIFIED;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
	return sharedCacheMode;
}
 

@Override
public MetadataBuilder applySharedCacheMode(SharedCacheMode sharedCacheMode) {
	this.options.sharedCacheMode = sharedCacheMode;
	return this;
}
 

@Override
public SharedCacheMode getSharedCacheMode() {
	return delegate.getSharedCacheMode();
}