SpringBoot_Redis

第一步

• pom.xml 文件添加对应的架包

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

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.71</version>
    </dependency>

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>
</dependencies>

第二步

• 配置文件添加对应的配置

# 单机的配置
spring:
  redis:
    # Redis服务器地址
    host: 122.112.166.49
    # Redis服务器连接端口
    port: 6379
    # Redis数据库索引（默认为0）
    database: 1
    password: Galaxyeye01
    # 连接池最大连接数（使用负值表示没有限制）
    lettuce:
      pool:
        max-active: 50
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 3000
        # 连接池中的最大空闲连接
        max-idle: 20
        # 连接池中的最小空闲连接
        min-idle: 1000

# 集群的配置
spring:
    redis:
    #Redis服务器地址
    cluster:
      nodes: 172.16.3.231:6379,172.16.3.232:6379,172.16.3.233:6379
    #Redis服务器连接端口
    #port: 6379
    #Redis数据库索引（默认为0）
    database: 0
    password: galaxyeye
    #连接池最大连接数（使用负值表示没有限制）
    jedis:
      pool:
        #max-active: 50
        #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 3000
        #连接池中的最大空闲连接
        max-idle: 20
        #连接池中的最小空闲连接
        min-idle: 2
    #连接超时时间（毫秒）
    timeout: 5000

第三步

• 实现FastJson 的序列化

@Component
public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    public FastJsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return (T) JSON.parseObject(str, clazz);
    }
}

第四步

• 定义RedisConfig 配置类

@Configuration
@EnableCaching
public class RedisConfig {
    /**
     * 实例化 RedisTemplate 对象
     *
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<Object>(Object.class);
        redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setConnectionFactory(connectionFactory);
        // 设置白名单---非常重要********
        ParserConfig.getGlobalInstance().addAccept("com.example");
        return redisTemplate;
    }
}

第五步

• 定义IRedisService 的接口

@Component
public interface IRedisService {

    /**
         * 在字符串后边追加 字符串
         * @param key
         * @param appendValue
         * @return
         */
    <T> ValueOperations<String, T> append(String key, String appendValue);

    /**
         * 缓存基本的对象，Integer、String、实体类等
         * @param key      缓存的健值
         * @param value    缓存的值
         * @return         缓存的对象
         */
    <T> ValueOperations<String, T> setCacheObject(String key, T value);

    /**
         * 缓存基本的对象，Integer、String、实体类等
         * @param key      缓存的健值
         * @param value    缓存的值
         * @param timeout  时间
         * @param timeUnit 时间颗粒度
         * @return         缓存的对象
         */
    <T> ValueOperations<String, T> setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit);

    /**
         * 缓存基本的对象，Integer、String、实体类等
         * @param key      缓存的健值
         * @param value    缓存的值
         * @param timeout  时间
         * @return         缓存的对象
         */
    <T> ValueOperations<String, T> setCacheObject(String key, T value, Duration timeout);

    /**
         * 获得缓存的基本对象。
         *
         * @param key 缓存键值
         * @return 缓存键值对应的数据
         */
    <T> T getCacheObject(String key);

    /**
         * 设置过期时间
         * @param key           key值
         * @param timeout       时间
         * @param timeUnit      时间单位
         * @return
         */
    Boolean setExpire(String key, Long timeout, TimeUnit timeUnit);

    /**
         * 删除单个对象
         * @param key
         */
    void deleteObject(String key);

    /**
         * 删除集合对象
         * @param collection
         */
    void deleteObject(Collection collection);

    /**
         * 缓存List数据
         *
         * @param key      缓存的键值
         * @param dataList 待缓存的List数据
         * @return         缓存的对象
         */
    <T> ListOperations<String, T> setCacheList(String key, List<T> dataList);

    /**
         * 获得缓存的list对象
         *
         * @param key 缓存的键值
         * @return 缓存键值对应的数据
         */
    <T> List<T> getCacheList(String key);

    /**
         * 缓存Set
         *
         * @param key     缓存键值
         * @param dataSet 缓存的数据
         * @return 缓存数据的对象
         */
    <T> BoundSetOperations<String, T> setCacheSet(String key, Set<T> dataSet);

    /**
         * 获得缓存的set
         *
         * @param key
         * @return
         */
    <T> Set<T> getCacheSet(String key);

    /**
         * 缓存Map
         *
         * @param key
         * @param dataMap
         * @return
         */
    void hashPutAll(String key, Map<String, Object> dataMap);

    /**
         * 在hash中新增一个值
         * @param key
         * @param field
         * @param value
         */
    void hashPut(String key, String field, Object value);

    /**
         * 当field不存在时put
         * @param key
         * @param field
         * @param value
         */
    void hashPutIfAbsent(String key, String field, Object value);

    /**
         * 获得缓存的Map
         *
         * @param key
         */
    Map<String, Object> hashGetAll(String key);

    /**
         * 获取键值为key的hash中的field字段的值
         * @param key
         * @param field
         */
    Object hashGet(String key, String field);

    /**
         * 获取键值为key的hash表中所有字段
         * @param key
         */
    Set<String> hashKeys(String key);

    /**
         * 获取键值为key的hash表中所有value
         * @param key
         */
    List<Object> hashValues(String key);

    /**
         * 给hash表中指定字段（整形）增加increment
         */
    Long hashIncrement(String key, String field, long increment);

    /**
         * 给hash表中指定字段（Double）增加increment
         */
    Double hashIncrement(String key, String field, double increment);

    /**
         * 判断hashKey是否存在
         * @param key
         * @param hashKey
         * @return 存在返回true，不存在返回false
         */
    Boolean hasKey(String key, String hashKey);

    /**
         * 根据key删除一个或多个字段
         * @param key
         * @param fields
         */
    void hashDelete(String key, String... fields);

    /**
         * 获得缓存的基本对象列表
         *
         * @param pattern 字符串前缀
         * @return 对象列表
         */
    Collection<String> keys(String pattern);

    /**
         * 自增
         * @param key
         * @return     自增后的值
         */
    Long increment(String key);

    /**
         * 自增 num
         * @param key
         * @return   自增后的值
         */
    Long increment(String key, long num);

    /**
         * 返回RedisTemplate
         *
         * @return RedisTemplate
         */
    RedisTemplate getRedisTemplate();

    /**
         * 执行lua脚本，返回执行结果
         * @param redisScript
         * @param key
         * @param value
         * @return
         */
    Object execute(DefaultRedisScript redisScript, String key, Object value);
}

