redis

 1.redis简述

1.1概念理解

Redis既可以作为数据库使用，也可以作为中间件
        数据库时，Redis是一种key-value型的内存数据库，支持数据持久化，可以将数据保存到磁盘上。它的主要特点是读写速度非常快，因为它将所有数据都存储在内存中，而且支持多种数据结构，如字符串、哈希表、列表、集合和有序集合等。
        中间件时，Redis通常用于缓存数据和分布式锁的实现。缓存数据可以减轻后端数据库的压力，提高系统的响应速度。分布式锁可以协调不同的进程或线程对共享资源的访问，防止并发访问问题导致的数据不一致或其他异常情况

1.2命令

1.查找        keys pattern    【类似mysql模糊查询 * 匹配0到多个字符，？匹配一个字符，[]匹配中括号一个字符】

keys *	查看所有key
keys A?	查看所有A开头长度2的字符串  A2,AA,Ap
keys A[12]	查看 A1,A2

2.判断key是否存在        exists kk   【返回存在个数，不存在0】

举例： exists  k1 k2 k3 k4  结果：2 说明里面2个存在

3.移动key到指定数据库  move k1  2 

注意： move key index  【redis默认16个库，用户默认使用第0库】0.1.2...15

举例：move k1 3

        exists k1  —》0  【 k1移走了，不在原0库，故不存在

        select 3 —》选择 3库

        exists k1 —》1  【 说明移动到1库中了

4.查看key的剩余时间   单位秒

举例： ttl k1  显示数值，但是注意：一般正值，负值时 -1—》key存在但是没设置生存时间。-2—》该key不存在

5.设置key的最大生存时间  expire key seconds  【时间、秒】

举例：expire k1 15   k1存在时间15秒

6.查看key的类型          type key

7.重命名key                  rename oldKey  newKey

举例： rename k1 k56     键k1 名改为 k56

8.删除指定key 值也会跟着删除

举例：del k1               del k1 k2 k3 删除三个key

9.减去某值  decrby k1 2

10.增加某值 incrby k1 3     incrby k1 -3 也可加负数 为减去3 

参考：序言 · Redis快速入门 · 看云 (kancloud.cn)

 2.redis使用

1.导包

    org.springframework.boot
    spring-boot-starter-redis
    ${spring-boot.version} 

2.配置

2.1配置相关属性

spring:
  redis:
    database: 0      # Redis数据库索引（默认为0）
    host: localhost  # Redis服务器地址
    port: 6379       # Redis服务器端口
    password:        # Redis服务器连接密码（默认为空）
    timeout: 0 # 连接超时时间（毫秒）
    lettuce:
      pool:
        max-active: 8  # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1   # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 8    # 连接池中的最大空闲连接
        min-idle: 0    # 连接池中的最小空闲连接          

 2.2配置具体的RedisTemplate的序列化策略
 

Redis本身提供了一下一种序列化的方式： 存储格式：key:value形式！value有多种数据结构

• GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化  【适用于值比较简单的场景，例如数值、日期等类型】
• Jackson2JsonRedisSerializer: 跟JacksonJsonRedisSerializer实际上是一样的 【适用于值比较复杂的场景，例如自定义的 POJO 类型】  一般针对value
• JacksonJsonRedisSerializer: 序列化object对象为json字符串
• JdkSerializationRedisSerializer: 序列化java对象  【 二进制流，人眼看不懂】
• 使用 JdkSerializationRedisSerializer 进行序列化时，被序列化的 Java 类需要实现 Serializable 接口，否则会抛出 NotSerializableException 异常
• StringRedisSerializer: 简单的字符串序列化 一般针对key

如果我们存储的是String类型，默认使用的是StringRedisSerializer 这种序列化方式。如果我们存储的是对象，默认使用的是 JdkSerializationRedisSerializer，也就是Jdk的序列化方式（通过ObjectOutputStream和ObjectInputStream实现，缺点是我们无法直观看到存储的对象内容）。

//导入包
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
//通用化配置
@Configuration
public class redisComConfig {
	//Redis链接工厂
	@Autowired
	private RedisConnectionFactory redisConnectionFactory;
	//缓存操作组件RedisTemplate的自定义配置
	@Bean
	public RedisTemplate redisTemplate(){
	//定义RedisTemplate实例
	RedisTemplate redisTemplate=new RedisTemplate();
	//设置Redis的链接工厂
	redisTemplate.setConnectionFactory(redisConnectionFactory);
	//TODO：指定大Key序列化策略为String序列化，Value为JDK自带的序列化策略
	redisTemplate.setKeySerializer(new StringRedisSerializer());
	redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
	//TODO：指定hashKey序列化策略为String序列化-针对hash散列存储
	redisTemplate.setHashKeySerializer(new StringRedisSerializer());
	return redisTemplate;
	}
	//缓存操作组件StringRedisTemplate
	@Bean
	public StringRedisTemplate stringRedisTemplate(){
	  //采用默认配置即可-后续有自定义配置时则在此处添加即可
	  StringRedisTemplate stringRedisTemplate=new StringRedisTemplate();
	  stringRedisTemplate.setConnectionFactory(redisConnectionFactory);
	  return stringRedisTemplate;
	}
}

