import org.springframework.cache.ehcache.EhCacheCache; //导入依赖的package包/类
@Override
public CacheStatistics getCacheStatistics(CacheManager cacheManager,
		EhCacheCache cache) {
	DefaultCacheStatistics statistics = new DefaultCacheStatistics();
	StatisticsGateway ehCacheStatistics = cache.getNativeCache().getStatistics();
	statistics.setSize(ehCacheStatistics.getSize());
	double hitRatio = cacheHitRatio(ehCacheStatistics);
	if (!Double.isNaN(hitRatio)) {
		// ratio is calculated 'racily' and can drift marginally above unity,
		// so we cap it here
		double sanitizedHitRatio = (hitRatio > 1 ? 1 : hitRatio);
		statistics.setHitRatio(sanitizedHitRatio);
		statistics.setMissRatio(1 - sanitizedHitRatio);
	}
	return statistics;
}
 

import org.springframework.cache.ehcache.EhCacheCache; //导入依赖的package包/类
@Override
public CacheStatistics getCacheStatistics(CacheManager cacheManager,
		EhCacheCache cache) {
	DefaultCacheStatistics statistics = new DefaultCacheStatistics();
	StatisticsGateway ehCacheStatistics = cache.getNativeCache().getStatistics();
	statistics.setSize(ehCacheStatistics.getSize());
	Double hitRatio = ehCacheStatistics.cacheHitRatio();
	if (!hitRatio.isNaN()) {
		// ratio is calculated 'racily' and can drift marginally above unity,
		// so we cap it here
		double sanitizedHitRatio = (hitRatio > 1 ? 1 : hitRatio);
		statistics.setHitRatio(sanitizedHitRatio);
		statistics.setMissRatio(1 - sanitizedHitRatio);
	}
	return statistics;
}
 

import org.springframework.cache.ehcache.EhCacheCache; //导入依赖的package包/类
@Override
protected Cache getMissingCache(final String name) {
    final Cache missingCache = super.getMissingCache(name);

    if (missingCache == null) {
        final CacheConfiguration cacheConfiguration = defaults.clone().name(name);

        final String cacheName = getCacheName(name);

        if (cacheExpires.containsKey(cacheName)) {
            cacheConfiguration.setTimeToLiveSeconds(cacheExpires.get(cacheName));
        }

        final net.sf.ehcache.Cache ehcache = new net.sf.ehcache.Cache(cacheConfiguration);
        ehcache.initialise();

        return new EhCacheCache(ehcache);
    } else {
        return missingCache;
    }
}
 

import org.springframework.cache.ehcache.EhCacheCache; //导入依赖的package包/类
@Bean
public CacheManager cacheManager() {
    SimpleCacheManager simpleCacheManager = new SimpleCacheManager();
    net.sf.ehcache.Cache aDefault1 = new net.sf.ehcache.Cache("default", 10000, true, false, 1000, 1000, false, 1000);
    aDefault1.initialise();
    EhCacheCache aDefault = new EhCacheCache(aDefault1);
    simpleCacheManager.setCaches(Arrays.asList(aDefault));
    return simpleCacheManager;
}
 

import org.springframework.cache.ehcache.EhCacheCache; //导入依赖的package包/类
private Long getTimeToLive() throws Exception {
        EhCacheCacheManager ehCacheManager = (EhCacheCacheManager) cacheManager;
        EhCacheCache cache = (EhCacheCache) ehCacheManager.getCache(GatewayConstants.VISITS_ON_BRANCH_CACHE);
        return cache.getNativeCache().getCacheConfiguration().getTimeToLiveSeconds();
}
 

import org.springframework.cache.ehcache.EhCacheCache; //导入依赖的package包/类
public CacheFactoryBean() {
    super(EhCacheCache.class);
}
 

import org.springframework.cache.ehcache.EhCacheCache; //导入依赖的package包/类
@Override
public EhCacheCache getObject() throws Exception {
    String name = this.config.getName();

    if (name == null) {
        this.config.setName((name = this.beanName));
    }

    if (this.searchable != null) {
        this.config.searchable(this.searchable);
    }

    if (this.hasMaxBytesLocalDisk()) {
        this.config.setMaxBytesLocalDisk(this.maxBytesLocalDisk);
    }

    if (this.hasMaxBytesLocalHeap()) {
        this.config.setMaxBytesLocalHeap(this.maxBytesLocalHeap);
    }

    if (this.hasMaxBytesLocalOffHeap()) {
        this.config.setMaxBytesLocalOffHeap(this.maxBytesLocalOffHeap);
    }

    if (this.hasPersistenceStrategy()) {
        this.config.addPersistence(new PersistenceConfiguration().strategy(persistenceStrategy));
    }

    if (this.hasSearchable()) {
        this.config.searchable(this.searchable);
    }

    Cache cache = new Cache(this.config);
    cache.setName(name);

    if (this.hasListeners()) {
        RegisteredEventListeners registeredListeners = cache.getCacheEventNotificationService();

        Stream.of(this.listeners).forEach(registeredListeners::registerListener);
    }

    cache.setCacheManager(this.cacheManager.getCacheManager());

    cache.initialise();

    return new EhCacheCache(cache);
}