ehcache 使用说明

小灰灰 2022-10-21 11:48 174阅读 0赞

--------------------

### ehcache 使用说明 ###

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**导入 jar 包**

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-cache</artifactId>
            </dependency>
            <dependency>
                <groupId>org.ehcache</groupId>
                <artifactId>ehcache</artifactId>
                <version>3.9.3</version>
            </dependency>
            <dependency>
                <groupId>javax.cache</groupId>
                <artifactId>cache-api</artifactId>
                <version>1.1.1</version>
            </dependency>

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**缓存开启注解及其导入类**

**@EnableCaching：开启缓存**

@Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import({CachingConfigurationSelector.class})       //导入缓存配置选择器，将选择的类注册为容器的bean
    public @interface EnableCaching {
        boolean proxyTargetClass() default false;
    
        AdviceMode mode() default AdviceMode.PROXY;     //默认代理模式：AdviceMode.PROXY
    
        int order() default 2147483647;
    }

**CachingConfigurationSelector**

public class CachingConfigurationSelector extends AdviceModeImportSelector<EnableCaching> {
        private static final String PROXY_JCACHE_CONFIGURATION_CLASS = "org.springframework.cache.jcache.config.ProxyJCacheConfiguration";
        private static final String CACHE_ASPECT_CONFIGURATION_CLASS_NAME = "org.springframework.cache.aspectj.AspectJCachingConfiguration";
        private static final String JCACHE_ASPECT_CONFIGURATION_CLASS_NAME = "org.springframework.cache.aspectj.AspectJJCacheConfiguration";
        private static final boolean jsr107Present;
        private static final boolean jcacheImplPresent;
    
        public CachingConfigurationSelector() {
        }
    
        public String[] selectImports(AdviceMode adviceMode) {
            switch(adviceMode) {
            case PROXY:                              //默认代理方式
                return this.getProxyImports();       //将返回结果注册为容器的bean
            case ASPECTJ:
                return this.getAspectJImports();
            default:
                return null;
            }
        }
    
        private String[] getProxyImports() {
            List<String> result = new ArrayList(3);
            result.add(AutoProxyRegistrar.class.getName());         //注入AutoProxyRegistrar的对象实例
            result.add(ProxyCachingConfiguration.class.getName());  //注入ProxyCachingConfiguration的对象实例
            if (jsr107Present && jcacheImplPresent) {               //默认是false，不注入
                result.add("org.springframework.cache.jcache.config.ProxyJCacheConfiguration");
            }
    
            return StringUtils.toStringArray(result);
        }
    
        private String[] getAspectJImports() {
            List<String> result = new ArrayList(2);
            result.add("org.springframework.cache.aspectj.AspectJCachingConfiguration");
            if (jsr107Present && jcacheImplPresent) {
                result.add("org.springframework.cache.aspectj.AspectJJCacheConfiguration");
            }
    
            return StringUtils.toStringArray(result);
        }
    
        static {
            ClassLoader classLoader = CachingConfigurationSelector.class.getClassLoader();
            jsr107Present = ClassUtils.isPresent("javax.cache.Cache", classLoader);
            jcacheImplPresent = ClassUtils.isPresent("org.springframework.cache.jcache.config.ProxyJCacheConfiguration", classLoader);
        }
    }

**AutoProxyRegistrar：为注解标注的类创建代理对象**

public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
        private final Log logger = LogFactory.getLog(this.getClass());
    
        public AutoProxyRegistrar() {
        }
    
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            boolean candidateFound = false;
            Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
            Iterator var5 = annTypes.iterator();
    
            while(var5.hasNext()) {
                String annType = (String)var5.next();
                AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
                if (candidate != null) {
                    Object mode = candidate.get("mode");
                    Object proxyTargetClass = candidate.get("proxyTargetClass");
                    if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() && Boolean.class == proxyTargetClass.getClass()) {
                        candidateFound = true;
                        if (mode == AdviceMode.PROXY) {
                            AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                            if ((Boolean)proxyTargetClass) {
                                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                                return;
                            }
                        }
                    }
                }
            }
    
            if (!candidateFound && this.logger.isInfoEnabled()) {
                String name = this.getClass().getSimpleName();
                this.logger.info(String.format("%s was imported but no annotations were found having both 'mode' and 'proxyTargetClass' attributes of type AdviceMode and boolean respectively. This means that auto proxy creator registration and configuration may not have occurred as intended, and components may not be proxied as expected. Check to ensure that %s has been @Import'ed on the same class where these annotations are declared; otherwise remove the import of %s altogether.", name, name, name));
            }
    
        }
    }

