ehcache 使用说明

最新推荐文章于 2025-07-03 18:14:46 发布
最新推荐文章于 2025-07-03 18:14:46 发布
阅读量559 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： ehcache 文章标签： ehcache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43931625/article/details/116399929

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;
}

 

ResourcePoolsBuilder

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> {

 

 

【SpringBoot】27、SpringBoot中整合Ehcache实现热点数据缓存
Asurplus
07-24 21万+
EhCache 是一个纯 Java 的进程内缓存框架，具有快速、精干等特点，是 Hibernate 中默认的CacheProvider。用惯了 Redis，很多人可能已经忘记了还有 EhCache 这么一个缓存框架 一、简介 EhCache 是一个纯 Java 的进程内缓存框架，具有快速、精干等特点，是 Hibernate 中默认CacheProvider。Ehcache 是一种广泛使用的开源 Java 分布式缓存。主要面向通用缓存,Java EE 和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展,
Ehcache Java 缓存框架 v3.5.2
10-14
EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。 主要的特性有： 1. 快速. 2. 简单. 3. 多种缓存策略 4. 缓存数据有两级：内存和磁盘，因此
EhCache初体验
weixin_34306446的博客
09-17 874
一、简介 　　EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点。Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。　　 　　主要的特性有：  快速  简单  多种缓存策略 缓...
Springboot3整合ehcache3缓存--XML配置和编程式配置
最新发布
m0_72945550的博客
07-03 1028
SpringBoot集成EhCache3的两种配置方法比较：XML配置（简单方案）通过在类路径下添加ehcache.xml文件定义缓存策略，并在application.yml中指定配置文件路径，适合简单固定策略场景。编程式配置（灵活方案）通过Java代码创建CacheManager Bean，动态定义缓存参数，适合需要运行时调整的复杂场景。关键区别在于XML配置维护简单但灵活性低，编程式配置代码量稍多但控制力强。特别注意SpringBoot3中EhCache3已基于JCache规范，需使用JCacheCac
SpringBoot整合Ehcache
wenge1477的博客
12-01 282
文章目录SpringBoot整合Ehcache【一】简介【二】添加maven依赖【三】基本架构【四】进行本地缓存配置【五】xml文件配置讲解【六】链接 SpringBoot整合Ehcache 【一】简介 介绍： EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点,Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和...
Ehcache使用
lianOwen的博客
07-25 681
maven依赖 &lt;dependency&gt; &lt;groupId&gt;org.ehcache&lt;/groupId&gt; &lt;artifactId&gt;ehcache&lt;/artifactId&gt; &lt;version&gt;3.5.2&lt;/version&gt; &lt;/dependency&amp
Spring Boot 缓存应用实践
程序猿DD
09-22 447
点击上方蓝色“程序猿DD”，选择“设为星标”回复“资源”获取独家整理的学习资料！来源：cnblogs.com/jeffwongishandsome缓存是最直接有效提升系统性能的手段之一。...
EHCache缓存使用说明与整合测试案例解析
文档中提到的“ehcache使用说明.doc”文件可能详细描述了EHCache缓存的配置方法、API使用、部署步骤以及性能调优技巧。文档也会包含异常处理和故障排除的相关内容，帮助开发者在实际项目中更加有效地使用EHCache。 ...
集群环境中使用_EhCache_缓存系统&Ehcache配置文件的详细说明
03-23
在集群环境中使用EhCache，可以实现数据的共享和一致性，有效减轻数据库的压力。本篇文章将深入探讨EhCache在集群环境中的应用及其配置文件的详细设置。 一、EhCache概述 EhCache是由Terracotta公司开发的内存缓存...
ehcache-3.3.1-API文档-中文版.zip
06-26
赠送jar包：ehcache-3.3.1.jar； 赠送原API文档：ehcache-3.3.1-javadoc.jar； 赠送源代码：ehcache-3.3.1-sources.jar；...人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
ehcache使用
我在深圳的这些日子的博客
09-26 214
1、在pom文件里引入 org.springframework.boot spring-boot-starter-cache org.ehcache ehcache 3.5.2 2、在配置文件yaml里添加 spring: cache: ehcache: config: classpath:ehcache.xml 3、在application里加入 @EnableCaching 4、在代码...
EhCache使用
z_xin1024的博客
07-21 539
1，使用代码编写的方式使用ehcache： 准备一个可用的maven项目：pom文件中引用：； <dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache</artifactId> <version>2.8.3</version> </dependency> 版本号可根据具体匹配； 1.:首先您得准备一些ehcache
Spring AOP+ehCache简单缓存系统解决方案
linfanhehe的专栏
06-25 5441
需要使用Spring来实现一个Cache简单的解决方案，具体需求如下：使用任意一个现有开源Cache Framework，要求可以Cache系统中Service或则DAO层的get/find等方法返回结果，如果数据更新（使用Create/update/delete方法），则刷新cache中相应的内容。  根据需求，计划使用Spring AOP + ehCache来实现这个功能，采用ehCac
Ehcache教程
JohnieLi的博客
01-11 941
官网链接：https://www.ehcache.org/ 官网英文文档链接：https://www.ehcache.org/documentation/3.8/getting-started.html Maven 依赖： <dependency> <groupId>org.ehcache</groupId> <artif...
Ehcache应用（一）--- 基本使用
hurricane_li的博客
09-24 960
引入的依赖： &lt;dependency&gt; &lt;groupId&gt;org.ehcache&lt;/groupId&gt; &lt;artifactId&gt;ehcache&lt;/artifactId&gt; &lt;version&gt;3.5.2&lt;/version&gt; &lt;/dependency&gt; 使用jav
Spring Boot文档阅读笔记-EhCache的使用
IT1995的博客
04-16 937
这里要先注意2个概念： buffer和cache，很多人会讲这两个概念混用。但其实这是两个概念！ buffer：一般是指存储临时数据的实体。只能读写一次，对于程序员来说buffer是可见的，比如TCB中，接收tcp数据的buffer。 cache：对于程序员来说是不可见的。允许多次获取相同的数据。这也就是EhCache不叫EhBuffer的原因。 程序结构如下： 首先来看下pom.xml <?xml version="1.0" encoding="UTF-8"?&g...
EhCache缓存使用教程
weixin_45032957的博客
04-29 452
使用方法 1、在pom.xml里添加依赖： <!--引入Mybatis的ehCache的适配--> <dependency> <groupId>org.mybatis.caches</groupId> <artifactId>mybatis-ehcache</artifactId> <version>1.0.3</version> </
【笔记06】Ehcache 缓存框架的使用
m0_54189068的博客
08-13 929
Ehcache 缓存框架的使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值