Redis连载系列（一） redis的日常使用

最新推荐文章于 2025-03-05 19:38:17 发布

原创最新推荐文章于 2025-03-05 19:38:17 发布 · 3.2w 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#Redis连载系列（一） redis的日常使用

Redis 专栏收录该内容

8 篇文章

订阅专栏

本文是Redis系列的第一篇，介绍了Redis的基本概念、优势，以及在Spring Boot项目中的简单应用和解决可视化界面乱码问题。Redis作为内存数据库，支持多种数据类型并保证原子性操作。在Spring Boot中，通过RedisTemplate和StringRedisTemplate解决乱码问题，利用Jackson2JsonRedisSerializer实现JSON序列化。

大家好，本篇文章是redis系列开篇第一章节，主要是介绍redis的基本功能和我们项目中如何以正确姿势使用redis。

1.什么是redis,redis有何作用？

下面是来自百度百科的解释：redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
下面推荐一篇博客里面讲的很详细，怎样下载与安装redis可视化界面，请点击
redis下载、安装可视化界面操作步骤

2.redis的优点

redis速度够快，因为是基于内存操作，时间复杂度都是O(1)
正如上面说的，redis支持丰富的5种数据类型
redis所有的操作都是原子性的，只有成功和失败，不会出现部分失败和成功的说法
轻量、简单拿来即用，对于各种语言的支持度也很好

3.spring boot中简单使用redis

引入jar包

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

核心配置文件

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    jedis:
      pool:
        max-active: 30 #连接池最大连接数（使用负值表示没有限制）
        max-wait: 1000 #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 8  #连接池中的最大空闲连接
        min-idle: 3   #连接池中的最小空闲连接
    timeout: 10000ms   #连接超时时间（毫秒）

Redis操作工具类（我这是从网上搜刮来的，嘿嘿）

package com.sheng.redischapter1.config;

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;

/**
 * @author Mr sheng.z
 */
@Component
public final class RedisUtil {

@Resource
private RedisTemplate<String, Object> redisTemplate;


public Set<String> keys(String keys){
    try {
        return redisTemplate.keys(keys);
    }catch (Exception e){
        e.printStackTrace();
        return null;
    }
}

/**
 * 指定缓存失效时间
 * @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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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));
        }
    }
}
/**
 * 普通缓存获取
 * @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) {
        e.printStackTrace();
        return false;
    }
}
/**
 * 普通缓存放入, 不存在放入，存在返回
 * @param key 键
 * @param value 值
 * @return true成功 false失败
 */
public boolean setnx(String key, Object value) {
    try {
        redisTemplate.opsForValue().setIfAbsent(key,value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        return false;
    }
}

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

/**
 * 递增
 * @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);
}
/**
 * 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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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);
}
/**
 * 根据key获取Set中的所有值
 * @param key 键
 * @return
 */
public Set<Object> sGet(String key) {
    try {
        return redisTemplate.opsForSet().members(key);
    } catch (Exception e) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        return 0;
    }
}
/**
 * 获取set缓存的长度
 * @param key 键
 * @return
 */
public long sGetSetSize(String key) {
    try {
        return redisTemplate.opsForSet().size(key);
    } catch (Exception e) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        return 0;
    }
}
// ===============================list=================================
/**
 * 获取list缓存的内容
 * @param key 键
 * @param start 开始
 * @param end 结束 0 到 -1代表所有值
 * @return
 */
public List<Object> lGet(String key, long start, long end) {
    try {
        return redisTemplate.opsForList().range(key, start, end);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}
/**
 * 获取list缓存的长度
 * @param key 键
 * @return
 */
public long lGetListSize(String key) {
    try {
        return redisTemplate.opsForList().size(key);
    } catch (Exception e) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        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) {
        e.printStackTrace();
        return 0;
    }
}

}
4. 使用juint进行单元测试（需要添加junit相关依赖在pom中）

	package com.sheng.redischapter1.test;
	import com.sheng.redischapter1.config.RedisUtil;
	import org.junit.runner.RunWith;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.boot.test.context.SpringBootTest;
	import org.springframework.test.context.junit4.SpringRunner;

	/**
	 * @Author: Mr sheng.z
	 * @Description:
	 * @Date: Create in 14:22 2019/11/28
	 */
	@RunWith(SpringRunner.class)
	@SpringBootTest
	public class Test {


    @Autowired
    RedisUtil redisUtil;

    @org.junit.Test
    public void insert() {

        redisUtil.set("1","测试1");

        System.out.println(redisUtil.get("1"));

    }
}