**ProxyCachingConfiguration**

@Configuration(
        proxyBeanMethods = false
    )
    @Role(2)
    public class ProxyCachingConfiguration extends AbstractCachingConfiguration {
        public ProxyCachingConfiguration() {
        }
    
        @Bean(
            name = {"org.springframework.cache.config.internalCacheAdvisor"}
        )
        @Role(2)
        public BeanFactoryCacheOperationSourceAdvisor cacheAdvisor(CacheOperationSource cacheOperationSource, CacheInterceptor cacheInterceptor) {
            BeanFactoryCacheOperationSourceAdvisor advisor = new BeanFactoryCacheOperationSourceAdvisor();
            advisor.setCacheOperationSource(cacheOperationSource);
            advisor.setAdvice(cacheInterceptor);
            if (this.enableCaching != null) {
                advisor.setOrder((Integer)this.enableCaching.getNumber("order"));
            }
    
            return advisor;
        }
    
        @Bean
        @Role(2)
        public CacheOperationSource cacheOperationSource() {
            return new AnnotationCacheOperationSource();
        }
    
        @Bean
        @Role(2)
        public CacheInterceptor cacheInterceptor(CacheOperationSource cacheOperationSource) {
            CacheInterceptor interceptor = new CacheInterceptor();  //缓存拦截器
            interceptor.configure(this.errorHandler, this.keyGenerator, this.cacheResolver, this.cacheManager);
                                                                    //配置errorHandler、key生成器、缓存解析器、缓存管理器
            interceptor.setCacheOperationSource(cacheOperationSource);
            return interceptor;
        }
    }

**AbstractCachingConfiguration**

@Configuration(
        proxyBeanMethods = false
    )
    public abstract class AbstractCachingConfiguration implements ImportAware {
        @Nullable
        protected AnnotationAttributes enableCaching;
        @Nullable
        protected Supplier<CacheManager> cacheManager;
        @Nullable
        protected Supplier<CacheResolver> cacheResolver;
        @Nullable
        protected Supplier<KeyGenerator> keyGenerator;
        @Nullable
        protected Supplier<CacheErrorHandler> errorHandler;
    
        public AbstractCachingConfiguration() {
        }
    
        public void setImportMetadata(AnnotationMetadata importMetadata) {
            this.enableCaching = AnnotationAttributes.fromMap(importMetadata.getAnnotationAttributes(EnableCaching.class.getName(), false));
            if (this.enableCaching == null) {
                throw new IllegalArgumentException("@EnableCaching is not present on importing class " + importMetadata.getClassName());
            }
        }
    
        @Autowired(
            required = false
        )
        void setConfigurers(Collection<CachingConfigurer> configurers) {
            if (!CollectionUtils.isEmpty(configurers)) {
                if (configurers.size() > 1) {
                    throw new IllegalStateException(configurers.size() + " implementations of CachingConfigurer were found when only 1 was expected. Refactor the configuration such that CachingConfigurer is implemented only once or not at all.");
                } else {
                    CachingConfigurer configurer = (CachingConfigurer)configurers.iterator().next();
                    this.useCachingConfigurer(configurer);
                }
            }
        }
    
        protected void useCachingConfigurer(CachingConfigurer config) {
            this.cacheManager = config::cacheManager;
            this.cacheResolver = config::cacheResolver;
            this.keyGenerator = config::keyGenerator;
            this.errorHandler = config::errorHandler;
        }
    }

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**相关类与接口**

**CacheManagerBuilder：构造缓存管理器**

public class CacheManagerBuilder<T extends CacheManager> implements Builder<T> {
        private final FluentConfigurationBuilder<?> configBuilder;
        private final Set<Service> services;
    
        public T build(boolean init) {
            T cacheManager = this.newCacheManager(this.services, (Configuration)this.configBuilder.build());
            if (init) {
                cacheManager.init();
            }
    
            return cacheManager;
        }
    
        public T build() {
            return this.build(false);
        }
    
