SpringBoot学习笔记(6) SpringBoot数据缓存Cache [Guava和Redis实现]

https://blog.csdn.net/a67474506/article/details/52608855

Spring定义了org.springframework.cache.CacheManager和org.springframework.cache.Cache接口来统一不同的缓存技术,而SpringBoot为我们提供了自动配置多个CacheManager的实现

在不适用任何额外配置的情况下,默认使用SimpleCacheConfiguration

SpringBoot通过spring.cache为前缀来配置缓存

使用这些缓存实现的话,只需导入相关缓存的依赖,并在配置类中使用@EnableCaching开启缓存即可

Guava实现

这里简单介绍下使用Guava实现

引入的依赖

pom.xml

1.  
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3.  
   <modelVersion>4.0.0</modelVersion>
4.  
   <groupId>com.ibigsea</groupId>
5.  
   <artifactId>spirngboot-cache-demo</artifactId>
6.  
   <version>0.0.1-SNAPSHOT</version>
7.  
    
8.  
    
9.  
   <properties>
10.  
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
11.  
    <boot.version>1.3.5.RELEASE</boot.version>
12.  
    </properties>
13.  
     
14.  
    <dependencies>
15.  
    <dependency>
16.  
    <groupId>org.springframework.boot</groupId>
17.  
    <artifactId>spring-boot-starter-web</artifactId>
18.  
    <version>${boot.version}</version>
19.  
    </dependency>
20.  
    <dependency>
21.  
    <groupId>org.springframework.boot</groupId>
22.  
    <artifactId>spring-boot-starter-test</artifactId>
23.  
    <version>${boot.version}</version>
24.  
    <scope>test</scope>
25.  
    </dependency>
26.  
    <dependency>
27.  
    <groupId>org.springframework.boot</groupId>
28.  
    <artifactId>spring-boot-starter-cache</artifactId>
29.  
    <version>${boot.version}</version>
30.  
    </dependency>
31.  
    <dependency>
32.  
    <groupId>com.google.guava</groupId>
33.  
    <artifactId>guava</artifactId>
34.  
    <version>19.0</version>
35.  
    </dependency>
36.  
    </dependencies>
37.  
    </project>

dataCache.java

1.  
   package com.ibigsea.springboot_cache_demo.cache;
2.  
    
3.  
   import java.text.SimpleDateFormat;
4.  
   import java.util.Date;
5.  
   import java.util.HashMap;
6.  
   import java.util.Map;
7.  
    
8.  
   import javax.annotation.PostConstruct;
9.  
    
10.  
    import org.springframework.cache.annotation.CacheConfig;
11.  
    import org.springframework.cache.annotation.CacheEvict;
12.  
    import org.springframework.cache.annotation.CachePut;
13.  
    import org.springframework.cache.annotation.Cacheable;
14.  
    import org.springframework.stereotype.Component;
15.  
     
16.  
    @Component
17.  
    public class DataCache {
18.  
     
19.  
    private Map<Long, String> dataMap = new HashMap<>();
20.  
     
21.  
    /**
22.  
    * 初始化
23.  
    */
24.  
    @PostConstruct
25.  
    public void init() {
26.  
    dataMap.put(1L, "张三");
27.  
    dataMap.put(2L, "李四");
28.  
    dataMap.put(3L, "王五");
29.  
    }
30.  
     
31.  
    /**
32.  
    * 查询
33.  
    * 如果数据没有缓存,那么从dataMap里面获取,如果缓存了,
34.  
    * 那么从guavaDemo里面获取
35.  
    * 并且将缓存的数据存入到 guavaDemo里面
36.  
    * 其中key 为 #id+dataMap
37.  
    */
38.  
    @Cacheable(value="guavaDemo" ,key="#id + 'dataMap'")
39.  
    public String query(Long id) {
40.  
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
41.  
    System.out.println(sdf.format(new Date()) + " : query id is " + id);
42.  
    return dataMap.get(id);
43.  
    }
44.  
     
45.  
    /**
46.  
    * 插入 或者更新
47.  
    * 插入或更新数据到dataMap中
48.  
    * 并且缓存到 guavaDemo中
49.  
    * 如果存在了那么更新缓存中的值
50.  
    * 其中key 为 #id+dataMap
51.  
    */
52.  
    @CachePut(value="guavaDemo" ,key="#id + 'dataMap'")
53.  
    public String put(Long id, String value) {
54.  
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
55.  
    System.out.println(sdf.format(new Date()) + " : add data ,id is "+ id);
56.  
    dataMap.put(id, value);
57.  
    // data persistence
58.  
    return value;
59.  
    }
60.  
     
61.  
    /**
62.  
    * 删除
63.  
    * 删除dataMap里面的数据
64.  
    * 并且删除缓存guavaDemo中的数据
65.  
    * 其中key 为 #id+dataMap
66.  
    */
67.  
    @CacheEvict(value="guavaDemo" , key="#id + 'dataMap'")
68.  
    public void remove(Long id) {
69.  
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
70.  
    System.out.println(sdf.format(new Date()) + " : remove id is "+ id + " data");
71.  
    dataMap.remove(id);
72.  
    // data remove
73.  
    }
74.  
     
75.  
     
76.  
    }

