首页 > 其他分享 >Spring接口缓存实现方案Caffeine和EhCache

Spring接口缓存实现方案Caffeine和EhCache

时间：2024-11-20 19:33:16浏览次数：1  
标签：EhCache return String Spring cache Caffeine import id log

Spring接口缓存实现方案Caffeine和EhCache

1.引入jar包
compile("com.github.ben-manes.caffeine:caffeine:2.8.6")
compile("org.springframework.boot:spring-boot-starter-cache")

2.application.properties
##配置ehcache
spring.cache.ehcache.config = classpath:/ehcache.xml
spring.cache.type = ehcache

##配置caffeine 或者使用下面的配置类也可以。
#spring.cache.cache-names=USER3
#spring.cache.caffeine.spec=initialCapacity=50,maximumSize=500,expireAfterWrite=5s
#spring.cache.type=caffeine

3.配置文件ehcache

<ehcache updateCheck="false" name="configCache">
    <diskStore path="java.io.tmpdir"/>
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="false"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            />

        <!--  配置自定义缓存
        maxElementsInMemory：缓存中允许创建的最大对象数
        eternal：缓存中对象是否为永久的，如果是，超时设置将被忽略，对象从不过期。
        timeToIdleSeconds：缓存数据的钝化时间，也就是在一个元素消亡之前，
                两次访问时间的最大时间间隔值，这只能在元素不是永久驻留时有效，
                如果该值是 0 就意味着元素可以停顿无穷长的时间。
        timeToLiveSeconds：缓存数据的生存时间，也就是一个元素从构建到消亡的最大时间间隔值，
                这只能在元素不是永久驻留时有效，如果该值是0就意味着元素可以停顿无穷长的时间。
        overflowToDisk：内存不足时，是否启用磁盘缓存。
        memoryStoreEvictionPolicy：缓存满了之后的淘汰算法。-->

 	<cache name="sysConfigCache2"
        maxElementsInMemory="10000" 
        eternal="false"
        overflowToDisk="false" 
        timeToIdleSeconds="900" 
        timeToLiveSeconds="1800"
        memoryStoreEvictionPolicy="LFU" />
        

</ehcache>

4.配置类caffeine

import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Configuration
public class CaffeineConfig {
    /**
     * 默认的超时时间
     */
    @Value("${caching.expire.duration:60}")
    private int duration;

    @Value("${caching.maximumSize:1000}")
    private int maximumSize;

    @Value("${caching.initialCapacity:50}")
    private int initialCapacity;

    @Bean
    public CacheManager cacheManager() {
        CaffeineCache cache = buildCache("USER2", duration);
        SimpleCacheManager manager = new SimpleCacheManager();
        manager.setCaches(Arrays.asList(cache));
        return manager;
    }

    private CaffeineCache buildCache(String name, int secondsToExpire) {
        return new CaffeineCache(name, Caffeine.newBuilder()
                .expireAfterWrite(secondsToExpire, TimeUnit.SECONDS)
                .maximumSize(maximumSize)
                .initialCapacity(initialCapacity)
                .build());
    }

}

5.caffeine演示

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/caffeine")
@lombok.extern.slf4j.Slf4j
public class CaffeineController {
    @Autowired
    private CaffeineService caffeineService;


    @GetMapping("/user/{id}")
    public String getUser(@PathVariable String id) {
        long start = System.currentTimeMillis();
        log.info("查询开始:" + start);
        String res = caffeineService.getUser(id);
        long end = System.currentTimeMillis();
        log.info("查询结束:" + end);
        log.info("查询耗时：" + (end - start));
        return res;
    }

    @GetMapping("/user2/{id}")
    public String getUser2(@PathVariable String id) {
        long start = System.currentTimeMillis();
        log.info("查询开始2:" + start);
        String res = caffeineService.getUser2(id);
        long end = System.currentTimeMillis();
        log.info("查询结束2:" + end);
        log.info("查询耗时2：" + (end - start));
        return res;
    }


    @GetMapping("/user/{id}/{name}")
    public String updateUser(@PathVariable String id, @PathVariable String name) {
        return caffeineService.updateUser(id, name);
    }

