import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
@Before
public void before() throws Exception {
  CachingProvider cachingProvider = Caching.getCachingProvider();
  EhcacheCachingProvider ehcacheProvider = (EhcacheCachingProvider) cachingProvider;

  DefaultConfiguration configuration = new DefaultConfiguration(ehcacheProvider.getDefaultClassLoader(),
    new DefaultPersistenceConfiguration(diskPath.newFolder()));

  CacheConfiguration<Integer, String> cacheConfiguration =
    CacheConfigurationBuilder.newCacheConfigurationBuilder(Integer.class, String.class, resources).build();
  configuration.addCacheConfiguration("cache", cacheConfiguration);

  cacheManager = ehcacheProvider.getCacheManager(ehcacheProvider.getDefaultURI(), configuration);

  EhcacheManager ehcacheManager = cacheManager.unwrap(EhcacheManager.class);
  Field field = EhcacheManager.class.getDeclaredField("serviceLocator");
  field.setAccessible(true);
  @SuppressWarnings("unchecked")
  ServiceProvider<Service> serviceProvider = (ServiceProvider<Service>)field.get(ehcacheManager);
  StatisticsService statisticsService = serviceProvider.getService(StatisticsService.class);

  cache = cacheManager.getCache("cache", Integer.class, String.class);

  cacheStatistics = statisticsService.getCacheStatistics("cache");
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
@Bean
@Primary
public CacheManager ehCacheManager(JiraSyncConfig jiraSyncConfig) throws Exception {
	CachingProvider cachingProvider = Caching.getCachingProvider();
	EhcacheCachingProvider ehcacheCachingProvider = (EhcacheCachingProvider) cachingProvider;
	CacheConfig cacheConfig = jiraSyncConfig.getCache();
	CacheManager cacheManager = getCacheManager(ehcacheCachingProvider, cacheConfig);
	boolean persistentCache = cacheConfig.isPersistent();
	createCache(cacheManager, CACHE_NAME_PROJECTS, ONE_HOUR, persistentCache);
	createCache(cacheManager, CACHE_NAME_PRIORITIES, ONE_HOUR, persistentCache);
	createCache(cacheManager, CACHE_NAME_RESOLUTIONS, ONE_HOUR, persistentCache);
	createCache(cacheManager, CACHE_NAME_VERSIONS, ONE_HOUR, persistentCache);
	createCache(cacheManager, CACHE_NAME_FIELDS, ONE_HOUR, persistentCache);
	createCache(cacheManager, CACHE_NAME_REMOTE_LINKS, ONE_HOUR, persistentCache);
	createCache(cacheManager, CACHE_NAME_USERS, ONE_HOUR, persistentCache);
	createCache(cacheManager, CACHE_NAME_FIELD_ALLOWED_VALUES, ONE_HOUR, persistentCache);
	createCache(cacheManager, CACHE_NAME_MYSELF, ONE_HOUR, false);
	createCache(cacheManager, CACHE_NAME_SERVER_INFO, THIRTY_SECONDS, false);
	return cacheManager;
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
@Bean
public CacheManager cacheManager(@Autowired Config config) {
    long ttl = Long.valueOf(config.getProperties().getProperty(Config.PROP_CACHE_TTL));

    double pctOfHeap = Double.valueOf(config.getProperties().getProperty(Config.PROP_CACHE_SIZE));
    long cacheSizeMB = new Double(Runtime.getRuntime().maxMemory() * pctOfHeap / 1048576.0).longValue();

    LogFactory.getLog(getClass()).info(
            String.format("Initializing cache TTL=%d secs, size=%d MB (%.2f percent of max heap)",
                    ttl, cacheSizeMB, pctOfHeap * 100));

    org.ehcache.config.CacheConfiguration<Object, Object> cacheConfiguration = CacheConfigurationBuilder
            .newCacheConfigurationBuilder(Object.class, Object.class,
                    ResourcePoolsBuilder.newResourcePoolsBuilder()
                            .heap(cacheSizeMB, MemoryUnit.MB))
            .withExpiry(Expirations.timeToLiveExpiration(new org.ehcache.expiry.Duration(ttl, TimeUnit.SECONDS)))
            .build();

    Map<String, CacheConfiguration<?, ?>> caches = new HashMap<>();
    caches.put(CACHE_DEFAULT, cacheConfiguration);

    EhcacheCachingProvider provider = (EhcacheCachingProvider) javax.cache.Caching.getCachingProvider();

    // when our cacheManager bean is re-created several times for
    // diff test configurations, this provider seems to hang on to state
    // causing cache settings to not be right. so we always close().
    provider.close();

    DefaultConfiguration configuration = new DefaultConfiguration(
            caches, provider.getDefaultClassLoader());

    return new JCacheCacheManager(
            provider.getCacheManager(provider.getDefaultURI(), configuration));
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
private CacheManager createInMemoryCacheManager() {
    long cacheSize = properties.getCache().getEhcache().getSize();
    long ttl = properties.getCache().getEhcache().getTimeToLiveSeconds();

    org.ehcache.config.CacheConfiguration<Object, Object> cacheConfiguration = CacheConfigurationBuilder
        .newCacheConfigurationBuilder(Object.class, Object.class, ResourcePoolsBuilder
            .newResourcePoolsBuilder()
            .heap(cacheSize))
        .withExpiry(Expirations.timeToLiveExpiration(new org.ehcache.expiry.Duration(ttl, TimeUnit.SECONDS)))
        .build();

    Map<String, org.ehcache.config.CacheConfiguration<?, ?>> caches = createCacheConfigurations(cacheConfiguration);

    EhcacheCachingProvider provider = getCachingProvider();
    DefaultConfiguration configuration = new DefaultConfiguration(caches, provider.getDefaultClassLoader());
    return provider.getCacheManager(provider.getDefaultURI(), configuration);
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
private DefaultConfiguration getCacheConfiguration(EhcacheCachingProvider cachingProvider, CacheConfig cacheConfig) {
	if (cacheConfig.isPersistent()) {
		Path cacheDirectory = Paths.get(cacheConfig.getDirectory());
		log.info("setting up persistent cache in {}", cacheDirectory.toAbsolutePath());
		DefaultPersistenceConfiguration persistenceConfiguration = new DefaultPersistenceConfiguration(cacheDirectory.toFile());
		return new DefaultConfiguration(cachingProvider.getDefaultClassLoader(), persistenceConfiguration);
	} else {
		log.info("setting up in-memory cache");
		return new DefaultConfiguration(cachingProvider.getDefaultClassLoader());
	}
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
@Test
public void ehcache3AsJCacheWithCaches() {
	String cachingProviderFqn = EhcacheCachingProvider.class.getName();
	load(DefaultCacheConfiguration.class, "spring.cache.type=jcache",
			"spring.cache.jcache.provider=" + cachingProviderFqn,
			"spring.cache.cacheNames[0]=foo", "spring.cache.cacheNames[1]=bar");
	JCacheCacheManager cacheManager = validateCacheManager(JCacheCacheManager.class);
	assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
@Test
public void ehcache3AsJCacheWithConfig() throws IOException {
	String cachingProviderFqn = EhcacheCachingProvider.class.getName();
	String configLocation = "ehcache3.xml";
	load(DefaultCacheConfiguration.class, "spring.cache.type=jcache",
			"spring.cache.jcache.provider=" + cachingProviderFqn,
			"spring.cache.jcache.config=" + configLocation);
	JCacheCacheManager cacheManager = validateCacheManager(JCacheCacheManager.class);

	Resource configResource = new ClassPathResource(configLocation);
	assertThat(cacheManager.getCacheManager().getURI())
			.isEqualTo(configResource.getURI());
	assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
private CacheManager createClusteredCacheManager() {
    JHipsterProperties.Cache.Ehcache.Cluster clusterProperties = properties.getCache().getEhcache().getCluster();
    URI clusterUri = clusterProperties.getUri();
    boolean autoCreate = clusterProperties.isAutoCreate();
    long clusteredCacheSize = clusterProperties.getSizeInMb();
    Consistency consistency = clusterProperties.getConsistency();

    long heapCacheSize = properties.getCache().getEhcache().getSize();
    long ttl = properties.getCache().getEhcache().getTimeToLiveSeconds();

    ClusteringServiceConfigurationBuilder clusteringServiceConfigurationBuilder = ClusteringServiceConfigurationBuilder.cluster(clusterUri);
    ServerSideConfigurationBuilder serverSideConfigurationBuilder = (autoCreate ? clusteringServiceConfigurationBuilder.autoCreate() : clusteringServiceConfigurationBuilder.expecting())
        .defaultServerResource("primary-server-resource");

    org.ehcache.config.CacheConfiguration<Object, Object> cacheConfiguration = CacheConfigurationBuilder
        .newCacheConfigurationBuilder(Object.class, Object.class, ResourcePoolsBuilder
            .newResourcePoolsBuilder()
            .heap(heapCacheSize)
            .with(ClusteredResourcePoolBuilder.clusteredDedicated(clusteredCacheSize, MemoryUnit.MB)))
        .withExpiry(Expirations.timeToLiveExpiration(new org.ehcache.expiry.Duration(ttl, TimeUnit.SECONDS)))
        .add(new ClusteredStoreConfiguration(consistency)).build();

    Map<String, org.ehcache.config.CacheConfiguration<?, ?>> caches = createCacheConfigurations(cacheConfiguration);

    EhcacheCachingProvider provider = getCachingProvider();
    DefaultConfiguration configuration = new DefaultConfiguration(caches, provider.getDefaultClassLoader(), serverSideConfigurationBuilder.build());
    return provider.getCacheManager(provider.getDefaultURI(), configuration);
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
private CacheManager create(@Nullable final URI config) {
  CachingProvider provider = Caching.getCachingProvider(
      EhcacheCachingProvider.class.getName(),
      EhcacheCachingProvider.class.getClassLoader()
  );

  log.info("Creating cache-manager with configuration: {}", config);
  CacheManager manager = provider.getCacheManager(config, getClass().getClassLoader());
  log.debug("Created cache-manager: {}", manager);
  return manager;
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
@Test
public void testCacheManagerLevelConfiguration() throws Exception {
  // tag::ehcacheCacheManagerConfigurationExample[]
  CachingProvider cachingProvider = Caching.getCachingProvider();
  EhcacheCachingProvider ehcacheProvider = (EhcacheCachingProvider) cachingProvider; // <1>

  DefaultConfiguration configuration = new DefaultConfiguration(ehcacheProvider.getDefaultClassLoader(),
    new DefaultPersistenceConfiguration(getPersistenceDirectory())); // <2>

  CacheManager cacheManager = ehcacheProvider.getCacheManager(ehcacheProvider.getDefaultURI(), configuration); // <3>
  // end::ehcacheCacheManagerConfigurationExample[]

  assertThat(cacheManager, notNullValue());
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
private static Stream<CachingProvider> cachingProviders() {
    return Stream.of(
        new RICachingProvider(),
        new EhcacheCachingProvider()
    );
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
private CacheManager getCacheManager(EhcacheCachingProvider cachingProvider, CacheConfig cacheConfig) {
	URI uri = cachingProvider.getDefaultURI();
	DefaultConfiguration configuration = getCacheConfiguration(cachingProvider, cacheConfig);
	return cachingProvider.getCacheManager(uri, configuration);
}
 

import org.ehcache.jsr107.EhcacheCachingProvider; //导入依赖的package包/类
private EhcacheCachingProvider getCachingProvider() {
    return (EhcacheCachingProvider) Caching.getCachingProvider();
}