第五篇：Spring Boot整合Redis

版权声明：本文为博主原创文章，欢迎转载，转载请注明作者、原文超链接 ，博主地址：https://blog.csdn.net/mr_chenjie_c。 https://blog.csdn.net/Mr_Chenjie_C/article/details/84877656

Redis 是一个高性能的key-value数据库，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。使用redis作为缓存技术方案，主要是因为Redis缓存技术的特点就在于高效，因为目前涉及的数据量逐渐增多，在对于数据的存储上面和sql以及服务器资源优化上面就显得尤为重要。而redis可以帮助解决由于数据库压力造成的延迟现象，针对于很少做改变的数据或者经常使用的数据，我们可以一致性加入内存。这样一方面可以减少数据库压力，另一方面也能提高读写效率。

本文主要介绍Spring Boot如何整合Redis。

引入依赖：

在pom文件中添加Redis依赖：

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

配置数据源

application.yml

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password:
    timeout: 0
    database: 0
  pool:
    max-active: 8
    max-wait: -1
    max-idle: 8
    min-idle: 0

编写配置类

@Configuration
@EnableCaching
public class RedisConfig {
    /**
     * 注入 RedisConnectionFactory
     */
    @Autowired
    RedisConnectionFactory redisConnectionFactory;

    /**
     * 实例化 RedisTemplate 对象
     *
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> functionDomainRedisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }

    /**
     * 设置数据存入 redis 的序列化方式
     *
     * @param redisTemplate
     * @param factory
     */
    private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
    }

    /**
     * 实例化 HashOperations 对象,可以使用 Hash 类型操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 实例化 ValueOperations 对象,可以使用 String 操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     * 实例化 ListOperations 对象,可以使用 List 操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 实例化 SetOperations 对象,可以使用 Set 操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     * 实例化 ZSetOperations 对象,可以使用 ZSet 操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

创建实体类

public class RedisEntity implements Serializable {
    private String name;
    private String tel;
    private String address;
    private String redisKey;
    //getter,setter...
}

特别注意，要实现Serializable接口

创建Service

public abstract class RedisService<T> {
    @Autowired
    protected RedisTemplate<String, Object> redisTemplate;
    @Resource
    protected HashOperations<String, String, T> hashOperations;

    /**
     * 存入redis中的key
     *
     * @return
     */
    protected abstract String getRedisKey();

    /**
     * 添加
     *
     * @param key    key
     * @param doamin 对象
     * @param expire 过期时间(单位:秒),传入 -1 时表示不设置过期时间
     */
    public void put(String key, T doamin, long expire) {
        hashOperations.put(getRedisKey(), key, doamin);
        if (expire != -1) {
            redisTemplate.expire(getRedisKey(), expire, TimeUnit.SECONDS);
        }
    }

    /**
     * 删除
     *
     * @param key 传入key的名称
     */
    public void remove(String key) {
        hashOperations.delete(getRedisKey(), key);
    }

    /**
     * 查询
     *
     * @param key 查询的key
     * @return
     */
    public T get(String key) {
        return hashOperations.get(getRedisKey(), key);
    }

    /**
     * 获取当前redis库下所有对象
     *
     * @return
     */
    public List<T> getAll() {
        return hashOperations.values(getRedisKey());
    }

    /**
     * 查询查询当前redis库下所有key
     *
     * @return
     */
    public Set<String> getKeys() {
        return hashOperations.keys(getRedisKey());
    }

    /**
     * 判断key是否存在redis中
     *
     * @param key 传入key的名称
     * @return
     */
    public boolean isKeyExists(String key) {
        return hashOperations.hasKey(getRedisKey(), key);
    }

    /**
     * 查询当前key下缓存数量
     *
     * @return
     */
    public long count() {
        return hashOperations.size(getRedisKey());
    }

    /**
     * 清空redis
     */
    public void empty() {
        Set<String> set = hashOperations.keys(getRedisKey());
        set.stream().forEach(key -> hashOperations.delete(getRedisKey(), key));
    }
}

@Service
public class RedisServiceImpl<T> extends RedisService<T> {
    private static final String REDIS_KEY = "TEST_REDIS_KEY";
    @Override
    protected String getRedisKey() {
        return this.REDIS_KEY;
    }
}

创建Controller

@RestController
public class RedisController {
    @Autowired
    private RedisServiceImpl service;

    //添加
    @GetMapping(value = "/add")
    public String add() {
        try {
            RedisEntity m = new RedisEntity();
            m.setName("chenjay");
            m.setTel("13800001111");
            m.setAddress("cd");
            m.setRedisKey("chenjay");
            service.put(m.getRedisKey(), m, -1);

            RedisEntity m2 = new RedisEntity();
            m2.setName("mary");
            m2.setTel("13011115555");
            m2.setAddress("sz");
            m2.setRedisKey("mary");
            service.put(m2.getRedisKey(), m2, -1);

            RedisEntity m3 = new RedisEntity();
            m3.setName("lucy");
            m3.setTel("13688889999");
            m3.setAddress("sh");
            m3.setRedisKey("lucy");
            service.put(m3.getRedisKey(), m3, -1);
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
        return "success";
    }

    //查询所有对象
    @GetMapping(value = "/list")
    public Object getAll() {
        return service.getAll();
    }

    //查询所有key
    @GetMapping(value = "/keys")
    public Object getKeys() {
        return service.getKeys();
    }

    //根据key查询
    @GetMapping(value = "/{key}")
    public Object get(@PathVariable String key) {
        return service.get(key);
    }

    //删除
    @GetMapping(value = "/remove/{key}")
    public String remove(@PathVariable String key) {
        try {
            service.remove(key);
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
        return "success";
    }

    //判断key是否存在
    @GetMapping(value = "/isExist/{key}")
    public Object isKeyExists(@PathVariable String key) {
        return service.isKeyExists(key);
    }

    //查询当前缓存的数量
    @GetMapping(value = "/count")
    public Object count() {
        return service.count();
    }

    //清空所有key
    @GetMapping(value = "/empty")
    public String empty() {
        try {
            service.empty();
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
        return "success";
    }
}

测试

• 添加测试
  
  打开Redis图形化桌面管理软件（点击获取）查看刚刚我们添加的数据
• 查询所有对象
  
• 查询所有key
  
• 根据key查询对象
  
• 根据key删除对象
  
• 判断key是否存在
• 查询当前缓存的数量
• 清空所有key
  最后打开Redis Desktop Manager
  

所有测试都通过！

源码下载：https://github.com/chenjary/SpringBoot