3.简化使用—工具类

//单元测试类
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
@Slf4j
public class RedisTest {

   //由于之前已经自定义注入RedisTemplate组件，因而在此可以直接自动装配
   @Autowired
    private RedisTemplate redisTemplate;
    //定义JSON序列化与反序列化框架类
   @Autowired
    private ObjectMapper objectMapper;
//===========字符串
    //采用RedisTemplate将字符串信息写入缓存中并读取出来
    @Test
    public void one(){
              
       //定义字符串内容及存入缓存的key
       final String content="RedisTemplate信息";
       final String key="redis:template:one:string";

       //Redis通用的操作组件
       ValueOperationsvalueOperations=redisTemplate.opsForValue();
       //将字符串信息写入缓存中
       log.info("写入缓存中的内容：{} ", content);
       valueOperations.set(key, content);
       //从缓存中读取内容
       Object result=valueOperations.get(key);
       log.info("读取出来的内容：{} ", result); 
//==================对象
         //构造对象信息
            Dog dog=new Dpg(1,  "华仔！");
 
             //将序列化后的信息写入缓存中
            final String key="redis:template:two:object";
            final String content=objectMapper.writeValueAsString(dog);

            valueOperations.set(key, content);

            log.info("写入缓存对象的信息：{} ", user);
            //从缓存中读取内容
            Object result=valueOperations.get(key);

            if (result! =null){
                Dog dog2=objectMapper.readValue(result.toString(), Dog.class);
                log.info("读取缓存内容并反序列化后的结果：{} ", dog2);
            }

//===========  也可写作 //灵活点 转换字符串就好
        valueOperations.set(key,SON.toJSONString(dog));

        JSONObject.parseObject(result.toString(), Dog.class);
    }
}

redis工具类

import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
 
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
/**
 * Redis工具类*/
@Component
public class RedisUtil {
    private StringRedisTemplate redisTemplate;

