SpringBoot整合Redis，一篇带你入门使用Redis

旧城等待， 2024-05-24 01:45 70阅读 0赞

> 本文介绍如何将Redis整合到SpringBoot项目中，以及如何配置、封装和使用

#### 文章目录 ####

*  前言
 *  环境搭建
 *   *  项目结构
     *  添加依赖
 *  Module封装
 *   *  RedisConfig配置
     *  封装常见操作为Service
     *   *  RedisService
         *  RedisLockUtil
 *  测试

## 前言 ##

参考链接：

*  [英文官网链接][Link 1]
 *  [中文官网链接][Link 2]
 *  [Redis github][]，Redis采用C语言开发，可以学习其架构设计和C语言开发
 *  [学习Spring-cloud][Spring-cloud]，封装了一些常用的库

Redis是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合，位图，hyperloglogs等数据类型。内置复制、Lua脚本、LRU收回、事务以及不同级别磁盘持久化功能，同时通过Redis Sentinel提供高可用，通过Redis Cluster提供自动分区。

## 环境搭建 ##

### 项目结构 ###

将Redis封装成一个module，上层依赖即可，引入该模块，再注入`RedisService` 。  
![在这里插入图片描述][d3e9625849844614975eb183d60e2e7d.jpeg_pic_center]

### 添加依赖 ###

pom.xml添加依赖库

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>spring-learn</artifactId>
            <groupId>org.ym</groupId>
            <version>1.0-SNAPSHOT</version>
            <relativePath>../../pom.xml</relativePath>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>learn-common-redis</artifactId>
    
        <properties>
            <maven.compiler.source>8</maven.compiler.source>
            <maven.compiler.target>8</maven.compiler.target>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba.fastjson2</groupId>
                <artifactId>fastjson2</artifactId>
            </dependency>
        </dependencies>
    
    </project>

`applicaiton.yml`配置：

spring:
      application:
        name: learn-checkcode
      mvc:
        pathmatch:
          matching-strategy: ant_path_matcher
      redis:
        host: localhost # Redis服务器地址
        database: 0 # Redis数据库索引（默认为0）
        port: 6379 # Redis服务器连接端口
        password:  # Redis服务器连接密码（默认为空）
        timeout: 3000ms # 连接超时时间（毫秒）

![在这里插入图片描述][f3a9c448510644bebd71bc0951ba483b.jpeg_pic_center]

spring.factories配置，修改自己的包路径即可:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
      com.ym.learn.redis.config.RedisConfig

## Module封装 ##

### RedisConfig配置 ###

package com.ym.learn.redis.config;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
    import com.ym.learn.redis.service.RedisService;
    import com.ym.learn.redis.service.impl.RedisServiceImpl;
    import com.ym.learn.redis.util.RedisLockUtil;
    import org.springframework.context.annotation.Bean;
    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.RedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.time.Duration;
    
    /**
     * @Author: Yangmiao
     * @Date: 2023/4/21 16:35
     * @Desc: redis基础配置
     */
    public class RedisConfig {
        
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        
            RedisSerializer<Object> redisSerializer = redisSerializer();
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            // 配置key value的序列化方式
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(redisSerializer);
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(redisSerializer);
            redisTemplate.afterPropertiesSet();
    
            return redisTemplate;
    
        }
    
        @Bean
        public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory){
        
            RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
            // 设置缓存有效期为1天
            RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer()))
                    .entryTtl(Duration.ofDays(1));
            return new RedisCacheManager(redisCacheWriter,redisCacheConfiguration);
    
        }
    
        @Bean
        public RedisSerializer<Object> redisSerializer(){
        
            Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);
            serializer.setObjectMapper(objectMapper);
            return serializer;
        }
    
        @Bean
        public RedisService redisService(){
        
            return new RedisServiceImpl();
        }
    
        @Bean
        public RedisLockUtil redisLockUtil(RedisTemplate redisTemplate){
        
            return new RedisLockUtil(redisTemplate);
        }
    
    }