关于缓存注解中的value,就是配置文件中的cache-names

关于注解中的key这个值,如果不指定的话 ,那么会取方法参数当做Key

application.yml

1.  
   spring:
2.  
   cache:
3.  
   #缓存名称
4.  
   cache-names: guavaDemo
5.  
   #缓存最大数量500条, 缓存失效时间 6个小时
6.  
   guava.spec: maximumSize=500,expireAfterWrite=360m

App.java

1.  
   package com.ibigsea.springboot_cache_demo;
2.  
    
3.  
   import java.text.SimpleDateFormat;
4.  
   import java.util.Date;
5.  
    
6.  
   import org.springframework.beans.factory.annotation.Autowired;
7.  
   import org.springframework.boot.SpringApplication;
8.  
   import org.springframework.boot.autoconfigure.SpringBootApplication;
9.  
   import org.springframework.cache.annotation.EnableCaching;
10.  
    import org.springframework.web.bind.annotation.RequestMapping;
11.  
    import org.springframework.web.bind.annotation.RestController;
12.  
     
13.  
    import com.ibigsea.springboot_cache_demo.cache.DataCache;
14.  
     
15.  
    /**
16.  
    * 是Spring Boot项目的核心注解,主要是开启自动配置
17.  
    */
18.  
    @SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
19.  
    @RestController
20.  
    // 开启缓存
21.  
    @EnableCaching
22.  
    public class App {
23.  
     
24.  
    @Autowired
25.  
    private DataCache dataCache;
26.  
     
27.  
    public static void main(String[] args) {
28.  
    SpringApplication.run(App.class, args);
29.  
    }
30.  
     
31.  
    @RequestMapping("/put")
32.  
    public String put(Long id, String value) {
33.  
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
34.  
    return sdf.format(new Date()) + " : value is " + dataCache.put(id, value) ;
35.  
    }
36.  
     
37.  
    @RequestMapping("/get")
38.  
    public String query(Long id){
39.  
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
40.  
    return sdf.format(new Date()) + " : value is " +dataCache.query(id) ;
41.  
    }
42.  
     
43.  
    @RequestMapping("/remove")
44.  
    public String remove(Long id) {
45.  
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
46.  
    dataCache.remove(id) ;
47.  
    return sdf.format(new Date()) + " : success " ;
48.  
    }
49.  
     
50.  
    }

运行结果

关于注解配置:

@Cacheable

@CacheEvict

@CachePut

和上面的一样,只是这个注解是用来更新或者插入数据到缓存中的,

其中key自己定义,返回值会缓存

还有就是SpringBoot会根据你的类路径里面的依赖jar,来确定使用什么类型进行缓存,所以基本是我们是不用配置spring.cache.type这个属性的

Redis实现

Redis缓存:

如果是用redis作为缓存的话

我们只需要引入redis相关依赖,修改yml配置属性

1.  
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3.  
   <modelVersion>4.0.0</modelVersion>
4.  
   <groupId>com.ibigsea</groupId>
5.  
   <artifactId>spirngboot-cache-demo</artifactId>
6.  
   <version>0.0.1-SNAPSHOT</version>
7.  
    
8.  
    
9.  
   <properties>
10.  
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
11.  
    <boot.version>1.3.5.RELEASE</boot.version>
12.  
    </properties>
13.  
     
14.  
    <dependencies>
15.  
    <dependency>
16.  
    <groupId>org.springframework.boot</groupId>
17.  
    <artifactId>spring-boot-starter-web</artifactId>
18.  
    <version>${boot.version}</version>
19.  
    </dependency>
20.  
    <dependency>