        private CacheManagerBuilder() {
        private CacheManagerBuilder(CacheManagerBuilder<T> builder, Set<Service> services) {
        private CacheManagerBuilder(CacheManagerBuilder<T> builder, FluentConfigurationBuilder<?> configBuilder) {
    
        T newCacheManager(Collection<Service> services, Configuration configuration) {
        T cast(EhcacheManager ehcacheManager) {
    
    
    ************
    创建缓存管理器
    
        public static CacheManager newCacheManager(Configuration configuration) {
            return new EhcacheManager(configuration);
        }
    
    
    ************
    添加缓存配置
    
        public <K, V> CacheManagerBuilder<T> withCache(String alias, CacheConfiguration<K, V> configuration) {
            return new CacheManagerBuilder(this, this.configBuilder.withCache(alias, configuration));
        }
    
        public <K, V> CacheManagerBuilder<T> withCache(String alias, Builder<? extends CacheConfiguration<K, V>> configurationBuilder) {
            return this.withCache(alias, (CacheConfiguration)configurationBuilder.build());
        }
    
        public <N extends T> CacheManagerBuilder<N> with(CacheManagerConfiguration<N> cfg) {
        public <N extends T> CacheManagerBuilder<N> with(Builder<? extends CacheManagerConfiguration<N>> cfgBuilder) {
    
    
    
    ************
    copier、serializer
    
        public <C> CacheManagerBuilder<T> withCopier(Class<C> clazz, Class<? extends Copier<C>> copier) {
                                         //on-heap存储value值时使用，默认存储对象
    
        public <C> CacheManagerBuilder<T> withSerializer(Class<C> clazz, Class<? extends Serializer<C>> serializer) {
                                         //off-heap、disk、clustered使用
    
    ************
    设置磁盘存储路径
    
        public static CacheManagerConfiguration<PersistentCacheManager> persistence(String rootDirectory) {
        public static CacheManagerConfiguration<PersistentCacheManager> persistence(File rootDirectory) {
    
    
    ************
    其他方法
    
        public CacheManagerBuilder<T> using(Service service) {
        public CacheManagerBuilder<T> using(ServiceCreationConfiguration<?, ?> serviceConfiguration) {
    
    
        public CacheManagerBuilder<T> withDefaultSizeOfMaxObjectGraph(long size) {
        public CacheManagerBuilder<T> withDefaultSizeOfMaxObjectSize(long size, MemoryUnit unit) {
    
        public CacheManagerBuilder<T> withDefaultWriteBehindThreadPool(String threadPoolAlias) {
        public CacheManagerBuilder<T> withDefaultDiskStoreThreadPool(String threadPoolAlias) {
        public CacheManagerBuilder<T> withDefaultEventListenersThreadPool(String threadPoolAlias) {
    
        public CacheManagerBuilder<T> withClassLoader(ClassLoader classLoader) {
        private <R, C extends ServiceCreationConfiguration<?, R>> CacheManagerBuilder<T> ensureThenUpdate(Supplier<C> supplier, UnaryOperator<R> update) {
        public static CacheManagerBuilder<CacheManager> newCacheManagerBuilder() {

**CacheManager：缓存管理器（实现类EhCacheManager）**

public interface CacheManager extends Closeable {
    
        <K, V> Cache<K, V> createCache(String var1, CacheConfiguration<K, V> var2);
        <K, V> Cache<K, V> createCache(String var1, Builder<? extends CacheConfiguration<K, V>> var2);
    
        <K, V> Cache<K, V> getCache(String var1, Class<K> var2, Class<V> var3);
    
        void removeCache(String var1);
    
        void init() throws StateTransitionException;
        void close() throws StateTransitionException;
    
        Status getStatus();
        Configuration getRuntimeConfiguration();
    }

**CacheConfiguration：缓存配置接口**

public interface CacheConfiguration<K, V> {
        Collection<ServiceConfiguration<?, ?>> getServiceConfigurations();
    
        Class<K> getKeyType();
        Class<V> getValueType();
    
        EvictionAdvisor<? super K, ? super V> getEvictionAdvisor();
    
        ClassLoader getClassLoader();
    
        ExpiryPolicy<? super K, ? super V> getExpiryPolicy();
    
        ResourcePools getResourcePools();
    
        default FluentCacheConfigurationBuilder<K, V, ?> derive() throws UnsupportedOperationException {
            throw new UnsupportedOperationException();
        }
    }

**CacheConfigurationBuilder：缓存配置构造类**

public class CacheConfigurationBuilder<K, V> implements FluentCacheConfigurationBuilder<K, V, CacheConfigurationBuilder<K, V>> {
        private final Collection<ServiceConfiguration<?, ?>> serviceConfigurations = new HashSet();
        private ExpiryPolicy<? super K, ? super V> expiry;              //缓存过期
        private ClassLoader classLoader = null;
        private EvictionAdvisor<? super K, ? super V> evictionAdvisor;  //缓存清除
        private ResourcePools resourcePools;                            //存储空间设置
        private final Class<K> keyType;                                 //on-heap存储的key类型
        private final Class<V> valueType;                               //on-heap存储的value类型
    
    
    **************
    获取CacheConfigurationBuilder
    
        public static <K, V> CacheConfigurationBuilder<K, V> newCacheConfigurationBuilder(Class<K> keyType, Class<V> valueType, ResourcePools resourcePools) {
        public static <K, V> CacheConfigurationBuilder<K, V> newCacheConfigurationBuilder(Class<K> keyType, Class<V> valueType, Builder<? extends ResourcePools> resourcePoolsBuilder) {
        public static <K, V> CacheConfigurationBuilder<K, V> newCacheConfigurationBuilder(CacheConfiguration<K, V> configuration) {
    
        private CacheConfigurationBuilder(Class<K> keyType, Class<V> valueType, ResourcePools resourcePools) {
        private CacheConfigurationBuilder(CacheConfigurationBuilder<K, V> other) {
    
    
    **************
    存储空间设置
    
        public CacheConfigurationBuilder<K, V> withResourcePools(ResourcePools resourcePools) {
        public CacheConfigurationBuilder<K, V> updateResourcePools(UnaryOperator<ResourcePools> update) {
    
    
    **************
    过期策略设置
    
        public CacheConfigurationBuilder<K, V> withExpiry(ExpiryPolicy<? super K, ? super V> expiry) {
    
        public boolean hasConfiguredExpiry() {
    
    
        public CacheConfigurationBuilder<K, V> withEvictionAdvisor(EvictionAdvisor<? super K, ? super V> evictionAdvisor) {
                                               //自定义缓存清除方法
    
    
    **************
    copier、serializer设置
    
        public CacheConfigurationBuilder<K, V> withKeySerializingCopier() {
        public CacheConfigurationBuilder<K, V> withValueSerializingCopier() {
    
        public CacheConfigurationBuilder<K, V> withKeyCopier(Copier<K> keyCopier) {
        public CacheConfigurationBuilder<K, V> withKeyCopier(Class<? extends Copier<K>> keyCopierClass) {
    
        public CacheConfigurationBuilder<K, V> withValueCopier(Copier<V> valueCopier) {
        public CacheConfigurationBuilder<K, V> withValueCopier(Class<? extends Copier<V>> valueCopierClass) {
    
        public CacheConfigurationBuilder<K, V> withoutKeyCopier() {
        public CacheConfigurationBuilder<K, V> withoutValueCopier() {
    
    
        public CacheConfigurationBuilder<K, V> withKeySerializer(Serializer<K> keySerializer) {
        public CacheConfigurationBuilder<K, V> withKeySerializer(Class<? extends Serializer<K>> keySerializerClass) {
        public CacheConfigurationBuilder<K, V> withDefaultKeySerializer() {
    
        public CacheConfigurationBuilder<K, V> withValueSerializer(Serializer<V> valueSerializer) {
        public CacheConfigurationBuilder<K, V> withValueSerializer(Class<? extends Serializer<V>> valueSerializerClass) {
        public CacheConfigurationBuilder<K, V> withDefaultValueSerializer() {
    
    
    **************
    其他方法
    
        public CacheConfigurationBuilder<K, V> withClassLoader(ClassLoader classLoader) {
        public CacheConfigurationBuilder<K, V> withDefaultClassLoader() {
    
    
        public CacheConfigurationBuilder<K, V> withLoaderWriter(CacheLoaderWriter<K, V> loaderWriter) {
        public CacheConfigurationBuilder<K, V> withLoaderWriter(Class<CacheLoaderWriter<K, V>> loaderWriterClass, Object... arguments) {
        public CacheConfigurationBuilder<K, V> withoutLoaderWriter() {
    
    
        public CacheConfigurationBuilder<K, V> withResilienceStrategy(ResilienceStrategy<K, V> resilienceStrategy) {
        public CacheConfigurationBuilder<K, V> withResilienceStrategy(Class<? extends ResilienceStrategy> resilienceStrategyClass, Object... arguments) {
        public CacheConfigurationBuilder<K, V> withDefaultResilienceStrategy() {
    
    
        public <C extends ServiceConfiguration<?, ?>> Collection<C> getServices(Class<C> configurationType) throws IllegalArgumentException {
        public CacheConfigurationBuilder<K, V> withService(ServiceConfiguration<?, ?> config) {
        public CacheConfigurationBuilder<K, V> withoutServices(Class<? extends ServiceConfiguration<?, ?>> clazz) {
        public <C extends ServiceConfiguration<?, ?>> CacheConfigurationBuilder<K, V> withoutServices(Class<C> clazz, Predicate<? super C> predicate) {
    
    
        public <R, C extends ServiceConfiguration<?, R>> CacheConfigurationBuilder<K, V> updateServices(Class<C> clazz, UnaryOperator<R> update) {
    
    
        public CacheConfigurationBuilder<K, V> withDispatcherConcurrency(int dispatcherConcurrency) {
        public CacheConfigurationBuilder<K, V> withDefaultDispatcherConcurrency() {
    
    
        public CacheConfigurationBuilder<K, V> withEventListenersThreadPool(String threadPoolAlias) {
        public CacheConfigurationBuilder<K, V> withDefaultEventListenersThreadPool() {
    
        public CacheConfigurationBuilder<K, V> withDiskStoreThreadPool(String threadPoolAlias, int concurrency) {
        public CacheConfigurationBuilder<K, V> withDefaultDiskStoreThreadPool() {
    
        public CacheConfigurationBuilder<K, V> withSizeOfMaxObjectGraph(long size) {
        public CacheConfigurationBuilder<K, V> withSizeOfMaxObjectSize(long size, MemoryUnit unit) {
        public CacheConfigurationBuilder<K, V> withDefaultSizeOfSettings() {
    
    
        public CacheConfiguration<K, V> build() {
    
        private <R, C extends ServiceConfiguration<?, R>> CacheConfigurationBuilder<K, V> installOrUpdate(Supplier<C> supplier, UnaryOperator<R> update) {

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**存储空间设置**

**ResourcePools**

public interface ResourcePools {
    
        <P extends ResourcePool> P getPoolForResource(ResourceType<P> var1);
        Set<ResourceType<?>> getResourceTypeSet();
    
        ResourcePools validateAndMerge(ResourcePools var1) throws IllegalArgumentException, UnsupportedOperationException;
    }

**ResourcePools****Builder**

public class ResourcePoolsBuilder implements Builder<ResourcePools> {
        private final Map<ResourceType<?>, ResourcePool> resourcePools;
    
        private ResourcePoolsBuilder() {
        private ResourcePoolsBuilder(Map<ResourceType<?>, ResourcePool> resourcePools) {
    
    
    ***********
    获取实例对象
    
        public static ResourcePoolsBuilder newResourcePoolsBuilder() {
            return new ResourcePoolsBuilder();
        }
    
        public static ResourcePoolsBuilder newResourcePoolsBuilder(ResourcePools pools) {
    
    
    ***********
    设置存储空间大小
    
        public static ResourcePoolsBuilder heap(long entries) {          //on-heap存储：键值对个数
            return newResourcePoolsBuilder().heap(entries, EntryUnit.ENTRIES);
        }
    
        public ResourcePoolsBuilder heap(long size, ResourceUnit unit) { //on-heap存储
            return this.with(Core.HEAP, size, unit, false);
        }
    
    
        public ResourcePoolsBuilder offheap(long size, MemoryUnit unit) { //off-heap存储
            return this.with(Core.OFFHEAP, size, unit, false);
        }
    
        public ResourcePoolsBuilder disk(long size, MemoryUnit unit) {    //磁盘存储
            return this.disk(size, unit, false);
        }
    
        public ResourcePoolsBuilder disk(long size, MemoryUnit unit, boolean persistent) {
            return this.with(Core.DISK, size, unit, persistent);
        }
    
    
        public ResourcePoolsBuilder with(ResourcePool resourcePool) {
        public ResourcePoolsBuilder with(ResourceType<SizedResourcePool> type, long size, ResourceUnit unit, boolean persistent) {
        public ResourcePoolsBuilder withReplacing(ResourcePool resourcePool) {
    
        public ResourcePools build() {

**ResourceUnit：存储单位**

public interface ResourceUnit {
        int compareTo(long var1, long var3, ResourceUnit var5) throws IllegalArgumentException;
    }

**MemoryUnit**

public enum MemoryUnit implements ResourceUnit {
        B("B", 0),
        KB("kB", 10),
        MB("MB", 20),
        GB("GB", 30),
        TB("TB", 40),
        PB("PB", 50);

**EntryUnit：设置on-heap存储的键值对个数**

public enum EntryUnit implements ResourceUnit {
        ENTRIES {
            public String toString() {
                return "entries";
            }
    
            public int compareTo(long thisSize, long thatSize, ResourceUnit thatUnit) throws IllegalArgumentException {
                if (this.equals(thatUnit)) {
                    return Long.signum(thisSize - thatSize);
                } else {
                    throw new IllegalArgumentException();
                }
            }
        };
    
        private EntryUnit() {
        }
    }

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**缓存过期策略**

**ExpiryPolicy**

public interface ExpiryPolicy<K, V> {
        Duration INFINITE = Duration.ofNanos(9223372036854775807L);
    
        ExpiryPolicy<Object, Object> NO_EXPIRY = new ExpiryPolicy<Object, Object>() {
                                      //永不过期
    
            public String toString() {
                return "No Expiry";
            }
    
            public Duration getExpiryForCreation(Object key, Object value) {
                return INFINITE;
            }   //存活时间无限长
    
            public Duration getExpiryForAccess(Object key, Supplier<?> value) {
                return null;
            }
    
            public Duration getExpiryForUpdate(Object key, Supplier<?> oldValue, Object newValue) {
                return null;
            }
        };
    
        Duration getExpiryForCreation(K var1, V var2);
        Duration getExpiryForAccess(K var1, Supplier<? extends V> var2);
        Duration getExpiryForUpdate(K var1, Supplier<? extends V> var2, V var3);
    }

**ExpiryPolicyBuilder**

public final class ExpiryPolicyBuilder<K, V> implements Builder<ExpiryPolicy<K, V>> {
        private final BiFunction<? super K, ? super V, Duration> create;
        private final BiFunction<? super K, ? super Supplier<? extends V>, Duration> access;
        private final ExpiryPolicyBuilder.TriFunction<? super K, ? super Supplier<? extends V>, ? super V, Duration> update;
    
        public static ExpiryPolicy<Object, Object> noExpiration() {
            return ExpiryPolicy.NO_EXPIRY;
        }
    
        public static ExpiryPolicy<Object, Object> timeToLiveExpiration(Duration timeToLive) {
            Objects.requireNonNull(timeToLive, "TTL duration cannot be null");
            if (timeToLive.isNegative()) {
                throw new IllegalArgumentException("TTL duration cannot be negative");
            } else {
                return new ExpiryPolicyBuilder.TimeToLiveExpiryPolicy(timeToLive);
            }
        }
    
        public static ExpiryPolicy<Object, Object> timeToIdleExpiration(Duration timeToIdle) {
            Objects.requireNonNull(timeToIdle, "TTI duration cannot be null");
            if (timeToIdle.isNegative()) {
                throw new IllegalArgumentException("TTI duration cannot be negative");
            } else {
                return new ExpiryPolicyBuilder.TimeToIdleExpiryPolicy(timeToIdle);
            }
        }
    
        public static ExpiryPolicyBuilder<Object, Object> expiry() {
            return new ExpiryPolicyBuilder();
        }
    
        private ExpiryPolicyBuilder() {
            this((k, v) -> {
                return ExpiryPolicy.INFINITE;
            }, (k, v) -> {
                return null;
            }, (k, oldV, newV) -> {
                return null;
            });
        }
    
        private ExpiryPolicyBuilder(BiFunction<? super K, ? super V, Duration> create, BiFunction<? super K, ? super Supplier<? extends V>, Duration> access, ExpiryPolicyBuilder.TriFunction<? super K, ? super Supplier<? extends V>, ? super V, Duration> update) {
            this.create = create;
            this.access = access;
            this.update = update;
        }
    
        public ExpiryPolicyBuilder<K, V> create(Duration create) {
            Objects.requireNonNull(create, "Create duration cannot be null");
            if (create.isNegative()) {
                throw new IllegalArgumentException("Create duration must be positive");
            } else {
                return this.create((a, b) -> {
                    return create;
                });
            }
        }
    
        public <K2 extends K, V2 extends V> ExpiryPolicyBuilder<K2, V2> create(BiFunction<K2, V2, Duration> create) {
            return new ExpiryPolicyBuilder((BiFunction)Objects.requireNonNull(create), this.access, this.update);
        }
    
        public ExpiryPolicyBuilder<K, V> access(Duration access) {
            if (access != null && access.isNegative()) {
                throw new IllegalArgumentException("Access duration must be positive");
            } else {
                return this.access((a, b) -> {
                    return access;
                });
            }
        }
    
        public <K2 extends K, V2 extends V> ExpiryPolicyBuilder<K2, V2> access(BiFunction<K2, Supplier<? extends V2>, Duration> access) {
            return new ExpiryPolicyBuilder(this.create, (BiFunction)Objects.requireNonNull(access), this.update);
        }
    
        public ExpiryPolicyBuilder<K, V> update(Duration update) {
            if (update != null && update.isNegative()) {
                throw new IllegalArgumentException("Update duration must be positive");
            } else {
                return this.update((a, b, c) -> {
                    return update;
                });
            }
        }
    
        public <K2 extends K, V2 extends V> ExpiryPolicyBuilder<K2, V2> update(ExpiryPolicyBuilder.TriFunction<K2, Supplier<? extends V2>, V2, Duration> update) {
    
        public ExpiryPolicy<K, V> build() {
    
    
    
    ***************
    空闲时间策略：TimeToIdleExpiryPolicy
    
        private static final class TimeToIdleExpiryPolicy extends ExpiryPolicyBuilder.BaseExpiryPolicy<Object, Object> {
                                   //空闲时间达到指定数值清除
            private final Duration tti;
    
            TimeToIdleExpiryPolicy(Duration tti) {
                super((a, b) -> {
                    return tti;
                }, (a, b) -> {
                    return tti;
                }, (a, b, c) -> {
                    return tti;
                });
                this.tti = tti;
            }
    
            public int hashCode() {
            public boolean equals(Object obj) {
            public String toString() {
    
    
    ***************
    剩余存活时间：TimeToLiveExpiryPolicy
    
    
        private static final class TimeToLiveExpiryPolicy extends ExpiryPolicyBuilder.BaseExpiryPolicy<Object, Object> {
                                   //缓存创建开始，指定缓存有效时间，达到后缓存失效
    
            private final Duration ttl;
    
            TimeToLiveExpiryPolicy(Duration ttl) {
                super((a, b) -> {
                    return ttl;
                }, (a, b) -> {
                    return null;
                }, (a, b, c) -> {
                    return ttl;
                });
                this.ttl = ttl;
            }
    
            public int hashCode() {
            public boolean equals(Object obj) {
            public String toString() {
    
    
    
    ***************
    内部类：BaseExpiryPolicy
    
        private static class BaseExpiryPolicy<K, V> implements ExpiryPolicy<K, V> {
            private final BiFunction<? super K, ? super V, Duration> create;
            private final BiFunction<? super K, ? super Supplier<? extends V>, Duration> access;
            private final ExpiryPolicyBuilder.TriFunction<? super K, ? super Supplier<? extends V>, ? super V, Duration> update;
    
            BaseExpiryPolicy(BiFunction<? super K, ? super V, Duration> create, BiFunction<? super K, ? super Supplier<? extends V>, Duration> access, ExpiryPolicyBuilder.TriFunction<? super K, ? super Supplier<? extends V>, ? super V, Duration> update) {
    
    
            public Duration getExpiryForCreation(K key, V value) {
            public Duration getExpiryForAccess(K key, Supplier<? extends V> value) {
            public Duration getExpiryForUpdate(K key, Supplier<? extends V> oldValue, V newValue) {
    
    
        @FunctionalInterface
        public interface TriFunction<T, U, V, R> {