springboot集成redis缓存

        redis是一款完全基于内存的K-V数据库，由于其基于内存，因此有着极高的性能，根据redis官方给出的资料，redis的可支持的并发高达6000/s，而且，redis支持丰富的数据结构，之前也出过一篇centos7安装redis的文章小白也会操作 ！Centos7 安装redis，如果感兴趣的小伙伴可自行安装，redis有对应的Windows版本，但是目前最新的Windows版本为3.2.0，因此，如果想使用最新版的redis功能，建议使用Linux系统安装。

使用redis的必要性

        在正常的业务开发中，我们需要通过查询数据库来返回给前端数据，对于一些访问量较高的接口，会频繁的请求数据，这就导致我们的系统需要不断地查询数据库，产生大量的IO操作，这一点无疑是非常耗性能的，除此之外，最为主要的原因是所有的请求都会落在数据库上，会给数据库造成很大的压力，这一点是非常致命的，因此我们在做系统设计的时候就必须考虑这个问题，特别是针对并发较高的接口。考虑使用redis作为缓存主要还是利用了redis的高并发能力（完全基于内存，读写迅速），当接口查询数据库后可以将数据存在redis之中，后续请求到达服务之后优先访问缓存，以此来减轻数据库的压力。

springboot使用redis

        由于springboot已经做好了redis的集成，因此，在springboot的项目中使用redis就变得特别简单，我们只需要引入spring-data-redis的包即可开箱即用，以下是spring官方对spring-data-redis的说明：

Spring Data Redis provides easy configuration and access to Redis from Spring applications. It offers both low-level and high-level abstractions for interacting with the store, freeing the user from infrastructural concerns.

 环境准备

• Interllij丶IDEA
• maven 3.6.3
• java 11
• redis 5.0.12
• springboot 2.3.12

引入依赖

<dependencies>

  <dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>2.5.4</version>
  </dependency>

</dependencies>

 添加redis配置

spring:
  application:
    name: springboot-redis
  redis:
    host: ip
    port: 1111
    password: pwd
    lettuce:
      pool:
        max-active: 8
        max-wait: 1ms
        min-idle: 1

redis工具类

package com.zt.springboot_redis.util;

import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;


@Component
public class RedisUtil {

    @Resource
    private RedisTemplate redisTemplate;

    /**
     * 添加缓存
     * @param key   缓存的键值
     * @param value 缓存的值
     * @return
     */
    public void setObj(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * @param key
     * @param value    值
     * @param timeout  时间
     * @param timeUnit 时间粒度
     * @return
     */
    public void setObj(String key, Object value, Integer timeout, TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 根据可以值获取缓存
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public Object getObj(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 根据key值删除缓存
     * @param key
     */
    public void deleteObj(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     * @param collection
     */
    public Long deleteObj(Collection collection) {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     */
    public void setList(String key, List<Object> dataList) {
        ListOperations listOperation = redisTemplate.opsForList();
        if (null != dataList) {
            int size = dataList.size();
            for (int i = 0; i < size; i++) {
                listOperation.leftPush(key, dataList.get(i));
            }
        }
    }

    /**
     * 获得缓存的list对象
     */
    public List<Object> getList(String key) {
        List<Object> dataList = new ArrayList();
        ListOperations<String, Object> listOperation = redisTemplate.opsForList();
        Long size = listOperation.size(key);

        for (int i = 0; i < size; i++) {
            dataList.add(listOperation.index(key, i));
        }
        return dataList;
    }

    /**
     * 缓存Set
     */
    public void setSet(String key, Set<Object> dataSet) {
        BoundSetOperations<String, Object> setOperation = redisTemplate.boundSetOps(key);
        Iterator<Object> it = dataSet.iterator();
        while (it.hasNext()) {
            setOperation.add(it.next());
        }
    }
    /**
     * 获得缓存的set
     */
    public Set<Object> getSet(String key) {
        Set<Object> dataSet;
        BoundSetOperations<String, Object> operation = redisTemplate.boundSetOps(key);
        dataSet = operation.members();
        return dataSet;
    }

    /**
     * 缓存Map
     */
    public void setMap(String key, Map<String, Object> dataMap) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        if (null != dataMap) {
            for (Map.Entry<String, Object> entry : dataMap.entrySet()) {
                hashOperations.put(key, entry.getKey(), entry.getValue());
            }
        }
    }

    /**
     * 获得缓存的Map
     */
    public Map<String, Object> getMap(String key) {
        Map<String, Object> map = redisTemplate.opsForHash().entries(key);
        return map;
    }

}

单元测试

@SpringBootTest
class RedisUtilTest {

    @Autowired
    private RedisUtil redisUtil;

    private String key = "key";
    private Integer value = 10;

    private String listKey = "listKey";

    @Test
    void setAndGet() {
        redisUtil.setObj(key,value);
        Assertions.assertEquals(value,redisUtil.getObj(key));
    }

    @Test
    void testDel() {
        redisUtil.deleteObj(key);
        Assertions.assertNull(redisUtil.getObj(key));
    }

    @Test
    void testSetList() {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        redisUtil.setList(listKey,list);
        List utilList = redisUtil.getList(listKey);
        Assertions.assertEquals(2,utilList.size());
    }

}

以上的测试中只测试了少数方法，后面的也可以在做测试。