### 封装常见操作为Service ###

#### RedisService ####

添加RedisService接口

package com.ym.learn.redis.service;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * @Author: Yangmiao
     * @Date: 2023/4/21 16:42
     * @Desc:
     */
    public interface RedisService {
        
        /**
         * 保存属性
         */
        void set(String key, Object value, long time);
    
        /**
         * 保存属性
         */
        void set(String key, Object value);
    
        /**
         * 获取属性
         */
        Object get(String key);
    
        /**
         * 删除属性
         */
        Boolean del(String key);
    
        /**
         * 批量删除属性
         */
        Long del(List<String> keys);
    
        /**
         * 设置过期时间
         */
        Boolean expire(String key, long time);
    
        /**
         * 获取过期时间
         */
        Long getExpire(String key);
    
        /**
         * 判断是否有该属性
         */
        Boolean hasKey(String key);
    
        /**
         * 按delta递增
         */
        Long incr(String key, long delta);
    
        /**
         * 按delta递减
         */
        Long decr(String key, long delta);
    
        /**
         * 获取Hash结构中的属性
         */
        Object hGet(String key, String hashKey);
    
        /**
         * 向Hash结构中放入一个属性
         */
        Boolean hSet(String key, String hashKey, Object value, long time);
    
        /**
         * 向Hash结构中放入一个属性
         */
        void hSet(String key, String hashKey, Object value);
    
        /**
         * 直接获取整个Hash结构
         */
        Map<Object, Object> hGetAll(String key);
    
        /**
         * 直接设置整个Hash结构
         */
        Boolean hSetAll(String key, Map<String, Object> map, long time);
    
        /**
         * 直接设置整个Hash结构
         */
        void hSetAll(String key, Map<String, ?> map);
    
        /**
         * 删除Hash结构中的属性
         */
        void hDel(String key, Object... hashKey);
    
        /**
         * 判断Hash结构中是否有该属性
         */
        Boolean hHasKey(String key, String hashKey);
    
        /**
         * Hash结构中属性递增
         */
        Long hIncr(String key, String hashKey, Long delta);
    
        /**
         * Hash结构中属性递减
         */
        Long hDecr(String key, String hashKey, Long delta);
    
        /**
         * 获取Set结构
         */
        Set<Object> sMembers(String key);
    
        /**
         * 向Set结构中添加属性
         */
        Long sAdd(String key, Object... values);
    
        /**
         * 向Set结构中添加属性
         */
        Long sAdd(String key, long time, Object... values);
    
        /**
         * 是否为Set中的属性
         */
        Boolean sIsMember(String key, Object value);
    
        /**
         * 获取Set结构的长度
         */
        Long sSize(String key);
    
        /**
         * 删除Set结构中的属性
         */
        Long sRemove(String key, Object... values);
    
        /**
         * 获取List结构中的属性
         */
        List<Object> lRange(String key, long start, long end);
    
        /**
         * 获取List结构的长度
         */
        Long lSize(String key);
    
        /**
         * 根据索引获取List中的属性
         */
        Object lIndex(String key, long index);
    
        /**
         * 向List结构中添加属性
         */
        Long lPush(String key, Object value);
    
        /**
         * 向List结构中添加属性
         */
        Long lPush(String key, Object value, long time);
    
        /**
         * 向List结构中批量添加属性
         */
        Long lPushAll(String key, Object... values);
    
        /**
         * 向List结构中批量添加属性
         */
        Long lPushAll(String key, Long time, Object... values);
    
        /**
         * 从List结构中移除属性
         */
        Long lRemove(String key, long count, Object value);
    
        /**
         * 加分布式锁
         * @param key
         * @param expireTime
         * @return
         */
        public boolean tryLock(String key, int expireTime);
    
        /**
         * 释放分布式锁
         * @param key
         */
        public void unLock(String key);
    }

RedisService实现类

