SpringBoot 2.2.5 整合Redis，并配置Spri

前言：该博客主要是记录自己学习的过程，方便以后查看，当然也希望能够帮到大家。

说明

一个系统在于数据库交互的过程中，内存的速度远远快于硬盘速度，当我们重复地获取相同数据时，我们一次又一次地请求数据库或远程服务，者无疑时性能上地浪费，这会导致大量时间被浪费在数据库查询或者远程方法调用上致使程序性能恶化，于是有了“缓存”。

完整代码地址在结尾！！

第一步，在pom.xml加入依赖，如下

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

<!-- Jackson 工具 -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.10.2</version>
</dependency>

第二步，在application.yml配置文件配置redis

spring:
  redis:
    database: 0 # redis 数据库索引（默认为0）
    host: xxx # ip地址
    password: xxx # redis 服务器连接密码（默认为空）
    port: 6379
    timeout: 12000  # 连接超时时间（毫秒），默认2000ms
    # cluster:
    # nodes: xxx:7000,xxx:7001,xxx:7002
    # maxRedirects: 6
    jedis:
      pool:
        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 8 # 连接池中的最大空闲连接
        min-idle: 0 # 连接池中的最小空闲连接
  cache:
    redis:
      # 过期时间（毫秒）。默认情况下，永不过期。
      time-to-live: 1d
      # 写入redis时是否使用键前缀。
      use-key-prefix: true
  application:
    name: redis-demo-server

server:
  port: 8095

第三步，由于RedisTemplate 默认的序列化方式为 JdkSerializeable，StringRedisTemplate的默认序列化方式为StringRedisSerializer，使用客户端查看的时候会乱码，修改序列化方式解决该问题，创建RedisConfig配置类

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @Description: redistemplate 配置
 * @Author: luoyu
 * @Date: 2020/1/15 11:20
 * @Version: 1.0.0
 */
@Configuration
@EnableCaching
public class RedisConfig {

    /**
     * @author  luoyu
     * @description redisTemplate 序列化使用的jdkSerializeable, 存储二进制字节码, 所以自定义序列化类
     * @param redisConnectionFactory
     * @return RedisTemplate<Object, Object>
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常，保留这行会报错：Unexpected token (VALUE_STRING)
//        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }

    @Bean
    public RedisCacheManager redisCacheManager(RedisTemplate redisTemplate) {
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisTemplate.getConnectionFactory());
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getValueSerializer()));
        return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
    }

    /**
     * 二者选其一即可
     */
//    @Bean
//    public RedisCacheConfiguration redisCacheConfiguration() {
//        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
//        ObjectMapper objectMapper = new ObjectMapper();
//        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
          // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常，保留这行会报错：Unexpected token (VALUE_STRING)
//        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
//        serializer.setObjectMapper(objectMapper);
//        return RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer));
//    }

}

第四步，直接用RedisTemplate操作redis比较麻烦，因此直接封装好一个RedisUtils工具类（本人在网上找到的比较完善的），这样写代码更方便点。这个RedisUtils交给spring容器管理，使用时直接注入使用即可

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/*
 * @Description: Redis工具类，基于spring和redis的redisTemplate工具类。针对所有的hash，都是以h开头的方法。
 * 针对所有的Set，都是以s开头的方法。不含通用方法。针对所有的List，都是以l开头的方法
 * @Author: luoyu
 * @Date: 2020/1/15 11:20
 * @Version: 1.0.0
 */
