Redis入门

Redis

---

入门：

简介：Redis（Remote Dictionary Server）是一个开源的内存数据结构存储系统，可以用作数据库、缓存和消息中间件。它使用ANSI C语言编写，支持网络功能，并提供高性能的键值对存储能力。‌

Redis支持多种类型的数据结构，包括字符串（String）、哈希（Hash）、列表（List）、集合（Set）、有序集合（ZSet）、位图（Bitmap）、超级日志（HyperLogLog）和地理空间（Geospatial）等。这些丰富的数据类型使得Redis能够满足多种应用场景的需求。Redis的所有数据都存储在内存中，这使得其读写性能非常出色，通常可以达到每秒执行10万次读写操作。

此外，Redis还提供了复制、Lua脚本、LRU缓存、事务和不同级别的磁盘持久化等功能，并通过哨兵模式（Sentinel）和集群模式（Cluster）提供高可用性。这些特性使得Redis在分布式系统中扮演着重要的角色

官网

https://redis.iohttps://redis.io/

中文网

https://www.redis.net.cnhttps://www.redis.net.cn/

数据类型

常见数据类型（5种）:

• 字符串 string

• 哈希 hash

• 列表 list

• 集合 set

• 有序集合 sorted set / zset

• 字符串 （string）：普通字符串 ，Redis中最简单的数据类型

• 哈希 （hash）：也叫作散列，类似于java中的Hash Map

• 列表 （list）：按照插入的顺序排序，可以有重复的元素，类似于java中的Linked List

• 集合 （set）：无序集合，没有重复的元素，类似于java中的Hashset

• 有序集合 （sorted set / zset）：集合中的每一个元素都关联一个分数（sort）,跟据分数升序排列，没有重复的元素

常用命令

字符串命令：

• 插入数据：set key value（相当于sql语句中的insert）

• setex key seconds value：插入数据的同时设置数据的存储时间

• setnx key value：当键不存在时才会插入数据

• 查询数据：get key（相当于sql语句中的select）

哈希操作命令：

• HSET key field value：将哈希表key中的字段field的值设置为value

• HGET key field：获取存储在哈希表中指定字段的值

• HDEL key field：删除存储在哈希表中的指定字段

• HKEYS key：获取哈希表中的所有字段

• HVALS key：获取哈希表中的所有值

列表操作命令：

• LPUSH key value1 [value2]：将一个或者多个值插入到列表的头部

• LRANGE key start stop：获取列表指定范围内的元素

• RPOP key：移除并获取列表最后一个元素

• LLEN key：获取列表长度

集合操作命令：

• SADD key member1 [member2]：向集合中添加一个或者多个成员

• SMEMBERS key：返回集合中的所有成员

• SCARD key：获取集合的成员数

• SINTER key1 [key2]：返回所有给定集合的交集

• SUNION key1 [key2]：返回所有给定集合的并集

• SREM key member1 [member2]：删除集合中一个或者多个成员

有序集合操作命令:

• ZADD key score1 member1 [score2 member2]：向有序集合中添加一个或者多个成员

• ZRANGE key start stop [WITHSCORES]：通过索引区间返回有序集合中指定区间内的成员

• ZINCRBY key increment member：有序集合中对指定成员的分数上增量increment

• ZREM key member [member...]：移除有序集合中的一个或者多个成员

通用命令：

• KEYS pattern：查找所有符合给定模式（pattern）的key

• EXSIS key：检查key是否存在

• TYPE key：返回key所存储的值的类型

• DEL key：当key存在时删除key

Redis的java客户端：

• Jedis

• Lettuce

• Spring Data Redis

Spring Data Redis是Spring的一部分，对Redis底层开发包进行了高度的封装

①导入Spring Data Redis 的maven坐标

②配置redis数据源

③编写配置类，创建RedisTemplate（Redis模板）对象

④通过RedisTemplate（Redis模板）对象操作redis

=========================改pom，添加相关依赖=========================================
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

========================写yml，声明相关配置信息=======================================
spring:
  redis:
    host: localhost
    port: 6379
    password: yourpassword  # 如果没有设置密码，可以省略这一行

==========================配置类设置================================================
@Configuration
@Slf4j
public class RedisConfiguration {
​
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        log.info("开始创建redis模板对象...");
        RedisTemplate redisTemplate = new RedisTemplate();
        //设置redis的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置redis key的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    };
}

/**
 * packageName com.sky.test
 *
 * @author 胡尔摩斯
 * @version 1.0
 * @version0 JDK 17
 * @className SpringDataRedisTest
 * @date 2024/12/8 11:49
 * @description TODO
 */
