写一个ehcache3的配置类

### 回答1：
下面是一个示例的 Ehcache3 配置类：

import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;
import org.ehcache.config.units.MemoryUnit;
import org.ehcache.expiry.Duration;
import org.ehcache.expiry.Expirations;
import org.ehcache.jsr107.Eh107Configuration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.cache.JCacheManagerCustomizer;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

@Configuration
@EnableCaching
public class EhcacheConfig {

    @Autowired
    javax.cache.CacheManager cacheManager;

    @Bean
    public JCacheManagerCustomizer cacheManagerCustomizer() {
        return cm -> {
            // 创建一个名为 "myCache" 的缓存
            cm.createCache("myCache", Eh107Configuration.fromEhcacheCacheConfiguration(
                    CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class,
                            ResourcePoolsBuilder.heap(10))
                            // 设置缓存的过期时间为 1 小时
                            .withExpiry(Expirations.timeToLiveExpiration(Duration.of(1, TimeUnit.HOURS)))
                            .build()));
        };
    }
}

在这个示例中，我们定义了一个名为 "myCache" 的缓存，它的键和值都是字符串类型。我们还设置了缓存的过期时间为 1 小时。这个缓存使用了堆内存，并设置了最大缓存大小为 10。

注意：这个示例使用了 JCache (JSR-107) 规范，所以这个类还定义了一个 JCacheManagerCustomizer bean，用于将 Ehcache3 配置与 JCache 兼容。

### 回答2：
下面是一个示例的ehcache3配置类：

import org.ehcache.config.CacheConfiguration;
import org.ehcache.config.Configuration;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.CacheEventListenerConfigurationBuilder;
import org.ehcache.config.builders.ConfigurationBuilder;
import org.ehcache.event.EventType;
import org.ehcache.jsr107.Eh107Configuration;

import javax.cache.CacheManager;
import javax.cache.Caching;
import java.util.concurrent.TimeUnit;

public class EhcacheConfig {

    public static void main(String[] args) {
        CacheManager cacheManager = Caching.getCachingProvider().getCacheManager();
        Configuration configuration = createCacheConfiguration();
        cacheManager.createCache("exampleCache", configuration);
        
        javax.cache.Cache<String, String> cache = cacheManager.getCache("exampleCache");
        
        cache.put("key1", "value1");
        String value = cache.get("key1");
        System.out.println(value);
        
        cacheManager.close();
    }
    
    private static Configuration createCacheConfiguration() {
        CacheConfiguration<String, String> cacheConfiguration = CacheConfigurationBuilder.newCacheConfigurationBuilder(
                String.class, String.class, ResourcePoolsBuilder.heap(100))
                .withExpiry(Expirations.timeToLiveExpiration(Duration.of(30, TimeUnit.MINUTES))))
                .add(CacheEventListenerConfigurationBuilder
                        .newEventListenerConfiguration(new LoggingCacheEventListenerAdapter(), EventType.CREATED, EventType.EXPIRED)
                        .unordered().asynchronous())
                .build();
        
        return Eh107Configuration.fromEhcacheCacheConfiguration(cacheConfiguration);
    }
    
    // 自定义的CacheEventListener实现
    private static class LoggingCacheEventListenerAdapter implements CacheEventListener<String, String> {
        // 省略实现
    }
}

以上代码是一个简单的ehcache3配置类。首先，我们使用`Caching.getCachingProvider().getCacheManager()`方法获取缓存管理器。然后，使用`createCacheConfiguration()`方法创建一个缓存配置。在配置中，我们指定了缓存的键值类型为`String.class`，并设置了存储在缓存中的最大值为100条。我们还设置了缓存的过期时间为30分钟，并添加了一个自定义的缓存事件监听器。最后，我们通过`cacheManager.createCache()`方法来创建一个名为"exampleCache"的缓存，并通过`cacheManager.getCache()`方法获取到该缓存实例。我们可以使用缓存的`put()`方法来向缓存中放入键值对，使用`get()`方法来获取键对应的值。最后，我们调用`cacheManager.close()`方法来关闭缓存管理器。

