JetCache快速入门小案例

小鱼儿 2021-12-14 17:09 485阅读 0赞

本文是基于SpringBoot的小案例，废话不多说，直接上代码：  
pom依赖：

<dependency>
    			<groupId>com.alicp.jetcache</groupId>
    			<artifactId>jetcache-starter-redis</artifactId>
    			<version>2.5.12</version>
    </dependency>

JetCache配置参数：**格式缩进需要注意**

# jetcache缓存全局配置
    jetcache:
      statIntervalMinutes: 15
      areaInCacheName: false
      local:
        default:
          type: linkedhashmap
          keyConvertor: fastjson
        otherCacheName:
          type: xxx
          keyConverter: yyy
      remote:
        default:
          type: redis
          keyConvertor: fastjson
          valueEncoder: java
          valueDecoder: java
          poolConfig:
            minIdle: 5
            maxIdle: 20
            maxTotal: 50
          host: 127.0.0.1
          port: 6379

下面是通过@CreateCache注解创建一个二级缓存实例，@CreateCache注解一般用在变量上：redis分布式锁这部分请参考我之前的博客地址[redis分布式锁][redis]

package com.daling.cache;
    
    import com.alicp.jetcache.Cache;
    import com.alicp.jetcache.CacheGetResult;
    import com.alicp.jetcache.anno.CacheType;
    import com.alicp.jetcache.anno.CreateCache;
    import com.daling.bean.Student;
    import com.daling.util.lock.LockUtils;
    import com.daling.util.lock.jedisLock.RdLock;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    
    @Component
    public class GatewayCache {
    
        private Logger logger = LoggerFactory.getLogger(GatewayCache.class);
    
        private final String GATEWAY_PREFIX = "gateway_";
        
        /**
         * 通过@CreateCache注解创建一个二级（内存 + 远程）缓存实例，默认超时时间是60秒，内存中的元素个数限制在50个
         */
        @CreateCache(name = GATEWAY_PREFIX, expire = 60, cacheType = CacheType.BOTH, localLimit = 50)
        private Cache<String, Student> studentCache;
    
        public Student getStudent() {
            Student student = new Student();
            CacheGetResult<Student> result = studentCache.GET("10000");
            if(result.isSuccess()){
                student = result.getValue();
                return student;
            }
            // 先获取锁，串行操作
            // RdLock实现了Closeable接口，try代码块结束后会执行close方法
            try(RdLock rdLock = LockUtils.getRLock(GATEWAY_PREFIX + "getStudent")){
                boolean lock = rdLock.tryLock();
                if (!lock) {
                    System.out.println("获取锁过于频繁");
                    return null;
                }else {
                    student = new Student(100, "tanhq", 1);
                    studentCache.put("10000", student);
                }
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
            return student;
        }
    }

Student实体类，该实体类必须实现Serializable，不然无法序列化存入JetCache缓存中：

package com.daling.bean;
    
    import java.io.Serializable;
    
    public class Student implements Serializable {
    
        private Integer id;
        private String name;
        private Integer gender;
        
    	//set,get方法和构造方法省略
    }

Application启动类：

package com.daling;
    
    import com.alicp.jetcache.anno.config.EnableCreateCacheAnnotation;
    import com.alicp.jetcache.anno.config.EnableMethodCache;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.ImportResource;
    
    @ComponentScan
    @SpringBootApplication
    //@ImportResource是引入spring配置文件.xml; @Import注解是引入带有@Configuration的java类。
    @ImportResource(locations = "classpath:applicationContext.xml")
    //制定开启缓存对应的包路径名，激活Cached注解
    @EnableMethodCache(basePackages = "com.daling.cache")
    //开启对应的CreateCache注解
    @EnableCreateCacheAnnotation
    public class SpringbootApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(SpringbootApplication.class, args);
    	}
    }

最后一个是测试Controller：

package com.daling.controller;
    
    import com.daling.cache.GatewayCache;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @RestController = @Controller + @ResponseBody
     */
    @RestController
    @RequestMapping(path = "/jetcache")
    public class JetCacheController {
    
        @Autowired
        private GatewayCache gatewayCache;
    
        @RequestMapping(value="/getStudent")
        public void get(){
            for (int i = 0; i < 10 ; i++) {
                new Thread(() -> gatewayCache.getStudent()).start();
            }
        }
    }

启动Application启动类，调用上面Controller接口地址**[http://localhost:8080/jetcache/getStudent][http_localhost_8080_jetcache_getStudent]**即可。

[redis]: https://blog.csdn.net/thqtzq/article/details/89448253
[http_localhost_8080_jetcache_getStudent]: http://localhost:8080/jetcache/getStudent