1、在pom文件中引入Redis依賴

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

2、在配置文件中添加redis配置信息

## Redis默認(rèn)密碼是空，此處僅配置
spring:
    redis:
       host: 127.0.0.1
       port: 6379
       password:
       pool:
           # 連接池最大連接數(shù)
           max-active: 8
           # 連接池最大阻塞等待時間
           max-wait: -1
           # 連接池中的最大空閑連接
           max-idle: 8
           # 連接池中的最小空閑連接
           min-idle: 0
           # 連接超時時間(毫秒)
           timeout: 0

3、添加cache配置類

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 使用TRedisCacheManager作為緩存管理器
     * @param redisTemplate
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
        RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate);
        // redisCacheManager.setDefaultExpiration(6); //設(shè)置默認(rèn)的過期時間
        Map<String, Long> map = new HashMap<>();
        // 主要針對不同緩存的不同過期時間，結(jié)合@Cacheable(value="oauth")使用，但經(jīng)常會不起作用，建議緩存時再次指定
        map.put("oauth", 6L);
        redisCacheManager.setExpires(map);
        return redisCacheManager;
    }

    /**
     * RedisTemplate配置
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        // 定義value的序列化方式
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        // ObjectMapper類是Jackson庫的主要類，用于將Java對象匹配JSON結(jié)構(gòu)
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 如果key是String，需要配置一下StringSerializer,不然key會亂碼 /XX/XX
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

4、新建Redis工具類

@SuppressWarnings("unchecked")
@Component
public class RedisComponentUtil<T> {
    @SuppressWarnings("rawtypes")
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 批量刪除對應(yīng)的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量刪除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }

    /**
     * 刪除對應(yīng)的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判斷緩存中是否有對應(yīng)的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 讀取緩存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 寫入緩存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 寫入緩存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

5、自動根據(jù)方法生成緩存

@Slf4j
@CacheConfig(cacheNames = "phoneUser")
public abstract class BaseServiceImpl<T, C, M extends BaseMapper<T, C>> implements BaseService<T, C> {
    @Autowired
    private M mapper;

    @CacheEvict(key = "'userCache'")
    @Override
    public int deleteRecord(Object id) {
        log.info("我是從數(shù)據(jù)庫刪除記錄");
        return mapper.deleteRecord(id);
    }

    @CachePut(key = "'userCache'")
    @Override
    public void updateRecord(T po) {
        log.info("我是從數(shù)據(jù)庫更新數(shù)據(jù)");
        mapper.updateRecord(po);
    }

    @Cacheable(key = "'userCache'")
    @Override
    public T selectRecord(C c) {
        log.info("我是從數(shù)據(jù)庫查詢數(shù)據(jù)");
        return mapper.selectRecord(c);
    }
}

/**
 * @CacheConfig(cacheNames="phoneUser")注解指的是該類中的緩存的名稱是phoneUser
 * @CachePut(key="'userCache'")中的userCache要加上''單引號，表示是一個字符串
 * @Cacheable能夠根據(jù)方法的請求參數(shù)對起結(jié)果進行緩存（緩存的是方法的返回結(jié)果），一般用于insert操作
 * @CachePut(key="'userCache'")主要針對方法配置，能夠根據(jù)方法的請求參數(shù)對其結(jié)果進行緩存，和@Cacheable
 * 不同的是它每次都會觸發(fā)真實方法的調(diào)用，一般用于update()操作
 * @CacheEvict(key="'usercache'")主要針對方法的配置，能夠根據(jù)一定的條件對緩存進行清空，一般用于delete()操作
 */