    @DeleteMapping("/user/{id}")
    public String delUser(@PathVariable String id) {
        return caffeineService.delUser(id);
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

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

@lombok.extern.slf4j.Slf4j
@Service
public class CaffeineService {

    public static Map<String, String> map = new HashMap<>();

    @Autowired
    CacheManager cacheManager;

    static {
        map.put("1", "zhangsan");
        map.put("2", "lisi");
        map.put("3", "wangwu");
    }

    @Cacheable(value = "USER3", key = "#id")
    public String getUser(String id) {
        System.out.println("getUser() run......");
        log.info("getUser() run......");

        // 这是在使用注解时做的调试，每次都进来这里，说明缓存没有生效。
        if (null != cacheManager.getCache("USER3").get(id)) {
            Object common = cacheManager.getCache("USER3").get(id).get();
            log.warn("cache !!!============ {}", common);
            System.out.println("cache !!!============");
        } else {
            log.warn("no cache !!!============");
            System.out.println("no cache !!!============");
        }

        return map.get(id);
    }

    /**
     * 手动写, 更加有优势，注解方式的话，如果key删除了，就没有返回数据，不会重新从数据库中获取初始化。
     * @param id
     * @return
     */
    public String getUser2(String id) {
        System.out.println("getUser() run......");
        String cacheKey = id;
        Cache cache = cacheManager.getCache("USER3");
        String user = (String) Optional.ofNullable(cache)
                .map(c -> c.get(cacheKey))
                .map(wapper -> {
                    Object o = wapper.get();
                    System.out.println("fetch.................");
                    log.info("fetch user from cache: cacheKey: {}, String: {}", cacheKey, o);
                    return o;
                }).orElseGet(() -> {
                    String response = map.get(id);
                    return Optional.ofNullable(response)
                            .map(data -> {
                                cache.put(cacheKey, data);
                                log.info("put init user from cache: id: {}, String: {}", cacheKey, data);
                                System.out.println("put init .................");
                                return data;
                            }).orElse(null);
                });
        return user;
    }


    @CachePut(value = "USER3", key = "#id")
    public String updateUser(String id, String name) {
        log.info("updateUser() run......");
        map.put(id, name);
        return map.get(id);
    }

    @CacheEvict(value = "USER3", key = "#id")
    public String delUser(String id) {
        log.info("delUser() run......");
        map.remove(id);
        return map.toString();
    }
}

访问
#查询
http://localhost:8080/caffeine/user/1
#查询2
http://localhost:8080/caffeine/user2/1
#修改
http://localhost:8080/caffeine/user/1/simayi
#删除
http://localhost:8080/caffeine/user/1

6.ehcache演示

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/ehcache")
@lombok.extern.slf4j.Slf4j
public class EhCacheController {
    @Autowired
    private EhCacheService ehCacheService;


    @GetMapping("/user/{id}")
    public String getUser(@PathVariable String id) {
        long start = System.currentTimeMillis();
        log.info("查询开始:" + start);
        String res = ehCacheService.getUser(id);
        long end = System.currentTimeMillis();
        log.info("查询结束:" + end);
        log.info("查询耗时：" + (end - start));
        return res;
    }

    @GetMapping("/user2/{id}")
    public String getUser2(@PathVariable String id) {
        long start = System.currentTimeMillis();
        log.info("查询开始2:" + start);
        String res = ehCacheService.getUser2(id);
        long end = System.currentTimeMillis();
        log.info("查询结束2:" + end);
        log.info("查询耗时2：" + (end - start));
        return res;
    }


    @GetMapping("/user/{id}/{name}")
    public String updateUser(@PathVariable String id, @PathVariable String name) {
        return ehCacheService.updateUser(id, name);
    }

    @DeleteMapping("/user/{id}")
    public String delUser(@PathVariable String id) {
        return ehCacheService.delUser(id);
    }
}




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

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

@lombok.extern.slf4j.Slf4j
@Service
public class EhCacheService {

    public static Map<String, String> map = new HashMap<>();

    @Autowired
    CacheManager cacheManager;

    static {
        map.put("1", "zhangsan22");
        map.put("2", "lisi22");
        map.put("3", "wangwu22");
    }

    @Cacheable(value = "sysConfigCache2", key = "#id")
    public String getUser(String id) {
        System.out.println("getUser() run......");
        log.info("getUser() run......");

        // 这是在使用注解时做的调试，每次都进来这里，说明缓存没有生效。
        if (null != cacheManager.getCache("sysConfigCache2").get(id)) {
            Object common = cacheManager.getCache("sysConfigCache2").get(id).get();
            log.info("cache !!!============ {}", common);
            System.out.println("cache !!!============");
        } else {
            log.warn("no cache !!!============");
            System.out.println("no cache !!!============");
        }

        return map.get(id);
    }

    /**
     * 手动写, 更加有优势，注解方式的话，如果key删除了，就没有返回数据，不会重新从数据库中获取初始化。
     * @param id
     * @return
     */
    public String getUser2(String id) {
        System.out.println("getUser() run......");
        String cacheKey = id;
        Cache cache = cacheManager.getCache("sysConfigCache2");
        String user = (String) Optional.ofNullable(cache)
                .map(c -> c.get(cacheKey))
                .map(wapper -> {
                    Object o = wapper.get();
                    System.out.println("fetch.................");
                    log.info("fetch user from cache: cacheKey: {}, String: {}", cacheKey, o);
                    return o;
                }).orElseGet(() -> {
                    String response = map.get(id);
                    return Optional.ofNullable(response)
                            .map(data -> {
                                cache.put(cacheKey, data);
                                log.info("put init user from cache: id: {}, String: {}", cacheKey, data);
                                System.out.println("put init .................");
                                return data;
                            }).orElse(null);
                });
        return user;
    }


    @CachePut(value = "sysConfigCache2", key = "#id")
    public String updateUser(String id, String name) {
        log.info("updateUser() run......");
        map.put(id, name);
        return map.get(id);
    }

    @CacheEvict(value = "sysConfigCache2", key = "#id")
    public String delUser(String id) {
        log.info("delUser() run......");
        map.remove(id);
        return map.toString();
    }
}

访问
#查询
http://localhost:8080/ehcache/user/1
#查询2
http://localhost:8080/ehcache/user2/1
#修改
http://localhost:8080/ehcache/user/1/zhugeliang
#删除
http://localhost:8080/ehcache/user/1

标签：EhCache,return,String,Spring,cache,Caffeine,import,id,log
From： https://www.cnblogs.com/oktokeep/p/18559057

相关文章

  • 信步漫谈之SpringBoot配置相关注释
    目录目标@ConfigurationProperties@EnableConfigurationProperties@Configuration示例代码参考资料（感谢）目标@EnableConfigurationProperties、@ConfigurationProperties、@Configuration区别和用法@ConfigurationProperties将我们项目中的yaml文件或者properties文件......
  • springboot毕设公司人事管理系统程序+论文
    系统程序文件列表开题报告内容研究背景在当今快速发展的信息化时代，企业管理正逐步向智能化、高效化转型。人事管理作为企业运营的核心环节之一，其效率与准确性直接关系到企业的竞争力与可持续发展能力。传统的人事管理方式往往依赖于纸质文档和人工操作，不仅耗时费力，还容易出......
  • springboot毕设公司人事档案管理系统程序+论文
    系统程序文件列表开题报告内容研究背景随着信息技术的飞速发展和企业管理理念的不断更新，人事档案管理作为企业日常运营中的重要环节，其效率与准确性直接关系到企业的竞争力和运营效率。传统的纸质档案管理方式不仅占用大量空间资源，还存在查询效率低、信息易丢失或篡改等问题......
  • 【Java系列】Spring Boot 配置Spring Native 详细步骤
    配置SpringNative以减少SpringBoot应用的启动时间，涉及几个关键步骤，包括设置相应的依赖、配置文件以及构建过程。以下是详细的步骤和配置示例：一、前提条件确保你的项目使用的是SpringBoot2.5或更高版本，并且使用Java11或更高版本。二、添加依赖在你的pom.x......
  • A037-基于Spring Boot的二手物品交易的设计与实现
    ......
  • SpringBoot+Docker +Nginx 部署前后端项目
    部署SpringBoot项目（通关版）一、概述使用 java-jar 命令直接部署项目的JAR包和使用Docker制作镜像进行部署是两种常见的部署方式。以下是对这两种方式的概述和简要的优劣势分析：1.1、使用 java-jar 命令直接部署项目的JAR包概述：通过 java-jar 直接部署项目的JA......
  • Spring八股
    SpringSpring框架核心特性IoC容器，AOP，事务管理，MVC框架SpringIOC实现机制反射，依赖注入，设计模式-工厂模式，容器实现SpringAOP实现机制SpringAOP的实现依赖于动态代理技术基于JDK的动态代理基于CGLIB的动态代理依赖倒置高层模块不依赖低层模块，它们共同依赖同一个抽象......
  • springboot汽车租赁智慧管理-计算机毕业设计源码96317
    目 录第1章引 言1.1选题背景1.2研究现状1.3论文结构安排第2章系统的需求分析2.1系统可行性分析2.1.1技术方面可行性分析2.1.2经济方面可行性分析2.1.3法律方面可行性分析2.1.4操作方面可行性分析2.2系统功能需求分析2.3系统性需......
  • Spring学习笔记_41——@RequestBody
    @RequestBody1.介绍@RequestBody是Spring框架中用于处理HTTP请求的一个非常关键的注解。它主要用于将客户端发送的HTTP请求体中的JSON、XML或其他格式的数据转换到Java方法参数上，这个转换过程通常需要一个消息转换器（MessageConverter），如MappingJackson2HttpMe......
  • springboot农产品小程序-计算机毕业设计源码31670
    摘要 近年来，电子商务的快速发展引起了行业和学术界的高度关注。农产品小程序旨在为用户提供一个简单、高效、便捷的新鲜农产品购物体验，它不仅要求用户清晰地查看所需信息，而且还要求界面设计精美，使得功能与页面完美融合，从而提升系统的可操作性。因此，我们需要深入研究信息内......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99