    @Autowired
    public void setRedisTemplate(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
 
    public StringRedisTemplate getRedisTemplate() {
        return this.redisTemplate;
    }
 
    /** -------------------key相关操作--------------------- */
    /**
     * 删除key
     * @param key
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }
 
    /**
     * 批量删除key
     * @param keys
     */
    public void delete(Collection keys) {
        redisTemplate.delete(keys);
    }
 
    /**
     * 序列化key
     * @param key
     * @return 返回一个字节数组
     */
    public byte[] dump(String key) {
        return redisTemplate.dump(key);
    }
 
    /**
     * 是否存在key
     * @param key
     * @return
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
 
    /**
     * 设置过期时间
     * 
     * @param key
     * @param timeout
     * @param unit
     * @return
     */
    public Boolean expire(String key, long timeout, TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }
 
    /**
     * 设置过期时间
     * 
     * @param key
     * @param date
     * @return
     */
    public Boolean expireAt(String key, Date date) {
        return redisTemplate.expireAt(key, date);
    }
 
    /**
     * 查找匹配的key
     * 
     * @param pattern
     * @return
     */
    public Set keys(String pattern) {
        return redisTemplate.keys(pattern);
    }
 
    /**
     * 将当前数据库的 key 移动到给定的数据库 db 当中
     * 
     * @param key
     * @param dbIndex
     * @return
     */
    public Boolean move(String key, int dbIndex) {
        return redisTemplate.move(key, dbIndex);
    }
 
    /**
     * 移除 key 的过期时间，key 将持久保持
     * 
     * @param key
     * @return
     */
    public Boolean persist(String key) {
        return redisTemplate.persist(key);
    }
 
    /**
     * 返回 key 的剩余的过期时间
     * 
     * @param key
     * @param unit
     * @return
     */
    public Long getExpire(String key, TimeUnit unit) {
        return redisTemplate.getExpire(key, unit);
    }
 
    /**
     * 返回 key 的剩余的过期时间
     * 
     * @param key
     * @return
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key);
    }
 
    /**
     * 从当前数据库中随机返回一个 key
     * 
     * @return
     */
    public String randomKey() {
        return redisTemplate.randomKey();
    }
 
    /**
     * 修改 key 的名称
     * 
     * @param oldKey
     * @param newKey
     */
    public void rename(String oldKey, String newKey) {
        redisTemplate.rename(oldKey, newKey);
    }
 
    /**
     * 仅当 newkey 不存在时，将 oldKey 改名为 newkey
     * 
     * @param oldKey
     * @param newKey
     * @return
     */
    public Boolean renameIfAbsent(String oldKey, String newKey) {
        return redisTemplate.renameIfAbsent(oldKey, newKey);
    }
 
    /**
     * 返回 key 所储存的值的类型
     * 
     * @param key
     * @return
     */
    public DataType type(String key) {
        return redisTemplate.type(key);
    }
 
    /** -------------------string相关操作--------------------- */
 
    /**
     * 设置指定 key 的值
     * @param key
     * @param value
     */
    public void set(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }
 
    /**
     * 获取指定 key 的值
     * @param key
     * @return
     */
    public String get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
 
    /**
     * 返回 key 中字符串值的子字符
     * @param key
     * @param start
     * @param end
     * @return
     */
    public String getRange(String key, long start, long end) {
        return redisTemplate.opsForValue().get(key, start, end);
    }
 
    /**
     * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)
     * 
     * @param key
     * @param value
     * @return
     */
    public String getAndSet(String key, String value) {
        return redisTemplate.opsForValue().getAndSet(key, value);
    }
 
    /**
     * 对 key 所储存的字符串值，获取指定偏移量上的位(bit)
     * 
     * @param key
     * @param offset
     * @return
     */
    public Boolean getBit(String key, long offset) {
        return redisTemplate.opsForValue().getBit(key, offset);
    }
 
    /**
     * 批量获取
     * 
     * @param keys
     * @return
     */
    public List multiGet(Collection keys) {
        return redisTemplate.opsForValue().multiGet(keys);
    }
 
    /**
     * 设置ASCII码, 字符串'a'的ASCII码是97, 转为二进制是'01100001', 此方法是将二进制第offset位值变为value
     * 
     * @param key 位置
     * @param value
     *            值,true为1, false为0
     * @return
     */
    public boolean setBit(String key, long offset, boolean value) {
        return redisTemplate.opsForValue().setBit(key, offset, value);
    }
 
    /**
     * 将值 value 关联到 key ，并将 key 的过期时间设为 timeout
     * 
     * @param key
     * @param value
     * @param timeout
     *            过期时间
     * @param unit
     *            时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES
     *            秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
     */
    public void setEx(String key, String value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }
 
    /**
     * 只有在 key 不存在时设置 key 的值
     * 
     * @param key
     * @param value
     * @return 之前已经存在返回false,不存在返回true
     */
    public boolean setIfAbsent(String key, String value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }
 
    /**
     * 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
     * 
     * @param key
     * @param value
     * @param offset
     *            从指定位置开始覆写
     */
    public void setRange(String key, String value, long offset) {
        redisTemplate.opsForValue().set(key, value, offset);
    }
 
    /**
     * 获取字符串的长度
     * 
     * @param key
     * @return
     */
    public Long size(String key) {
        return redisTemplate.opsForValue().size(key);
    }
 
    /**
     * 批量添加
     * 
     * @param maps
     */
    public void multiSet(Map maps) {
        redisTemplate.opsForValue().multiSet(maps);
    }
 
    /**
     * 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
     * 
     * @param maps
     * @return 之前已经存在返回false,不存在返回true
     */
    public boolean multiSetIfAbsent(Map maps) {
        return redisTemplate.opsForValue().multiSetIfAbsent(maps);
    }
 
    /**
     * 增加(自增长), 负数则为自减
     * 
     * @param key
     * @return
     */
    public Long incrBy(String key, long increment) {
        return redisTemplate.opsForValue().increment(key, increment);
    }
 
    /**
     * 
     * @param key
     * @return
     */
    public Double incrByFloat(String key, double increment) {
        return redisTemplate.opsForValue().increment(key, increment);
    }
 
    /**
     * 追加到末尾
     * 
     * @param key
     * @param value
     * @return
     */
    public Integer append(String key, String value) {
        return redisTemplate.opsForValue().append(key, value);
    }
 
    /** -------------------hash相关操作------------------------- */
 
    /**
     * 获取存储在哈希表中指定字段的值
     * 
     * @param key
     * @param field
     * @return
     */
    public Object hGet(String key, String field) {
        return redisTemplate.opsForHash().get(key, field);
    }
 
    /**
     * 获取所有给定字段的值
     * 
     * @param key
     * @return
     */
    public Map hGetAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }
 
    /**
     * 获取所有给定字段的值
     * 
     * @param key
     * @param fields
     * @return
     */
    public List