第六步

• 实现IRedisService 的接口

@Service
public class RedisServiceImpl implements IRedisService {

    @Resource
    private RedisTemplate redisTemplate;

    /**
         * 在字符串后边追加 字符串
         * @param key
         * @param appendValue
         * @return
         */
    public <T> ValueOperations<String, T> append(String key, String appendValue) {
        ValueOperations<String, T> operations = this.redisTemplate.opsForValue();
        operations.append(key, appendValue);
        return operations;
    }

    /**
         * 缓存基本的对象，Integer、String、实体类等
         * @param key      缓存的健值
         * @param value    缓存的值
         * @return         缓存的对象
         */
    public <T> ValueOperations<String, T> setCacheObject(String key, T value) {
        ValueOperations<String, T> operations = this.redisTemplate.opsForValue();
        operations.set(key, value);
        return operations;
    }

    /**
         * 缓存基本的对象，Integer、String、实体类等
         * @param key      缓存的健值
         * @param value    缓存的值
         * @param timeout  时间
         * @param timeUnit 时间颗粒度
         * @return         缓存的对象
         */
    public <T> ValueOperations<String, T> setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit) {
        ValueOperations<String, T> operations = this.redisTemplate.opsForValue();
        operations.set(key, value, timeout, timeUnit);
        return operations;
    }

    /**
         * 缓存基本的对象，Integer、String、实体类等
         * @param key      缓存的健值
         * @param value    缓存的值
         * @param timeout  时间
         * @return         缓存的对象
         */
    public <T> ValueOperations<String, T> setCacheObject(String key, T value, Duration timeout) {
        ValueOperations<String, T> operations = this.redisTemplate.opsForValue();
        operations.set(key, value, timeout);
        return operations;
    }

    /**
         * 获得缓存的基本对象。
         *
         * @param key 缓存键值
         * @return 缓存键值对应的数据
         */
    public <T> T getCacheObject(String key) {
        ValueOperations<String, T> operation = this.redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
         * 设置过期时间
         * @param key           key值
         * @param timeout       时间
         * @param timeUnit      时间单位
         * @return
         */
    public Boolean setExpire(String key, Long timeout, TimeUnit timeUnit) {
        return this.redisTemplate.expire(key, timeout, timeUnit);
    }

    /**
         * 删除单个对象
         * @param key
         */
    public void deleteObject(String key) {
        this.redisTemplate.delete(key);
    }

    /**
         * 删除集合对象
         * @param collection
         */
    public void deleteObject(Collection collection) {
        this.redisTemplate.delete(collection);
    }

    /**
         * 缓存List数据
         *
         * @param key      缓存的键值
         * @param dataList 待缓存的List数据
         * @return         缓存的对象
         */
    public <T> ListOperations<String, T> setCacheList(String key, List<T> dataList) {
        ListOperations listOperations = this.redisTemplate.opsForList();
        if (null != listOperations) {
            int size = dataList.size();
            for (int i = 0; i < size; i++) {
                listOperations.leftPush(key, dataList.get(i));
            }
        }
        return listOperations;
    }

    /**
         * 获得缓存的list对象
         *
         * @param key 缓存的键值
         * @return 缓存键值对应的数据
         */
    public <T> List<T> getCacheList(String key) {
        List<T> dataList = new ArrayList<>();
        ListOperations<String, T> listOperations = this.redisTemplate.opsForList();
        Long size = listOperations.size(key);
        for (long i = 0; i < size; i++) {
            dataList.add(listOperations.index(key, i));
        }
        return dataList;
    }

    /**
         * 缓存Set
         *
         * @param key     缓存键值
         * @param dataSet 缓存的数据
         * @return 缓存数据的对象
         */
    public <T> BoundSetOperations<String, T> setCacheSet(String key, Set<T> dataSet) {
        BoundSetOperations<String, T> setOperations = this.redisTemplate.boundSetOps(key);
        Iterator<T> iterable = dataSet.iterator();
        while (iterable.hasNext()) {
            setOperations.add(iterable.next());
        }
        return setOperations;
    }

    /**
         * 获得缓存的set
         *
         * @param key
         * @return
         */
    public <T> Set<T> getCacheSet(String key) {
        Set<T> dataSet = new HashSet<>();
        BoundSetOperations<String, T> setOperations = this.redisTemplate.boundSetOps(key);
        Long size = setOperations.size();
        for (long i = 0; i < size; i++) {
            dataSet.add(setOperations.pop());
        }
        return dataSet;
    }

    /**
         * 缓存Map
         *
         * @param key
         * @param dataMap
         * @return
         */
    public void hashPutAll(String key, Map<String, Object> dataMap) {
        this.redisTemplate.opsForHash().putAll(key, dataMap);
    }

    /**
         * 在hash中新增一个值
         * @param key
         * @param field
         * @param value
         */
    public void hashPut(String key, String field, Object value) {
        this.redisTemplate.opsForHash().put(key, field, value);
    }

    /**
         * 当field不存在时put
         * @param key
         * @param field
         * @param value
         */
    public void hashPutIfAbsent(String key, String field, Object value) {
        this.redisTemplate.opsForHash().putIfAbsent(key, field, value);
    }

    /**
         * 获得缓存的Map
         *
         * @param key
         */
    public Map<String, Object> hashGetAll(String key) {
        return this.redisTemplate.opsForHash().entries(key);
    }

    /**
         * 获取键值为key的hash中的field字段的值
         * @param key
         * @param field
         */
    public Object hashGet(String key, String field) {
        return this.redisTemplate.opsForHash().get(key, field);
    }

    /**
         * 获取键值为key的hash表中所有字段
         * @param key
         */
    public Set<String> hashKeys(String key) {
        return this.redisTemplate.opsForHash().keys(key);
    }

    /**
         * 获取键值为key的hash表中所有value
         * @param key
         */
    public List<Object> hashValues(String key) {
        return this.redisTemplate.opsForHash().values(key);
    }

    /**
         * 给hash表中指定字段（整形）增加increment
         */
    public Long hashIncrement(String key, String field, long increment) {
        return this.redisTemplate.opsForHash().increment(key, field, increment);
    }

    /**
         * 给hash表中指定字段（Double）增加increment
         */
    public Double hashIncrement(String key, String field, double increment) {
        return this.redisTemplate.opsForHash().increment(key, field, increment);
    }

    /**
         * 判断hashKey是否存在
         * @param key
         * @param hashKey
         * @return 存在返回true，不存在返回false
         */
    public Boolean hasKey(String key, String hashKey) {
        return this.redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
         * 根据key删除一个或多个字段
         * @param key
         * @param fields
         */
    public void hashDelete(String key, String... fields) {
        this.redisTemplate.opsForHash().delete(key, fields);
    }

    /**
         * 获得缓存的基本对象列表
         *
         * @param pattern 字符串前缀
         * @return 对象列表
         */
    public Collection<String> keys(String pattern) {
        return this.redisTemplate.keys(pattern);
    }

    /**
         * 自增
         * @param key
         * @return     自增后的值
         */
    public Long increment(String key) {
        return this.redisTemplate.opsForValue().increment(key);
    }

    /**
         * 自增 num
         * @param key
         * @return   自增后的值
         */
    public Long increment(String key, long num) {
        return this.redisTemplate.opsForValue().increment(key, num);
    }

    /**
         * 返回RedisTemplate
         *
         * @return RedisTemplate
         */
    public RedisTemplate getRedisTemplate() {
        return this.redisTemplate;
    }

    /**
         * 执行lua脚本，返回执行结果
         * @param redisScript
         * @param key
         * @param value
         * @return
         */
    public Object execute(DefaultRedisScript redisScript, String key, Object value) {
        return this.redisTemplate.execute(redisScript, Arrays.asList(key), value);
    }
}

第七步

• Controller层使用

@RestController
public class RedisController {

    @Resource
    private IRedisService redisService;

    @PostMapping("getRedis/01")
    public String getRedis_01(String message) {

        /**
         * 获取这个参数为 key 的缓存数据
         * 这里实际的操作的时候，需要判断缓存数据是否存在，然后根据不同的情况做不同的业务操作
         */
        Object cacheObject = redisService.getCacheObject(message);
        if (ObjectUtils.isNotEmpty(cacheObject)) {

        } else {

        }

        /**
         * 最后业务执行完，需要在缓存里设置数据，第一个参数为对应的 key 值，第二个参数为对应的值
         */
        redisService.setCacheObject(message, message);

        return "success";
    }
}