@Component
@Slf4j
public class RedisUtils {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    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=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 递增 适用场景： https://blog.csdn.net/y_y_y_k_k_k_k/article/details/79218254 高并发生成订单号，秒杀类的业务逻辑等。。
     * @param key 键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * @param key 键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================Map=================================
    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param by 要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            log.error(key, e);
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    // ============================zset=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> zSGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            log.error(key, e);
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean zSHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    public Boolean zSSet(String key, Object value, double score) {
        try {
            return redisTemplate.opsForZSet().add(key, value, 2);
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long zSSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long zSGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long zSetRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }
    // ===============================list=================================

    /**
     * 获取list缓存的内容
     * 取出来的元素 总数 end-start+1
     * @param key 键
     * @param start 开始 0 是第一个元素
     * @param end 结束 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            log.error(key, e);
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            log.error(key, e);
            return null;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

}

第五步，编写单元测试类，RedisApplicationTests，并进行测试，只列举了部分方法，至此springboot整合redis完成。

import com.luoyu.redis.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import javax.annotation.Resource;

@Slf4j
// 获取启动类，加载配置，确定装载 Spring 程序的装载方法，它回去寻找 主配置启动类（被 @SpringBootApplication 注解的）
@SpringBootTest
class RedisApplicationTests {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private RedisUtil redisUtil;

    @Test
    void redisTemplateSetStringTest() {
        redisTemplate.opsForValue().set("a","c");
    }

    @Test
    void redisTemplateGetStringTest() {
        log.info(redisTemplate.opsForValue().get("a").toString());
    }

    @Test
    void redisUtilDeteleStringTest() {
        redisTemplate.delete("a");
    }

    @Test
    void redisUtilGetStringTest() {
        log.info(redisUtil.get("a").toString());
    }

    @BeforeEach
    void testBefore(){
        log.info("测试开始!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    }

    @AfterEach
    void testAfter(){
        log.info("测试结束!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    }

}

第六步，开始整合SpringCache缓存功能，编写服务类，Test，TestService，TestServiceImpl，如下

Test

import lombok.Data;

import java.io.Serializable;

@Data
public class Test implements Serializable {

    private String id;
    private String name;
    private int age;
    private String sex;

}

TestService

import com.luoyu.redis.entity.Test;

public interface TestService {

    Test get(String id);

    boolean add(Test test);

    boolean delete(String id);

    boolean update(Test test);

}

TestServiceImpl

import com.luoyu.redis.entity.Test;
import com.luoyu.redis.service.TestService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class TestServiceImpl implements TestService {

    @Override
    public Test get(String id) {
        log.info("没有使用缓存，创建一个新对象返回，并设置到缓存");

        Test test = new Test();
        test.setId(id);
        test.setName("测试name");
        test.setAge(12);
        test.setSex("男");

        return test;
    }

    @Override
    public boolean add(Test test) {
        log.info("创建id为：" + test.getId() + "的对象存起来，并设置到缓存，对象为：" + test.toString());

        return true;
    }

    @Override
    public boolean delete(String id) {
        log.info("删除id为：" + id + "的对象，并从缓存中删除");

        return true;
    }

    @Override
    public boolean update(Test test) {
        log.info("更新id为：" + test.getId() + "的对象，并更新到缓存，新对象为：" + test.toString());

        return true;
    }

}

第七步，编写TestController类，如下

import com.luoyu.redis.entity.Test;
import com.luoyu.redis.service.TestService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.*;

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {

    @Autowired
    private TestService testService;

    /**
     * 查询一个对象并返回
     *
     * @return
     */
    @GetMapping("/get")
    @Cacheable(value = "redis.test.key:", key = "#id")
    public Test get(@RequestParam(required = true) String id) {
        log.info("查询一个对象并返回");
        return testService.get(id);
    }

    /**
     * 删除一个对象
     *
     * @return
     */
    @DeleteMapping("/delete")
    @CacheEvict(value = "redis.test.key:", key = "#id")
    public boolean delete(@RequestParam(required = true) String id) {
        log.info("删除一个对象");
        return testService.delete(id);
    }

    /**
     * 新增一个对象
     *
     * @return
     */
    @PostMapping("/add")
    @Cacheable(value = "redis.test.key:", key = "#test.getId()")
    public Test add(@RequestBody Test test) {
        log.info("新增一个对象，结果：" + testService.add(test));
        return test;
    }

    /**
     * 更新一个对象
     *
     * @return
     */
    @PutMapping("/update")
    @CachePut(value = "redis.test.key:", key = "#test.getId()")
    public Test update(@RequestBody Test test) {
        log.info("更新一个对象，结果：" + testService.update(test));
        return test;
    }

}

第八步，使用postman工具调api接口

1. 通过查看控制台日志打印情况，可得出整合SpringCache缓存功能成功，本文只做简单的操作方式，如需复杂使用方式，请自行百度查询

第九步，各种注解使用方式说明，如下

注解说明

1. @Cacheable：触发缓存写入。
2. @CacheEvict：触发缓存清除。
3. @CachePut：更新缓存(不会影响到方法的运行)。
4. @Caching：重新组合要应用于方法的多个缓存操作。
5. @CacheConfig：设置类级别上共享的一些常见缓存设置。

@Cacheable/@CachePut/@CacheEvict等注解的主要参数

名称	解释	示例
value	缓存的名称，在 spring 配置文件中定义，必须指定至少一个	@Cacheable(value=”mycache”) 或者@Cacheable(value={”cache1”,”cache2”})
key	缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合	@Cacheable(value=”testcache”,key=”#id”)
condition	缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存/清除缓存	@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
unless	否定缓存。当条件结果为TRUE时，就不会缓存	@Cacheable(value=”testcache”,unless=”#userName.length()>2”)
allEntries(@CacheEvict )	是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存	@CachEvict(value=”testcache”,allEntries=true)
beforeInvocation(@CacheEvict)	是否在方法执行前就清空，缺省为 false，如果指定为 true，则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法执行抛出异常，则不会清空缓存	@CachEvict(value=”testcache”，beforeInvocation=true)

SpEL上下文数据说明

名称	位置	描述	示例
methodName	root对象	当前被调用的方法名	#root.methodname
method	root对象	当前被调用的方法	#root.method.name
target	root对象	当前被调用的目标对象实例	#root.target
targetClass	root对象	当前被调用的目标对象的类	#root.targetClass
args	root对象	当前被调用的方法的参数列表	#root.args[0]
caches	root对象	当前方法调用使用的缓存列表	#root.caches[0].name
Argument Name	执行上下文	当前被调用的方法的参数，如findArtisan(Artisan artisan),可以通过#artsian.id获得参数	#artsian.id
result	执行上下文	方法执行后的返回值（仅当方法执行后的判断有效，如 unless cacheEvict的beforeInvocation=false）	#result

注意：

1. 当我们要使用root对象的属性作为key时我们也可以将“#root”省略，因为Spring默认使用的就是root对象的属性。 如@Cacheable(key = "targetClass + methodName +#p0")
2. 使用方法参数时我们可以直接使用“#参数名”或者“#p参数index”。 如：@Cacheable(value="users", key="#id")，@Cacheable(value="users", key="#p0")

SpEL提供了多种运算符

类型	运算符
关系	<，>，<=，>=，==，!=，lt，gt，le，ge，eq，ne
算术	+，- ，* ，/，%，^
逻辑	&&，||，!，and，or，not，between，instanceof
条件	?: (ternary)，?: (elvis)
正则表达式	matches
其他类型	?.，?[…]，![…]，^[…]，$[…]

第十步，开始使用Pipelined管道进行批量操作

Redis是采用基于C/S模式的请求/响应协议的TCP服务器。

性能问题1：redis客户端发送多条请求，后面的请求需要等待前面的请求处理完后，才能进行处理，而且每个请求都存在往返时间RRT（Round Trip Time），即使redis性能极高，当数据量足够大，也会极大影响性能，还可能会引起其他意外情况。
性能问题2：上面的性能问题1我们可以通过scan命令来解决，如何来设置count又是一个问题，设置不好，同样会有大量请求存在，即使设置到1w(推荐最大值)，如果扫描的数据量太大，这个问题同样不能避免。每个请求都会经历三次握手、四次挥手，在处理大量连接时，处理完后，挥手会产生大量time-wait，如果该服务器提供其他服务，可能对其他服务造成影响。
然而，使用Pipeline可以解决以上问题。具体使用方法如下。

新增工具类JsonUtils，MapUtils，如下

JsonUtils

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * JsonUtils
 *
 * @author luoyu
 * @date 2018/10/08 19:13
 * @description Json工具类，依赖jackson
 */
@Slf4j
public class JsonUtils {

    private static final ObjectMapper objectMapper;

    static {
        objectMapper = new ObjectMapper();
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * object转换成json
     */
    public static <T>String objectToJson(T obj){
        if(obj == null){
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
        } catch (Exception e) {
            log.error("object转换成json失败：", e);
            return null;
        }
    }

    /**
     * json转换成object
     */
    public static <T>T jsonToObject(String src, Class<T> clazz){
        if(StringUtils.isEmpty(src) || clazz == null){
            return null;
        }
        try {
            return clazz.equals(String.class) ? (T) src : objectMapper.readValue(src, clazz);
        } catch (Exception e) {
            log.error("json转换成object失败：", e);
            return null;
        }
    }

    /**
     * json转换成map
     */
    public static <T>Map<String, Object> jsonToMap(String src) {
        if(StringUtils.isEmpty(src)){
            return null;
        }
        try {
            return objectMapper.readValue(src, Map.class);
        } catch (Exception e) {
            log.error("json转换成map失败：", e);
            return null;
        }
    }

    /**
     * json转换成list
     */
    public static <T>List<T> jsonToList(String jsonArrayStr, Class<T> clazz) {
        try{
            JavaType javaType = objectMapper.getTypeFactory().constructParametricType(ArrayList.class, clazz);
            return objectMapper.readValue(jsonArrayStr, javaType);
        }catch (Exception e) {
            log.error("json转换成list失败：", e);
            return null;
        }
    }

}

MapUtils

import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;

/**
 * MapUtils
 *
 * @author luoyu
 * @date 2018/10/22 19:38
 * @description Map工具类
 */
@Slf4j
public class MapUtils extends HashMap<String, Object> {

    @Override
    public MapUtils put(String key, Object value) {
        super.put(key,value);
        return this;
    }

    /**
     * object转换成map
     */
    public static <T>Map<String, Object> objectToMap(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            Field[] fields = obj.getClass().getDeclaredFields();
            Map<String, Object> map = new HashMap<>();
            for (Field field : fields) {
                field.setAccessible(true);
                map.put(field.getName(), field.get(obj));
            }
            return map;
        } catch (Exception e) {
            log.error("object转换成map失败：", e);
            return null;
        }
    }

    /**
     * map转换成object
     */
    public static <T>T mapToObject(Map<String, Object> map, Class<T> clazz) {
        if (map == null) {
            return null;
        }
        try {
            T obj = clazz.newInstance();
            Field[] fields = obj.getClass().getDeclaredFields();
            for (Field field : fields) {
                int mod = field.getModifiers();
                if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                    continue;
                }
                field.setAccessible(true);
                field.set(obj, map.get(field.getName()));
            }
            return obj;
        } catch (Exception e) {
            log.error("map转换成object失败：", e);
            return null;
        }
    }

}

第十一步，修改TestService，TestServiceImpl添加方法，如下

TestService

import com.luoyu.redis.entity.Test;

import java.util.List;

public interface TestService {

    Test get(String id);

    boolean add(Test test);

    boolean delete(String id);

    boolean update(Test test);

    List<Test> gets();

    void sets(List<Test> tests);

    void deletes();

}

TestServiceImpl

import com.luoyu.redis.entity.Test;
import com.luoyu.redis.service.TestService;
import com.luoyu.redis.util.JsonUtils;
import com.luoyu.redis.util.MapUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;

@Slf4j
@Service
public class TestServiceImpl implements TestService {
    
    @Autowired
    private RedisTemplate redisTemplate;

    private static final String PIPELINED_KEY = "pipelined:";

    @Override
    public Test get(String id) {
        log.info("没有使用缓存，创建一个新对象返回，并设置到缓存");

        Test test = new Test();
        test.setId(id);
        test.setName("测试name");
        test.setAge(12);
        test.setSex("男");

        return test;
    }

    @Override
    public boolean add(Test test) {
        log.info("创建id为：" + test.getId() + "的对象存起来，并设置到缓存，对象为：" + test.toString());
        return true;
    }

    @Override
    public boolean delete(String id) {
        log.info("删除id为：" + id + "的对象，并从缓存中删除");
        return true;
    }

    @Override
    public boolean update(Test test) {
        log.info("更新id为：" + test.getId() + "的对象，并更新到缓存，新对象为：" + test.toString());
        return true;
    }

    @Override
    public List<Test> gets() {
        // 获取指定key的所有hashKey
        Set<String> testSet = redisTemplate.keys(PIPELINED_KEY + "*");
        if (CollectionUtils.isEmpty(testSet)) {
            return Collections.emptyList();
        }
        // 根据hashKey依次获取所有value
        List<Map> mapList = redisTemplate.executePipelined((RedisCallback<Map>) connection -> {
            if (!CollectionUtils.isEmpty(testSet)) {
                for (String item : testSet) {
                    connection.get((item).getBytes());
                }
            }
            return null;
        });

        List<Test> testList = new ArrayList<>();
        mapList.forEach(mapListItem -> {
            Test test = MapUtils.mapToObject(mapListItem, Test.class);
            testList.add(test);
        });

        return testList;
    }

    @Override
    public void sets(List<Test> tests) {
        redisTemplate.executePipelined((RedisCallback) connection -> {
            if (!CollectionUtils.isEmpty(tests)) {
                for (Test item : tests) {
                    connection.set((PIPELINED_KEY + item.getId()).getBytes(), JsonUtils.objectToJson(item).getBytes(), Expiration.seconds(1000), RedisStringCommands.SetOption.UPSERT);
                }
            }
            return null;
        });
    }

    @Override
    public void deletes() {
        // 获取指定key的所有hashKey
        Set<String> testSet = redisTemplate.keys(PIPELINED_KEY + "*");
        if (CollectionUtils.isEmpty(testSet)) {
            return;
        }
        redisTemplate.executePipelined((RedisCallback) connection -> {
            if (!CollectionUtils.isEmpty(testSet)) {
                for (String item : testSet) {
                    connection.del((item).getBytes());
                }
            }
            return null;
        });
    }

}

第十二步，修改单元测试类，RedisApplicationTests，添加新测试方法并进行测试，如下

import com.luoyu.redis.service.TestService;
import com.luoyu.redis.util.RedisUtils;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@Slf4j
// 获取启动类，加载配置，确定装载 Spring 程序的装载方法，它回去寻找 主配置启动类（被 @SpringBootApplication 注解的）
@SpringBootTest
class RedisApplicationTests {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private TestService testService;

    @Autowired
    private RedisUtils redisUtils;

    @Test
    void redisTemplateSetStringTest() {
        redisTemplate.opsForValue().set("a","c");
    }

    @Test
    void redisTemplateGetStringTest() {
        log.info(redisTemplate.opsForValue().get("a").toString());
    }

    @Test
    void redisUtilDeteleStringTest() {
        redisTemplate.delete("a");
    }

    @Test
    void redisUtilGetStringTest() {
        log.info(redisUtils.get("a").toString());
    }

    @Test
    void redisTemplatePipelinedGetTest() {
        testService.gets().forEach(x -> log.info(x.toString()));
    }

    @Test
    void redisTemplatePipelinedSetTest() {
        List<com.luoyu.redis.entity.Test> testList = new ArrayList<>();
        for (int i = 0; i < 500; i++) {
            com.luoyu.redis.entity.Test test = new com.luoyu.redis.entity.Test();
            test.setId(i + "");
            test.setAge(i * i);
            test.setName("name" + i);
            test.setSex("sex" + i);
            testList.add(test);
        }
        testService.sets(testList);
    }

    @Test
    void redisTemplatePipelinedDeleteTest() {
        testService.deletes();
    }

    @BeforeEach
    void testBefore(){
        log.info("测试开始!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    }

    @AfterEach
    void testAfter(){
        log.info("测试结束!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    }

}

完整代码地址：https://github.com/Jinhx128/springboot-demo

注：此工程包含多个module，本文所用代码均在redis-demo模块下

后记：本次分享到此结束，本人水平有限，难免有错误或遗漏之处，望大家指正和谅解，欢迎评论留言。