package com.ym.learn.redis.service.impl;
    
    import com.alibaba.fastjson2.JSONObject;
    import com.ym.learn.redis.service.RedisService;
    import com.ym.learn.redis.util.RedisLockUtil;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @Author: Yangmiao
     * @Date: 2023/4/21 16:42
     * @Desc: 实现redis操作常见接口
     */
    public class RedisServiceImpl implements RedisService {
        
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        @Autowired
        private RedisLockUtil redisLockUtil;
    
        @Override
        public void set(String key, Object value, long time) {
        
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        }
    
        @Override
        public void set(String key, Object value) {
        
            redisTemplate.opsForValue().set(key, value);
        }
    
        @Override
        public Object get(String key) {
        
            return redisTemplate.opsForValue().get(key);
        }
    
        @Override
        public Boolean del(String key) {
        
            return redisTemplate.delete(key);
        }
    
        @Override
        public Long del(List<String> keys) {
        
            return redisTemplate.delete(keys);
        }
    
        @Override
        public Boolean expire(String key, long time) {
        
            return redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
    
        @Override
        public Long getExpire(String key) {
        
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        @Override
        public Boolean hasKey(String key) {
        
            return redisTemplate.hasKey(key);
        }
    
        @Override
        public Long incr(String key, long delta) {
        
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
        @Override
        public Long decr(String key, long delta) {
        
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
        @Override
        public Object hGet(String key, String hashKey) {
        
            return redisTemplate.opsForHash().get(key, hashKey);
        }
    
        @Override
        public Boolean hSet(String key, String hashKey, Object value, long time) {
        
            redisTemplate.opsForHash().put(key, hashKey, value);
            return expire(key, time);
        }
    
        @Override
        public void hSet(String key, String hashKey, Object value) {
        
            redisTemplate.opsForHash().put(key, hashKey, value);
        }
    
        @Override
        public Map<Object, Object> hGetAll(String key) {
        
            return redisTemplate.opsForHash().entries(key);
        }
    
        @Override
        public Boolean hSetAll(String key, Map<String, Object> map, long time) {
        
            redisTemplate.opsForHash().putAll(key, map);
            return expire(key, time);
        }
    
        @Override
        public void hSetAll(String key, Map<String, ?> map) {
        
            redisTemplate.opsForHash().putAll(key, map);
        }
    
        @Override
        public void hDel(String key, Object... hashKey) {
        
            redisTemplate.opsForHash().delete(key, hashKey);
        }
    
        @Override
        public Boolean hHasKey(String key, String hashKey) {
        
            return redisTemplate.opsForHash().hasKey(key, hashKey);
        }
    
        @Override
        public Long hIncr(String key, String hashKey, Long delta) {
        
            return redisTemplate.opsForHash().increment(key, hashKey, delta);
        }
    
        @Override
        public Long hDecr(String key, String hashKey, Long delta) {
        
            return redisTemplate.opsForHash().increment(key, hashKey, -delta);
        }
    
        @Override
        public Set<Object> sMembers(String key) {
        
            return redisTemplate.opsForSet().members(key);
        }
    
        @Override
        public Long sAdd(String key, Object... values) {
        
            return redisTemplate.opsForSet().add(key, values);
        }
    
        @Override
        public Long sAdd(String key, long time, Object... values) {
        
            Long count = redisTemplate.opsForSet().add(key, values);
            expire(key, time);
            return count;
        }
    
        @Override
        public Boolean sIsMember(String key, Object value) {
        
            return redisTemplate.opsForSet().isMember(key, value);
        }
    
        @Override
        public Long sSize(String key) {
        
            return redisTemplate.opsForSet().size(key);
        }
    
        @Override
        public Long sRemove(String key, Object... values) {
        
            return redisTemplate.opsForSet().remove(key, values);
        }
    
        @Override
        public List<Object> lRange(String key, long start, long end) {
        
            return redisTemplate.opsForList().range(key, start, end);
        }
    
        @Override
        public Long lSize(String key) {
        
            return redisTemplate.opsForList().size(key);
        }
    
        @Override
        public Object lIndex(String key, long index) {
        
            return redisTemplate.opsForList().index(key, index);
        }
    
        @Override
        public Long lPush(String key, Object value) {
        
            return redisTemplate.opsForList().rightPush(key, value);
        }
    
        @Override
        public Long lPush(String key, Object value, long time) {
        
            Long index = redisTemplate.opsForList().rightPush(key, value);
            expire(key, time);
            return index;
        }
    
        @Override
        public Long lPushAll(String key, Object... values) {
        
            return redisTemplate.opsForList().rightPushAll(key, values);
        }
    
        @Override
        public Long lPushAll(String key, Long time, Object... values) {
        
            Long count = redisTemplate.opsForList().rightPushAll(key, values);
            expire(key, time);
            return count;
        }
    
        @Override
        public Long lRemove(String key, long count, Object value) {
        
            return redisTemplate.opsForList().remove(key, count, value);
        }
    
        /**
         * 分布式锁
         *
         * @param key        分布式锁key
         * @param expireTime 持有锁的最长时间 (redis过期时间) 秒为单位
         * @return 返回获取锁状态 成功失败
         */
        @Override
        public boolean tryLock(String key, int expireTime) {
        
            final JSONObject lock = new JSONObject();
            lock.put("id", key);
            // startTime
            lock.put("st", System.currentTimeMillis());
            // keepSeconds
            lock.put("ks", expireTime);
            return redisLockUtil.tryLock(key, "", expireTime);
        }
    
        @Override
        public void unLock(String key) {
        
            redisLockUtil.releaseLock(key, "");
        }
    }

#### RedisLockUtil ####

package com.ym.learn.redis.util;
    
    import org.springframework.data.redis.connection.RedisStringCommands;
    import org.springframework.data.redis.connection.ReturnType;
    import org.springframework.data.redis.core.RedisCallback;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.types.Expiration;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * @Author: Yangmiao
     * @Date: 2023/4/21 16:45
     * @Desc: Redis分布式锁
     */
    public class RedisLockUtil {
        
        public RedisLockUtil(RedisTemplate<String, Object> redisTemplate) {
        
            this.redisTemplate = redisTemplate;
        }
    
        private RedisTemplate<String, Object> redisTemplate;
    
        private static final byte[] SCRIPT_RELEASE_LOCK = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end".getBytes();
    
        /**
         * 尝试获取分布式锁
         *
         * @param key       键
         * @param requestId 请求ID
         * @param expire    锁的有效时间（秒）
         */
        public synchronized Boolean tryLock(String key, String requestId, long expire) {
        
            return redisTemplate.execute((RedisCallback<Boolean>) redisConnection -> redisConnection.set(key.getBytes(), requestId.getBytes(), Expiration.from(expire, TimeUnit.SECONDS), RedisStringCommands.SetOption.SET_IF_ABSENT));
        }
    
        /**
         * 释放分布式锁
         *
         * @param key       键
         * @param requestId 请求ID
         */
        public synchronized Boolean releaseLock(String key, String requestId) {
        
            return redisTemplate.execute((RedisCallback<Boolean>) redisConnection -> redisConnection.eval(SCRIPT_RELEASE_LOCK, ReturnType.BOOLEAN, 1, key.getBytes(), requestId.getBytes()));
        }
    }

## 测试 ##

借助工具Another Redis Desktop Manager查看值  
![在这里插入图片描述][3522e3a954274175932510e6f4f60a9b.jpeg_pic_center]

[Link 1]: https://redis.io/
[Link 2]: https://www.redis.net.cn/
[Redis github]: https://github.com/redis/redis
[Spring-cloud]: https://github.com/miaoyang/spring-learn
[d3e9625849844614975eb183d60e2e7d.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/9c4a400246864d1a91c4e2c909cdf4e9.jpeg
[f3a9c448510644bebd71bc0951ba483b.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/0bbceb6a94354fd7917138c630dda87d.jpeg
[3522e3a954274175932510e6f4f60a9b.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/99b6aedee6504c299eac254240440e5e.jpeg