@SpringBootTest
public class SpringDataRedisTest {
​
    @Autowired//自动注入redis模板对象
    private RedisTemplate redisTemplate;
​
    @Test
    public void test() {
        System.out.println(redisTemplate);
​
        //获取各个数据类型的操作对象
        //获取字符串类型数据操作对象opsForValue()
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //获取哈希类型数据操作对象opsForHash()
        HashOperations hashOperations = redisTemplate.opsForHash();
        //获取列表类型数据操作对象opsForList()
        ListOperations listOperations = redisTemplate.opsForList();
        //获取集合数据类型操作对象opsForSet()
        SetOperations setOperations = redisTemplate.opsForSet();
        //获取有序集合数据类型操作对象opsForZSet()
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
​
    }
​
​
    /**
     * 操作字符串类型的数据
     */
    @Test
    public void testString(){
        redisTemplate.opsForValue().set("city","北京");
        String city = (String)redisTemplate.opsForValue().get("city");
        System.out.println(city);
​
        //设置带有过期时间的值
        redisTemplate.opsForValue().set("code","28256",3, TimeUnit.MINUTES);
        String code = (String)redisTemplate.opsForValue().get("code");
        System.out.println(code);
​
        //setIfAbsent方法用于在键不存在时设置其值。如果键已经存在，则不会更改其值。
        redisTemplate.opsForValue().setIfAbsent("name", "胡尔摩斯");
        redisTemplate.opsForValue().setIfAbsent("name", "吕蛋蛋");
    }
​
    /**
     * 操作哈希类型的数据
     */
    @Test
    public void testHash(){
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.put("person","name","吕蛋蛋");
        hashOperations.put("person","age","18");
        int age = (int) hashOperations.get("person", "age");
        String name = (String) hashOperations.get("person", "name");
        System.out.println(name+" 的年龄为 ："+age);
​
​
        //获取所有的key值
        Set keys = hashOperations.keys("person");
        System.out.println(keys);
​
        //获取所有的value值
        List values = hashOperations.values("person");
        System.out.println(values);
​
​
        //删除指定的key值
        hashOperations.delete("person", "age");
    }
​
    /**
     * 操作列表类型的数据
     */
    @Test
    public void testlist(){
        ListOperations listOperations = redisTemplate.opsForList();
        //一次性从左到右插入多个值
        listOperations.leftPushAll("detective","服部平次","工藤新一","夏洛克.福尔摩斯");
        //从左到右插入单个值
        listOperations.leftPush("detective","柯南.道尔");
​
        //指定查询索引范围内的数据
        List detective = listOperations.range("detective", 0, -1);
        System.out.println(detective);
​
        //rightPop方法从列表的右侧移除并返回最后一个元素。
        listOperations.rightPop("detective");
​
        //获取list长度
        Long size = listOperations.size("detective");
        System.out.println(size);
    }
​
    /**
     * 操作集合数类型的数据
     */
    @Test
    public void testSet(){
        SetOperations setOperations = redisTemplate.opsForSet();
​
        setOperations.add("girlfriend1","山内樱良","三笠.阿克曼","毛利兰","日向雏田","姬如雪");
        setOperations.add("girlfriend2","工藤有希子","日向雏田","灰原哀","东方淮竹","姬如雪");
​
        //查询集合数据
        Set girlfriend1 = setOperations.members("girlfriend1");
        System.out.println(girlfriend1);
​
        //获取集合元素个数
        Long size = setOperations.size("girlfriend1");
        System.out.println(size);
​
        //计算集合的交集
        Set intersect = setOperations.intersect("girlfriend1", "girlfriend2");
        System.out.println(intersect);
​
        //计算集合的并集
        Set union = setOperations.union("girlfriend1", "girlfriend2");
        System.out.println(union);
​
        //删除集合中的元素
        setOperations.remove("girlfriend1","山内樱良" );
    }
​
    /**
     * 操作有序集和类型数据
     */
    @Test
    public void testZSet(){
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
​
        zSetOperations.add("zset1","a",10);
        zSetOperations.add("zset1","b",20);
        zSetOperations.add("zset1","c",30);
​
        Set zset1 = zSetOperations.range("zset1", 0, -1);
        System.out.println(zset1);
​
        //给指定元素加分
        zSetOperations.incrementScore("zset1", "a", 1);
​
        zSetOperations.remove("zset1", "a");
    }
​
    /**
     * 通用操作
     */
    @Test
    public void testcommon(){
        Set keys = redisTemplate.keys("*");
        System.out.println(keys);
​
        Boolean name = redisTemplate.hasKey("name");
        System.out.println(name);
        
        //查询指定key的数据类型
        redisTemplate.type("name");
        //删除指定的key
        redisTemplate.delete("name");
    }
}

操作Redis字符串数据类型的常见API

1. set(K key, V value)

   • 设置指定键的值。如果键已经存在，则覆盖旧值。

2. get(Object key)

   • 获取指定键的值。如果键不存在，则返回null。

3. append(K key, String value)

   • 将指定的值追加到存储在键上的现有值的末尾。如果键不存在，则将其视为空字符串，并设置该值。

4. setIfAbsent(K key, V value)

   • 仅在键不存在时设置键的值。如果键已经存在，则不进行任何操作。

5. delete(Object key)

   • 删除指定的键及其关联的值。

操作Redis哈希数据类型的常见API

1. put(H key, HK hashKey, HV value)

   • 将哈希表key中的字段hashKey的值设置为value。如果hashKey已存在，则更新其值；如果不存在，则添加新字段。

