springboot整合redis与Spring Cache

@Cacheable 

主要是针对方法配置，能根据方法的请求参数对结果进行缓存

    @Cacheable(cacheNames = "user:",key = "#id",condition = "#id > 0")
    @Override
    public Suser selectByPrimaryKey(int id) {
        return userDao.selectByPrimaryKey(id);
    }

@Cacheable的参数：
cacheNames：缓存的名称，必须至少指定一个
key：缓存的关键字，可以为空，按照spEL表达式编写，如果为空则按照所有参数进行组合定义
condition：使用缓存的条件，可以为空，使用spEl表达式编写，结果为“true”才执行缓存，“false”则不缓存。
@CachePut

在Spring Cache中，在我们使用@Cacheable注解时，我们会先查找在缓存中是否存在该key的缓存，如果没有，会查找数据库数据并添加到缓存中，而我们在使用@CachePut注解时，无论在缓存中是否存在缓存，程序都会执行，并将查到的结果添加指定的缓存中。

 //@CachePut也可以标注在类上和方法上。使用@CachePut时我们可以指定的属性跟@Cacheable是一样的。
   @CachePut("user")//每次都会执行方法，并将结果存入指定的缓存中
   public User find(Integer id) {
      return null;
   }

@CacheEvict

@CacheEvict是用来标注在需要清除缓存元素的方法或类上的。当标记在一个类上时表示其中所有的方法的执行都会触发缓存的清除操作。@CacheEvict可以指定的属性有value、key、condition、allEntries和beforeInvocation。其中value、key和condition的语义与@Cacheable对应的属性类似。即value表示清除操作是发生在哪些Cache上的（对应Cache的名称）；key表示需要清除的是哪个key，如未指定则会使用默认策略生成的key；condition表示清除操作发生的条件。

@CacheEvit 的属性：
cachename：缓存的名称，至少指定一个

key：缓存的关键字，可以为空，按照spEL表达式编写，如果为空则按照所有参数进行组合定义

condition：使用缓存的条件，可以为空，使用spEl表达式编写，结果为“true”才执行清空缓存，“false”则不清空缓存。

allEntries：是否清空所有缓存，使用spEl表达式编写，当程序执行时，为true则全部清空缓存，false则不全部清空，缺省为false。
beforeInvocation：是否在程序执行前清空缓存，为true时则在程序执行前清空缓存，为false则不清空，缺省为false。

@Caching
@Caching注解可以让我一个类或方法上定义多个Spring cache相关的注解，其拥有三个属性：cacheable、put和evict，分别用于指定@Cacheable、@CachePut和@CacheEvict。

@Caching(cacheable = @Cacheable("user"), evict = { @CacheEvict("cache2"),
   @CacheEvict(value = "cache3", allEntries = true) })
   public User find(Integer id) {
      return null;
   }

    
        
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
        
            org.springframework.boot
            spring-boot-starter-cache
        

 redis:
    #超时时间
    timeout: 10000ms
    #服务器地址
    host: xxx
    #服务器端口
    port: 6379
    #数据库
    database: 0
    #密码
    password: xxx
    lettuce:
      pool:
        #最大连接数，默认8
        max-active: 1024
        #最大连接阻塞等待时间，默认-1
        max-wait: 10000ms
        #最大空闲连接
        max-idle: 200
        #最小空闲连接
        min-idle: 5

然后就是整合配置走起

RedisUtil

package com.yqs.utils;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;


@RequiredArgsConstructor
@Component
@SuppressWarnings({"unchecked", "all"})
@Slf4j
public class RedisUtil {

    private final RedisTemplate redisTemplate;

    // =============================common============================

    
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    
    public long getExpire(Object key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    
    public List scan(String pattern) {
        ScanOptions options = ScanOptions.scanOptions().match(pattern).build();
        RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
        RedisConnection rc = Objects.requireNonNull(factory).getConnection();
        Cursor cursor = rc.scan(options);
        List result = new ArrayList<>();
        while (cursor.hasNext()) {
            result.add(new String(cursor.next()));
        }
        try {
            RedisConnectionUtils.releaseConnection(rc, factory);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    
    public List findKeysForPage(String patternKey, int page, int size) {
        ScanOptions options = ScanOptions.scanOptions().match(patternKey).build();
        RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
        RedisConnection rc = Objects.requireNonNull(factory).getConnection();
        Cursor cursor = rc.scan(options);
        List result = new ArrayList<>(size);
        int tmpIndex = 0;
        int fromIndex = page * size;
        int toIndex = page * size + size;
        while (cursor.hasNext()) {
            if (tmpIndex >= fromIndex && tmpIndex < toIndex) {
                result.add(new String(cursor.next()));
                tmpIndex++;
                continue;
            }
            // 获取到满足条件的数据后,就可以退出了
            if (tmpIndex >= toIndex) {
                break;
            }
            tmpIndex++;
            cursor.next();
        }
        try {
            RedisConnectionUtils.releaseConnection(rc, factory);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    // ============================String=============================

    
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    
    public List