21.  
    <groupId>org.springframework.boot</groupId>
22.  
    <artifactId>spring-boot-starter-test</artifactId>
23.  
    <version>${boot.version}</version>
24.  
    <scope>test</scope>
25.  
    </dependency>
26.  
    <dependency>
27.  
    <groupId>org.springframework.boot</groupId>
28.  
    <artifactId>spring-boot-starter-cache</artifactId>
29.  
    <version>${boot.version}</version>
30.  
    </dependency>
31.  
    <dependency>
32.  
    <groupId>org.springframework.boot</groupId>
33.  
    <artifactId>spring-boot-starter-redis</artifactId>
34.  
    <version>${boot.version}</version>
35.  
    </dependency>
36.  
    <!-- <dependency> -->
37.  
    <!-- <groupId>com.google.guava</groupId> -->
38.  
    <!-- <artifactId>guava</artifactId> -->
39.  
    <!-- <version>19.0</version> -->
40.  
    <!-- </dependency> -->
41.  
    </dependencies>
42.  
    </project>

application.yml

1.  
   spring:
2.  
   cache:
3.  
   #缓存名称
4.  
   cache-names: guavaDemo
5.  
   #缓存最大数量500条, 缓存失效时间 6个小时
6.  
   #guava.spec: maximumSize=500,expireAfterWrite=360m
7.  
   # REDIS (RedisProperties)
8.  
   redis :
9.  
   host : localhost # server host
10.  
    port : 6379 # connection port
11.  
    pool.max-idle : 8 # pool settings ...
12.  
    pool.min-idle : 1
13.  
    pool.max-active : 8
14.  
    pool.max-wait : -1

就这样就OK了,代码什么的都是不用改变的,是不是很方便

测试结果

数据都会缓存到redis里面

其他的地方就不测试了 都是差不多的

使用其他实现导入对应的依赖,然后添加配置即可

注意:

如果使用guava缓存的时候 ,同时添加了redis的jar依赖,或者其他的依赖,可能会出现异常

这个时候加上 type: GUAVA 就可以

版权声明：本文为博主原创文章，博客地址:http://blog.csdn.net/a67474506?viewmode=contents https://blog.csdn.net/a67474506/article/details/52608855

 

---

guava cache

 

缓存是提高性能的一把利器。
常用到的缓存技术有分布式缓存，像Redis、MC；也有本地缓存，像ehcache、guava cache等。这里说的是本地缓存guava cache。

guava cache刚开始接触，这就记录下来。。

    public static void main(String[] args) throws ExecutionException, InterruptedException{
        //缓存接口这里是LoadingCache，LoadingCache在缓存项不存在时可以自动加载缓存
        LoadingCache<Integer,Student> studentCache
                //CacheBuilder的构造函数是私有的，只能通过其静态方法newBuilder()来获得CacheBuilder的实例
                = CacheBuilder.newBuilder()
                //设置并发级别为8，并发级别是指可以同时写缓存的线程数
                .concurrencyLevel(8)
                //设置写缓存后8秒钟过期
                .expireAfterWrite(8, TimeUnit.SECONDS)
　　　　　　　　　　//设置写缓存后1秒钟刷新
　　　　　　　　　.refreshAfterWrite(1, TimeUnit. SECONDS)
                //设置缓存容器的初始容量为10
                .initialCapacity(10)
                //设置缓存最大容量为100，超过100之后就会按照LRU最近虽少使用算法来移除缓存项
                .maximumSize(100)
                //设置要统计缓存的命中率
                .recordStats()
                //设置缓存的移除通知
                .removalListener(new RemovalListener<Object, Object>() {
                    @Override
                    public void onRemoval(RemovalNotification<Object, Object> notification) {
                        System.out.println(notification.getKey() + " was removed, cause is " + notification.getCause());
                    }
                })
                //build方法中可以指定CacheLoader，在缓存不存在时通过CacheLoader的实现自动加载缓存
                .build(
                        new CacheLoader<Integer, Student>() {
                            @Override
                            public Student load(Integer key) throws Exception {
                                System.out.println("load student " + key);
                                Student student = new Student();
                                student.setId(key);
                                student.setName("name " + key);
                                return student;
                            }
                        }
                );

        for (int i=0;i<20;i++) {
            //从缓存中得到数据，由于我们没有设置过缓存，所以需要通过CacheLoader加载缓存数据
            Student student = studentCache.get(1);
            System.out.println(student);
            //休眠1秒
            TimeUnit.SECONDS.sleep(1);
        }

        System.out.println("cache stats:");
        //最后打印缓存的命中率等 情况
        System.out.println(studentCache.stats().toString());
    }