这样的话，其实就整合redis到我们的项目中，并且可以正常的进行redis数据的增加与删除。但是当我们可视化用管理工具查看的时候，都是key和value全部是乱码，这是咋回事呢？

4.spring boot中使用redis使用可视化界面查看乱码问题解决

1.乱码肯定是我们在项目进行set的时候编码格式不对，导致乱码。我们查看我们注入的RedisTemplate,它里面有一个JdkSerializationRedisSerializer类,我们在存入redis数据的时候，要将数据转换为byte[]数组进行存储，存储的时候使用的JdkSerializationRedisSerializer类进行序列化操作，他也是redis默认的序列化方式。

public JdkSerializationRedisSerializer(@Nullable ClassLoader classLoader) {
this(new SerializingConverter(), new DeserializingConverter(classLoader));
}

SerializingConverter进行序列化，DeserializingConverter进行反序列化。我们再继续跟踪
SerializingConverter类，SerializingConverter类又指向了serializer，其实这时候局势大概已经明朗了许多。

public SerializingConverter() {
    this.serializer = new DefaultSerializer();
}

继续跟踪serializer下去，我们可以看到序列化底层主要是用的是ObjectOutputStream这个类，这就是jdk中IO流，默认的使用GBK的方式，这个也跟我们本身的操作系统的编码格式有关。好了，问题到这，乱码的原因找到了，下面开始说如何解决客户端乱码问题。

	package org.springframework.core.serializer;
	import java.io.IOException;
	import java.io.ObjectOutputStream;
	import java.io.OutputStream;
	import java.io.Serializable;

	public class DefaultSerializer implements Serializer<Object> {
    public DefaultSerializer() {
    }

    public void serialize(Object object, OutputStream outputStream) throws IOException {
        if (!(object instanceof Serializable)) {
            throw new IllegalArgumentException(this.getClass().getSimpleName() + " requires a Serializable payload but received an object of type [" + object.getClass().getName() + "]");
        } else {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            objectOutputStream.writeObject(object);
            objectOutputStream.flush();
        }
    }
}

2.解决redis客户端乱码问题
上面我们提到RedisTemplate使用的是JdkSerializationRedisSerializer序列化方式进行序列化，主要用于存储对象，当我们存储字符串的时候，客户端会乱码。其实spring-boot-starter-data-redis中还有一种模板StringRedisTemplate主要用于存储字符串用的。这两种模板功能都差不多，主要是封装了一些对Redis常规的操作。那我们现在使用JdkSerializationRedisSerializer自带的序列化操作方式肯定是不行的，看到网上对于redis的介绍，可以采用Jackson2JsonRedisSerializer方式序列化，这样不仅体积小，序列化后的数据长度更是优于采用jdk的方式，看名字就知道，跟json相关，目前流行的数据和接口交互基本上都是json格式。
话不多说，直接上代码，注入到soring容器当中，修改序列化格式，即可解决上述问题

package com.sheng.redischapter1.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

/**
 * @Author: Mr sheng.z
 * @Description:
 * @Date: Create in 14:27 2019/11/28
 */
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
public class RedisConfig {


/**
 * RedisTemplate配置
 * @param factory
 * @return
 */
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
    StringRedisTemplate template = new StringRedisTemplate(factory);
    //定义value的序列化方式
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    template.setValueSerializer(jackson2JsonRedisSerializer);
    template.setHashValueSerializer(jackson2JsonRedisSerializer);
    template.afterPropertiesSet();
    return template;
}

}