/**     * 定义全局变量     */    private static Map<String,Object> CACHE_MAP;
/** * 获取缓存map中的值 * @param key * @return */public static Object getCacheMapValue(String key){    Object value = getCacheMap().get(key);    return value == null ? null : value ;}
/** * 存放键值对 * @param key * @param value */public static void putCache(String key,Object value){    getCacheMap().put(key,value);
}
/** * 删除 * @param key */public static void removeCache(String key){    getCacheMap().remove(key);}
/** * 获取map * @return */public static Map<String,Object> getCacheMap(){    if(CACHE_MAP == null ){        CACHE_MAP = new HashMap<>();    }
    return CACHE_MAP;}
public static void main(String[] args) {    putCache("1","test1");    putCache("2","test2");    putCache("3","test3");
    System.out.println(getCacheMapValue("1")); //返回test1
    removeCache("1");
    System.out.println(getCacheMapValue("1")); //返回nul}

<dependency>      <groupId>com.google.guava</groupId>      <artifactId>guava</artifactId>      <version>25.0-jre</version></dependency>

Cache<String,String> cache = CacheBuilder.newBuilder().build();cache.put("word","Hello World");System.out.println(cache.getIfPresent("word"));

Cache<String,String> cache1 = CacheBuilder.newBuilder()                .concurrencyLevel(8)                     //并发级别为8，表示只有8个线程可以同时写缓存                .expireAfterWrite(10, TimeUnit.SECONDS) //写入缓存10秒后过期                .initialCapacity(10)                             //容器初始容量为10                .maximumSize(15)                                 //容器最大存储容量为15                        .build();

Cache<String,Object> cache3 = CacheBuilder.newBuilder()                .weakKeys()                .weakValues()                .build();

 Cache<String,Object> cache4 = CacheBuilder.newBuilder().build();        cache4.put("1","1");        cache4.put("2","2");        cache4.put("3","3");
//cache4.invalidate("1"); //单个删除key为1的缓存项
List<String> keyList=new ArrayList<>();keyList.add("1");keyList.add("2");cache4.invalidateAll(keyList); //将key为1和2的缓存项批量移除
cache4.invalidateAll(); //将cache4中的缓存项全部移除

LoadingCache<String,Object> loadingCache = CacheBuilder.newBuilder().build(                new CacheLoader<String, Object>() {                    @Override                    public Object load(String s) throws Exception {                        if(s.equals("key1")){                            return "value";                        }                       return null;                    }                });System.out.println(loadingCache.get("key1")); //返回load方法中指定的“value”System.out.println(loadingCache.get("key2")); //不满足load方法的if判断，返回空，抛出ExecutionException

//--自动填充--LoadingCache<String,Object> cache = Caffeine.newBuilder()     		                .build(key -> load());
//缓存数据来源public  String load(){        return null;    }
System.out.println(cache.get("key1"));  //直接返回空
//--手动填充--Cache<String,Integer> cache2 = Caffeine.newBuilder().build();//先从缓存中查询，1.缓存中能找到，直接返回，2.找不到调用自定义的方法返回        Integer age2 = cache2.get("张三",k->{    //在实际业务中这里可以把我们代码中的mapper传入进去，进行数据源的刷新。       return 18;});System.out.println(age2);
//--异步手动填充--AsyncCache<String, Integer> cache = Caffeine.newBuilder().buildAsync();
//会返回一个 future对象， 调用future对象的get方法会一直卡住直到得到返回，和多线程的submit一样CompletableFuture<Integer> ageFuture = cache.get("张三", name -> {      System.out.println("name:" + name);      return 18;});        Integer age = ageFuture.get();System.out.println("age:" + age);

//基于设置的内存大小清除缓存 Cache<String, String> cache5 = Caffeine.newBuilder().maximumSize(1)                .build();cache5.put("测试1", "test1");cache5.put("测试2", "test2");cache5.cleanUp();System.out.println(cache5.getIfPresent("测试1"));System.out.println(cache5.getIfPresent("测试2"));

Cache<String,String> cache6 = Caffeine.newBuilder().maximumSize(1).                expireAfterWrite(2,TimeUnit.MINUTES)                .build();        cache6.put("test1","1");        Thread.sleep(1*1000);        System.out.println(cache.getIfPresent("test1"));  //还存在值        Thread.sleep(1*1000);        System.out.println(cache.getIfPresent("test1")); //缓存过期，返回null        Thread.sleep(1*1000);        System.out.println(cache.getIfPresent("test1")); //缓存过期，返回null
最后的结果：在第二次时打印null

Cache<String, String> cache7 =  Caffeine.newBuilder()                // 最大容量为1                .maximumSize(1)                .expireAfterAccess(2, TimeUnit.SECONDS) //设置2秒后无访问引用过期                .build();        cache7.put("1","test1");        Thread.sleep(1*1000);        System.out.println(cache7.getIfPresent("1")); //线程等待1秒后访问，返回test1        Thread.sleep(1*1000);        System.out.println(cache7.getIfPresent("1"));  //线程等待1秒后访问，返回test1        Thread.sleep(3001);        System.out.println(cache7.getIfPresent("1")); //线程等待3秒后超过过期时间且无访问，返回null

@PostConstruct    public void init() {        sellerIdAndParkCodeCache = Caffeine.newBuilder()                .refreshAfterWrite(5, TimeUnit.MINUTES) //5分钟更新                .build(key -> refreshCache());    }

redisTemplate.opsForValue();//操作字符串redisTemplate.opsForHash();//操作hashredisTemplate.opsForList();//操作listredisTemplate.opsForSet();//操作setredisTemplate.opsForZSet();//操作有序set

<dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-data-redis</artifactId></dependency>

@Servicepublic class RedisServiceImpl implements CacheService {    @Resource    private RedisTemplate<String, String> redisTemplate;
    //获取值--String类型    @Override    public String getFromString(String key) {        return redisTemplate.opsForValue().get(key);    }
    //设置值和对应的过期时间    @Override    public void setString(String key, String value, Long timeout) {        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);    }
    //删除    @Override    public boolean delString(String key) {        return redisTemplate.delete(key);    }
    //获取值--Hash类型    @Override    public void put(String HKey, String key, Object str) {        redisTemplate.opsForHash().put(HKey, key, str);    }	    //设置hash类型的值对应的过期时间    @Override    public void expire(String HKey, long time) {        redisTemplate.expire(HKey, time, TimeUnit.SECONDS);    }	//获取k为传入的key对应的值    @Override    public List<Object> values(String key) {        return redisTemplate.opsForHash().values(key);    }        //获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null。     @Override    public Object get(String Hkey, String key) {        return redisTemplate.opsForHash().get(Hkey, key);    }	    //设置值，如果不存在就设置    @Override    public boolean setKeyIfNotExist(String key, long timeSeconds) {        return redisTemplate.opsForValue().setIfAbsent(key, key, timeSeconds, TimeUnit.SECONDS);    }
    //set if not exists ,k不存在则新增传入的kv（且setnx返回1），存在就不会做操作（返回0），长用作分布式锁    /*如果 SETNX 返回1，说明该进程获得锁，SETNX将time的值设置为锁的超时时间（当前时间 + 锁的有效时间）。    如果 SETNX 返回0，说明其他进程已经获得了锁，进程不能进入临界区。进程可以在一个循环中不断地尝试 SETNX 操作，以获得锁*/    @Override    public Boolean setNX(String key, String value, Duration time) {        try {            return redisTemplate.opsForValue().setIfAbsent(key, value, time);        } catch (Exception ex) {            return false;        }    }
	//解锁，操作完后使用delete方式删除key    @Override    public void unlock(String key, String value) {        String currentValue = redisTemplate.opsForValue().get(key);        if (!StringUtils.isEmpty(currentValue) && currentValue.equals(value)) {            redisTemplate.opsForValue().getOperations().delete(key);        }    }