Java 将Ehcache CacheManager（v3.x）转换为不带XML配置的Spring CacheManager

我正在尝试在我的应用程序中使用Ehcache管理器。我想在没有xml配置的情况下设置它。 我有下一个依赖项：

<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.6.0</version>
</dependency>
<dependency>
    <groupId>javax.cache</groupId>
    <artifactId>cache-api</artifactId>
    <version>1.0.0</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>5.1.1.RELEASE</version>
</dependency>

是否可以将Ehcache CacheManager转换为Spring CacheManager？

---

我认为应该是这样的：

returnnewjcachecachemanager（/*somecode*/）
您不能简单地将ehcache CacheManager转换为spring CacheManager

您可以使用
org.ehcache.jsr107.EhcacheCachingProvider
获取
javax.cache.CacheManager
，并将其交给
org.springframework.cache.JCacheCacheManager
，它是jcache（也称为jsr107）的
org.springframework.cache.CacheManager
的实现

import java.util.HashMap；
导入java.util.Map；
导入javax.cache.CacheManager；
导入javax.cache.Caching；
导入org.ehcache.config.CacheConfiguration；
导入org.ehcache.config.ResourcePools；
导入org.ehcache.config.builders.CacheConfigurationBuilder；
导入org.ehcache.config.builders.ResourcePoolsBuilder；
导入org.ehcache.config.units.EntryUnit；
导入org.ehcache.config.units.MemoryUnit；
导入org.ehcache.core.config.DefaultConfiguration；
导入org.ehcache.jsr107.EhcacheCachingProvider；
导入org.springframework.cache.annotation.EnableCaching；
导入org.springframework.cache.jcache.JCacheCacheManager；
导入org.springframework.context.annotation.Bean；
导入org.springframework.context.annotation.Configuration；
@配置
@启用缓存
公共类CacheConfig{
@豆子
公共JCacheCacheCacheManager JCacheCacheCacheManager（）{
jCacheMacheManager jCacheManager=新的jCacheMacheManager（cacheManager（））；
返回jCacheManager；
}
@Bean（destromethod=“close”）
公共缓存管理器缓存管理器（）{
ResourcePools ResourcePools=ResourcePoolsBuilder.newResourcePoolsBuilder（）
.heap（2000，EntryUnit.ENTRIES）
.offheap（100，MemoryUnit.MB）
.build（）；
CacheConfiguration CacheConfigurationBuilder=CacheConfigurationBuilder.newCacheConfigurationBuilder(
Object.class，
Object.class，
资源池）。
build（）；
映射您构建的缓存管理器根本没有使用JCache，因此您需要首先使用JCache，请参阅
@Bean
public org.springframework.cache.CacheManager cacheManager() {
    org.ehcache.CacheManager mainPageCache = CacheManagerBuilder
            .newCacheManagerBuilder()
            .withCache("mainPageCache", CacheConfigurationBuilder
                    .newCacheConfigurationBuilder(
                            Pageable.class,
                            Collection.class,
                            ResourcePoolsBuilder.heap(10))
                    .withExpiry(ExpiryPolicyBuilder
                            .timeToLiveExpiration(Duration
                                    .of(10, ChronoUnit.SECONDS))))
            .build(true);
    // ...
}

import java.util.HashMap;
import java.util.Map;

import javax.cache.CacheManager;
import javax.cache.Caching;

import org.ehcache.config.CacheConfiguration;
import org.ehcache.config.ResourcePools;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;
import org.ehcache.config.units.EntryUnit;
import org.ehcache.config.units.MemoryUnit;
import org.ehcache.core.config.DefaultConfiguration;
import org.ehcache.jsr107.EhcacheCachingProvider;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.jcache.JCacheCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class CacheConfig {


    @Bean
    public JCacheCacheManager jCacheCacheManager() {
        JCacheCacheManager jCacheManager = new JCacheCacheManager(cacheManager());
        return jCacheManager;
    }

    @Bean(destroyMethod = "close")
    public CacheManager cacheManager() {

        ResourcePools resourcePools = ResourcePoolsBuilder.newResourcePoolsBuilder()
                .heap(2000, EntryUnit.ENTRIES)
                .offheap(100, MemoryUnit.MB)
                .build();


        CacheConfiguration<Object,Object> cacheConfiguration = CacheConfigurationBuilder.newCacheConfigurationBuilder(
                Object.class,
                Object.class,
                resourcePools).
                build();

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

        EhcacheCachingProvider provider = (EhcacheCachingProvider) Caching.getCachingProvider("org.ehcache.jsr107.EhcacheCachingProvider");
        org.ehcache.config.Configuration configuration = new DefaultConfiguration(caches, provider.getDefaultClassLoader());

        return  provider.getCacheManager(provider.getDefaultURI(), (org.ehcache.config.Configuration) configuration);
    }

}