还有另一种方法

package com;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import com.google.common.cache.*;

/**
 * @author  作者 PZhang  E-mail:pzhang@rxhui.com
 * @date 创建时间：2017-2-15 上午9:58:00
 * @version 1.0
 * @parameter
 * @return
 */
public class CacheModel {
    public Student getStudent(Integer key){
        System.out.println("load student " + key);
        Student student = new Student();
        student.setId(key);
        student.setName("name " + key);
        return student;
    }
    //load Method
    public void loadCacheA() throws Exception{
         LoadingCache<Integer,Student> studentCache= CacheBuilder.newBuilder().concurrencyLevel(8).
                 expireAfterWrite(8, TimeUnit.SECONDS).refreshAfterWrite(1, TimeUnit. SECONDS).initialCapacity(10).maximumSize(100)
                 .recordStats().removalListener(new RemovalListener<Object, Object>() {
                     public void onRemoval(RemovalNotification<Object, Object> notification) {
                                 System.out.println(notification.getKey() + " was removed, cause is " + notification);}
                     }).build(
                    new CacheLoader<Integer, Student>() {
                        @Override
                        public Student load(Integer key) throws Exception {
                            return getStudent(key);
                           }
                        }
          );

         for (int i=0;i<20;i++) {
           Student student = studentCache.get(1);
           System.out.println(student);
           TimeUnit.SECONDS.sleep(1);
         }

         System.out.println("cache stats:");
         System.out.println(studentCache.stats().toString());

    }
    //call back Method
    public void loadCacheB(final Integer key) throws Exception{
         Cache<Integer, Student> cache = CacheBuilder.newBuilder().maximumSize(1000).recordStats().expireAfterWrite(8, TimeUnit.SECONDS).build();  

         for (int i=0;i<20;i++) {
                System.out.println(cache.get(key, new Callable<Student>() {
                     public Student call() {
                        return getStudent(key);
                    }
                }));
                TimeUnit.SECONDS.sleep(1);
              }

              System.out.println("cache stats:");
              System.out.println(cache.stats().toString());
    }

    public static void main(String[] args) throws Exception {
        CacheModel cache = new CacheModel();
        cache.loadCacheB(2);
    }

}

　　guava Cache数据移除：

　　guava做cache时候数据的移除方式，在guava中数据的移除分为被动移除和主动移除两种。
　　被动移除数据的方式，guava默认提供了三种方式：
　　1.基于大小的移除:看字面意思就知道就是按照缓存的大小来移除，如果即将到达指定的大小，那就会把不常用的键值对从cache中移除。
　　定义的方式一般为 CacheBuilder.maximumSize(long)，还有一种一种可以算权重的方法，个人认为实际使用中不太用到。就这个常用的来看有几个注意点，
　　　　其一，这个size指的是cache中的条目数，不是内存大小或是其他；
　　　　其二，并不是完全到了指定的size系统才开始移除不常用的数据的，而是接近这个size的时候系统就会开始做移除的动作；
　　　　其三，如果一个键值对已经从缓存中被移除了，你再次请求访问的时候，如果cachebuild是使用cacheloader方式的，那依然还是会从cacheloader中再取一次值，如果这样还没有，就会抛出异常
　　2.基于时间的移除：guava提供了两个基于时间移除的方法
　　　　expireAfterAccess(long, TimeUnit)  这个方法是根据某个键值对最后一次访问之后多少时间后移除
　　　　expireAfterWrite(long, TimeUnit)  这个方法是根据某个键值对被创建或值被替换后多少时间移除
　　3.基于引用的移除：
　　这种移除方式主要是基于java的垃圾回收机制，根据键或者值的引用关系决定移除
　　主动移除数据方式，主动移除有三种方法：
　　1.单独移除用 Cache.invalidate(key)
　　2.批量移除用 Cache.invalidateAll(keys)
　　3.移除所有用 Cache.invalidateAll()
　　如果需要在移除数据的时候有所动作还可以定义Removal Listener，但是有点需要注意的是默认Removal Listener中的行为是和移除动作同步执行的，如果需要改成异步形式，可以考虑使用RemovalListeners.asynchronous(RemovalListener, Executor)

 

 

标签: cache