这只是一个简单的ehcache3配置类示例，你可以根据自己的需求进行扩展和定制。

### 回答3：
在使用ehcache3进行缓存配置时，需要创建一个配置类用于定义缓存的规则和属性。下面是一个示例的ehcache3配置类：

import org.ehcache.config.Builder;
import org.ehcache.config.CacheConfiguration;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.CacheEventListenerConfigurationBuilder;
import org.ehcache.config.builders.CacheManagerBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;
import org.ehcache.expiry.Duration;
import org.ehcache.expiry.Expirations;
import org.ehcache.spi.loaderwriter.CacheLoaderWriter;
import org.ehcache.spi.loaderwriter.CacheLoaderWriterFactory;

import java.util.concurrent.TimeUnit;

public class EhcacheConfig {

    public static void main(String[] args) {
        // 创建缓存配置
        CacheConfiguration<String, String> cacheConfiguration = CacheConfigurationBuilder
                .newCacheConfigurationBuilder(String.class, String.class, ResourcePoolsBuilder.heap(100))
                .withExpiry(Expirations.timeToIdleExpiration(Duration.of(30, TimeUnit.MINUTES))) // 设置缓存过期时间
                .withLoaderWriter(new CacheLoaderWriterFactory<String, String>() { // 设置缓存加载和写入方式
                    @Override
                    public CacheLoaderWriter<? super String, String> createCacheLoaderWriter(String alias, org.ehcache.config.Configuration<?, ?> cacheConfiguration) {
                        return new MyCacheLoaderWriter(); // 自定义的CacheLoaderWriter实现类
                    }
                })
                .add(CacheEventListenerConfigurationBuilder
                        .newEventListenerConfiguration(new MyCacheEventListener(), EventType.CREATED, EventType.EXPIRED)
                        .unordered().asynchronous()) // 设置缓存事件监听器
                .build();

        // 创建缓存管理器
        org.ehcache.config.Configuration configuration = CacheManagerBuilder.newCacheManagerBuilder()
                .withCache("myCache", cacheConfiguration) // 设置缓存名称和配置
                .build();

        // 初始化缓存管理器
        org.ehcache.CacheManager cacheManager = CacheManagerBuilder.newCacheManager(configuration);
        cacheManager.init();

        // 获取缓存
        org.ehcache.Cache<String, String> cache = cacheManager.getCache("myCache", String.class, String.class);

        // 添加数据到缓存
        cache.put("key1", "value1");

        // 从缓存中获取数据
        String value = cache.get("key1");

        // 打印缓存数据
        System.out.println(value);

        // 关闭缓存管理器
        cacheManager.close();
    }

    // 自定义CacheLoaderWriter实现类
    static class MyCacheLoaderWriter implements CacheLoaderWriter<String, String> {
        @Override
        public String load(String key) throws Exception {
            // 从数据源加载数据
            return getDataFromDataSource(key);
        }

        @Override
        public void write(String key, String value) throws Exception {
            // 写入数据到数据源
        }

        @Override
        public void delete(String key) throws Exception {
            // 从数据源删除数据
        }

        // 模拟从数据源获取数据的方法
        private String getDataFromDataSource(String key) {
            return "value from data source";
        }
    }

    // 自定义缓存事件监听器
    static class MyCacheEventListener implements CacheEventListener<String, String> {
        @Override
        public void onEvent(CacheEvent<? extends String, ? extends String> cacheEvent) {
            System.out.println("Cache Event: " + cacheEvent.getType() + ", Key: " + cacheEvent.getKey() + ", Old Value: " + cacheEvent.getOldValue() + ", New Value: " + cacheEvent.getNewValue());
        }
    }
}

以上代码演示了如何创建一个ehcache3的配置类，包含了缓存的基本配置和使用方式。需要注意的是，根据具体需求可能需要调整缓存的过期时间、缓存加载和写入方式、缓存事件监听器等等。