2. putAll(H key, Map<? extends HK, ? extends HV> m)

   • 将map中的所有键值对添加到哈希表key中。这相当于批量执行put操作。

3. get(H key, Object hashKey)

   • 获取哈希表key中字段hashKey的值。如果字段不存在，则返回null。

4. delete(H key, Object... hashKeys)

   • 删除哈希表key中的一个或多个字段hashKeys。如果字段不存在，则忽略该操作。、

5. keys(H key)

   • 获取哈希表key中所有字段的键。

6. values(H key)

   • 获取哈希表key中所有字段的值。

7. hasKey(H key, Object hashKey)

   • 判断哈希表key中是否存在字段hashKey。

操作Redis列表数据类型的常见API

1. leftPush(K key, V value)

   • 将值value推入列表key的左端。如果key不存在，一个空列表会被创建并执行LPUSH操作。当key存在但不是列表类型时，返回一个错误。

2. leftPushAll(K key, V... values)

   • 将一个值列表values中的所有值依次推入列表key的左端。如果key不存在，一个空列表会被创建并执行LPUSH操作。当key存在但不是列表类型时，返回一个错误。

3. rightPush(K key, V value)

   • 将值value推入列表key的右端。如果key不存在，一个空列表会被创建并执行RPUSH操作。当key存在但不是列表类型时，返回一个错误。

4. rightPushAll(K key, V... values)

   • 将一个值列表values中的所有值依次推入列表key的右端。如果key不存在，一个空列表会被创建并执行RPUSH操作。当key存在但不是列表类型时，返回一个错误。

5. leftPop(K key)

   • 移除并返回列表key的左端元素。如果key不存在，返回null。当key存在但不是列表类型时，返回一个错误。

6. rightPop(K key)

   • 移除并返回列表key的右端元素。如果key不存在，返回null。当key存在但不是列表类型时，返回一个错误。

7. range(K key, long start, long end)

   • 返回列表key中指定区间内的元素，区间以0为起始索引，以-1为结束索引表示列表的最后一个元素。

8. size(K key)

   • 返回列表key的长度。如果key不存在，返回0。当key存在但不是列表类型时，返回一个错误。

9. trim(K key, long start, long end)

   • 对一个已存在的列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。

10. remove(K key, long count, Object value)

    • 根据参数count的值，移除列表中与参数value相等的元素。count的值可以是以下几种：
      • count > 0: 从头往尾移除与value相等的元素，移除count个。
      • count < 0: 从尾往头移除与value相等的元素，移除|count|个。
      • count = 0: 移除列表中所有与value相等的元素。

操作Redis集合数据类型的常见API

1. add(K key, V... values)

   • 将一个或多个值添加到集合key中。如果某个值已经存在于集合中，则不会重复添加。

2. remove(K key, Object... values)

   • 从集合key中移除一个或多个值。如果值不存在于集合中，则忽略该操作。

3. pop(K key)

   • 随机移除并返回集合key中的一个元素。如果集合为空，则返回null。

4. members(K key)

   • 返回集合key中的所有元素。

5. size(K key)

   • 返回集合key中的元素数量。

6. move(K key, Object value, K destKey)

   • 将集合key中的元素value移动到集合destKey中。如果value存在于key中，则从key中移除它，并将其添加到destKey中。如果value不存在于key中，则忽略该操作。如果destKey不存在，则将其创建为一个空集合。

7. union(K key, K otherKey)

   • 返回集合key和集合otherKey的并集。

8. intersection(K key, K otherKey)

   • 返回集合key和集合otherKey的交集。

9. difference(K key, K otherKey)

   • 返回集合key中存在但集合otherKey中不存在的元素。

操作Redis有序集合数据类型的常见API

1. add(K key, V value, double score)

   • 将一个成员及其分数添加到有序集合中。如果成员已存在，则更新其分数。

2. add(K key, Set<TypedTuple> tuples)

   • 批量将成员及其分数添加到有序集合中。每个TypedTuple对象包含一个成员和一个分数。

3. remove(K key, Object... values)

   • 从有序集合中移除一个或多个成员。

4. incrementScore(K key, V value, double delta)

   • 为有序集合中的指定成员增加分数。如果成员不存在，则将其添加到集合中，并设置分数为delta。

5. score(K key, Object o)

   • 返回有序集合中指定成员的分数。

6. size(K key)

   • 返回有序集合中成员的数量。

7. range(K key, long start, long end)

   • 返回有序集合中指定排名范围内的成员。排名是从0开始的，end参数可以是-1，表示返回所有成员。

8. rangeWithScores(K key, long start, long end)

   • 返回有序集合中指定排名范围内的成员及其分数。

9. removeRangeByScore(K key, double min, double max)

   • 移除有序集合中分数在指定范围内的成员。

10. unionAndStore(K key, K otherKey, K destKey)

    • 计算两个有序集合的并集，并将结果存储在destKey中。如果destKey已经存在，则覆盖它。

11. intersectAndStore(K key, K otherKey, K destKey)

    • 计算两个有序集合的交集，并将结果存储在destKey中。如果destKey已经存在，则覆盖它。