Java Settings类代码示例

import org.hibernate.cfg.Settings; //导入依赖的package包/类
SessionBuilderImpl(SessionFactoryImpl sessionFactory) {
	this.sessionFactory = sessionFactory;
	this.sessionOwner = null;
	final Settings settings = sessionFactory.settings;

	// set up default builder values...
	this.interceptor = sessionFactory.getInterceptor();
	this.connectionReleaseMode = settings.getConnectionReleaseMode();
	this.autoClose = settings.isAutoCloseSessionEnabled();
	this.flushBeforeCompletion = settings.isFlushBeforeCompletionEnabled();

	if ( sessionFactory.getCurrentTenantIdentifierResolver() != null ) {
		tenantIdentifier = sessionFactory.getCurrentTenantIdentifierResolver().resolveCurrentTenantIdentifier();
	}

	listeners = settings.getBaselineSessionEventsListenerBuilder().buildBaselineList();
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
/**
 * Constructs a StandardQueryCache instance
 *
 * @param settings The SessionFactory settings.
 * @param props Any properties
 * @param updateTimestampsCache The update-timestamps cache to use.
 * @param regionName The base query cache region name
 */
public StandardQueryCache(
		final Settings settings,
		final Properties props,
		final UpdateTimestampsCache updateTimestampsCache,
		final String regionName) {
	String regionNameToUse = regionName;
	if ( regionNameToUse == null ) {
		regionNameToUse = StandardQueryCache.class.getName();
	}
	final String prefix = settings.getCacheRegionPrefix();
	if ( prefix != null ) {
		regionNameToUse = prefix + '.' + regionNameToUse;
	}
	LOG.startingQueryCache( regionNameToUse );

	this.cacheRegion = settings.getRegionFactory().buildQueryResultsRegion( regionNameToUse, props );
	this.updateTimestampsCache = updateTimestampsCache;
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
public StandardQueryCache(
		final Settings settings, 
		final Properties props, 
		final UpdateTimestampsCache updateTimestampsCache, 
		String regionName) throws HibernateException {
	if ( regionName == null ) {
		regionName = StandardQueryCache.class.getName();
	}
	String prefix = settings.getCacheRegionPrefix();
	if ( prefix != null ) {
		regionName = prefix + '.' + regionName;
	}
	log.info( "starting query cache at region: " + regionName );

	this.queryCache = settings.getCacheProvider().buildCache(regionName, props);
	this.updateTimestampsCache = updateTimestampsCache;
	this.regionName = regionName;
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
public HazelcastInstance getHazelcastInstance(Settings settings) {
    Object providerObject = null;
    try {
        Method getCacheProviderMethod = Settings.class.getMethod(METHOD_GET_CACHE_PROVIDER);
        providerObject = getCacheProviderMethod.invoke(settings);
    } catch (Exception e) {
        logger.log(Level.SEVERE, e.getMessage(), e);
        return null;
    }
    if (providerObject == null) {
        logger.log(Level.SEVERE, "Hibernate 2nd level cache has not been enabled!");
        return null;
    }
    final CacheProvider provider = (CacheProvider) providerObject;
    if (provider instanceof HazelcastCacheProvider) {
        return ((HazelcastCacheProvider) provider).getHazelcastInstance();
    }
    logger.log(Level.WARNING, "Current 2nd level cache implementation is not HazelcastCacheProvider!");
    return null;
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
public HazelcastInstance getHazelcastInstance(Settings settings) {
    final RegionFactory rf = settings.getRegionFactory();
    if (rf == null) {
        logger.log(Level.SEVERE, "Hibernate 2nd level cache has not been enabled!");
        return null;
    }
    if (rf instanceof RegionFactoryCacheProviderBridge) {
        final CacheProvider provider = ((RegionFactoryCacheProviderBridge) rf).getCacheProvider();
        if (provider instanceof HazelcastCacheProvider) {
            return ((HazelcastCacheProvider) provider).getHazelcastInstance();
        }
        logger.log(Level.WARNING, "Current 2nd level cache implementation is not HazelcastCacheProvider!");
    } else if (rf instanceof HazelcastCacheRegionFactory) {
        return ((HazelcastCacheRegionFactory) rf).getHazelcastInstance();
    } else {
        logger.log(Level.WARNING, "Current 2nd level cache implementation is not HazelcastCacheRegionFactory!");
    }
    return null;
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
SessionBuilderImpl(SessionFactoryImpl sessionFactory) {
	this.sessionFactory = sessionFactory;
	this.sessionOwner = null;
	final Settings settings = sessionFactory.settings;

	// set up default builder values...
	this.interceptor = sessionFactory.getInterceptor();
	this.connectionReleaseMode = settings.getConnectionReleaseMode();
	this.autoClose = settings.isAutoCloseSessionEnabled();
	this.flushBeforeCompletion = settings
			.isFlushBeforeCompletionEnabled();

	if (sessionFactory.getCurrentTenantIdentifierResolver() != null) {
		tenantIdentifier = sessionFactory
				.getCurrentTenantIdentifierResolver()
				.resolveCurrentTenantIdentifier();
	}
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
HibernateCacheTimestamper populateTimestamper(Settings settings, OverridableReadOnlyProperties properties) {
    String timestamperClazzName = properties.getProperty(TIMESTAMPER_PROPERTY_KEY,
            DEFAULT_TIMESTAMPER_CLASS.getName());

    HibernateCacheTimestamper timestamper;
    try {
        Class<?> clazz = Class.forName(timestamperClazzName);
        timestamper = (HibernateCacheTimestamper) clazz.newInstance();
    } catch (Exception e) {
        throw new IllegalStateException(e.getMessage(), e);
    }

    timestamper.setSettings(settings);
    timestamper.setProperties(properties);
    timestamper.setMemcachedAdapter(memcachedAdapter);
    timestamper.init();
    return timestamper;
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
public HazelcastInstance getHazelcastInstance(Settings settings) {
    final RegionFactory rf = settings.getRegionFactory();
    if (rf == null) {
        logger.log(Level.SEVERE, "Hibernate 2nd level cache has not been enabled!");
        return null;
    }
    if (rf instanceof RegionFactoryCacheProviderBridge) {
        final CacheProvider provider = ((RegionFactoryCacheProviderBridge) rf).getCacheProvider();
        if (provider instanceof HazelcastCacheProvider) {
            return ((HazelcastCacheProvider) provider).getHazelcastInstance();
        }
        logger.log(Level.WARNING, "Current 2nd level cache implementation is not HazelcastCacheProvider!");
    } else if (rf instanceof AbstractHazelcastCacheRegionFactory) {
        return ((AbstractHazelcastCacheRegionFactory) rf).getHazelcastInstance();
    } else {
        logger.log(Level.WARNING, "Current 2nd level cache implementation is not HazelcastCacheRegionFactory!");
    }
    return null;
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
@Override
public Settings buildSettings(Properties props, ServiceRegistry serviceRegistry) throws HibernateException {
	Settings settings = super.buildSettings(props, serviceRegistry);
	if (this.cacheRegionFactory != null) {
		try {
			Method setRegionFactory = Settings.class.getDeclaredMethod("setRegionFactory", RegionFactory.class);
			setRegionFactory.setAccessible(true);
			setRegionFactory.invoke(settings, this.cacheRegionFactory);
		}
		catch (Exception ex) {
			throw new IllegalStateException("Failed to invoke Hibernate's setRegionFactory method", ex);
		}
	}
	return settings;
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
/**
 * Constructs an UpdateTimestampsCache.
 *
 * @param settings The SessionFactory settings
 * @param props Any properties
 * @param factory The SessionFactory
 */
public UpdateTimestampsCache(Settings settings, Properties props, final SessionFactoryImplementor factory) {
	this.factory = factory;
	final String prefix = settings.getCacheRegionPrefix();
	final String regionName = prefix == null ? REGION_NAME : prefix + '.' + REGION_NAME;

	LOG.startingUpdateTimestampsCache( regionName );
	this.region = settings.getRegionFactory().buildTimestampsRegion( regionName, props );
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
@Override
public QueryCache getQueryCache(
		final String regionName,
		final UpdateTimestampsCache updateTimestampsCache,
		final Settings settings,
		final Properties props) throws HibernateException {
	return new StandardQueryCache(settings, props, updateTimestampsCache, regionName);
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
public void start(Settings settings, Properties properties) throws CacheException {
    // Do nothing the hazelcast hazelcastInstance is injected
    log.info("Starting up {}", getClass().getSimpleName());

    if (hazelcastInstance == null) {
        throw new IllegalArgumentException("Hazelcast hazelcastInstance must not be null");
    }
    cleanupService = new CleanupService(hazelcastInstance.getName());
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
public void start(final Settings settings, final Properties properties) throws CacheException {
    log.info("Starting up " + getClass().getSimpleName());
    if (instance == null || !instance.getLifecycleService().isRunning()) {
        instanceLoader = HazelcastInstanceFactory.createInstanceLoader(properties);
        instance = instanceLoader.loadInstance();
    }
    cleanupService = new CleanupService(instance.getName());
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
/**
 * Tries to extract <code>HazelcastInstance</code> from <code>SessionFactoryImplementor</code>.
 *
 * @param sessionFactory Hibernate <code>SessionFactory</code> to extract settings from
 * @return currently used <code>HazelcastInstance</code> or null if an error occurs.
 */
public static HazelcastInstance getHazelcastInstance(final SessionFactoryImplementor sessionFactory) {
    final Settings settings = sessionFactory.getSettings();
    final RegionFactory rf = settings.getRegionFactory();
    if (rf instanceof AbstractHazelcastCacheRegionFactory) {
        return ((AbstractHazelcastCacheRegionFactory) rf).getHazelcastInstance();
    } else {
        LOGGER.warning("Current 2nd level cache implementation is not HazelcastCacheRegionFactory!");
    }
    return null;
}
 

import org.hibernate.cfg.Settings; //导入依赖的package包/类
@Override
public void start(final Settings settings, final Properties properties) throws CacheException {
    logger.info("Starting up " + getClass().getSimpleName());
    if (instance == null || !instance.getLifecycleService().isRunning()) {
        instanceLoader = HazelcastInstanceFactory.createInstanceLoader(properties);
        instance = instanceLoader.loadInstance();
    }
    cleanupService = new CleanupService(instance.getName());
}