数据类型

Redis存储的是key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型：

  • 字符串 —— string

  • 哈希 —— hash

    适合存储对象。

  • 列表 —— list

    按照插入顺序排序，可以有重复元素。可以用来做任务队列。

  • 集合 —— set

    无序集合，没有重复元素（后插入的元素会覆盖已有的相同元素）。

  • 有序集合 —— sorted set

    有序集合（使用分值进行排序），没有重复元素。

常用命令

Redis命令符不区分大小写，但是key是区分大小写的。 更多命令请参考Redis中文网。

字符串操作命令

1SET key value
  • 设置指定key的值。
  • key相同的情况下，后设的值会覆盖前面的值。
1GET key
  • 获取指key的值。
1SETEX key seconds value
  • 设置指定key的值，并将key的过期时间设为seconds秒。
1SETNX key value

  • 只有在key不存在时设置key的值。

  • 如：

    1> SETNX key1 value1
21
3> SETNX key1 value2
40
5> GET key1
6value1

哈希操作命令

Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。

1HSET key field value
  • 将哈希表key种的字段field的值设为value。
1HGET key field
  • 获取存储在哈希表中指定字段的值。
1HDEL key field
  • 删除存储在哈希表中的指定字段。
1HKEYS key
  • 获取哈希表中所有字段。
1HVALS key
  • 获取哈希表中所有值。
1HGETALL key
  • 获取在哈希表中指定key的所有字段和值。

列表操作命令

1LPUSH key value1 [value2 ...]
  • 将一个或多个值插入到列表头部。
1LRANGE key start stop
  • 获取列表指定范围内的元素（start到stop，索引从0开始）。
1RPOP key
  • 移除并获取列表最后一个元素。
1LLEN key
  • 获取列表长度。
1BRPOP key1 [key2 ...] timeout
  • 移除并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时（timeout秒）或（在指定的key中）发现可弹出元素为止。

集合操作命令

Redis set是string类型的无序集合，集合成员是唯一的。

1SADD key member1 [member2 ...]
  • 向集合添加一个或多个成员。
1SMEMBERS key
  • 返回集合中的所有成员。
1SCARD key
  • 获取集合的成员数。
1SINTER key1 [key2 ...]
  • 返回给定所有集合的交集。
1SUNION key1 [key2 ...]
  • 返回所有给定集合的并集。
1SDIFF key1 [key2 ...]
  • 返回给定所有集合的差集（左差集，即key1集合中在其他集合没有的元素集合）。
1SREM key member1 [member2 ...]
  • 移除集合中一个或多个成员。

有序集合操作命令

Redis sorted set 是string类型元素的集合，且不允许重复的成员。每个元素都会关联一个double类型的分数（score）。Redis通过分数来为集合中的成员进行从小到大排序，有序集合的成员是唯一的，但分数却可以重复。

1ZADD key score1 member1 [score2 member2 ...]
  • 向有序集合添加一个或多个成员，或者更新已存在成员的分数。
1ZRANGE key start stop [WITHSCOES]
  • 通过索引区间返回有序集合中指定区间内的成员。使用WITHSCOES可以返回成员的分数。
1ZINCRBY key increment member
  • 有序集合中对指定成员的分数加上增量increment。
1ZREM key member [member ...]
  • 移除有序集合中的一个或多个成员。

通用命令

1KEYS pattren
  • 查找所有符合给定模式（pattern）的key。
1EXISTS key
  • 检查给定key是否存在。
1TYPE key
  • 返回key所存储的值的类型。
1TTL key
  • 返回给定key的剩余生存时间（TTL，time to live），以秒为单位。
1DEL key1 [key2 ...]

  • 该命令用于在key存在时删除key。

  • 如：

    1> TTL key
2-1

    返回-1表示永久存活。

切换数据库

Redis 默认是在0号数据库中执行操作。如果想要切换数据库，可以使用：

1SELECT number

如：

1127.0.0.1:6379> SELECT 1
2OK
3127.0.0.1:6379[1]>

Redis 默认提供了16个数据库。

要修改该配置可以在redis.conf中修改databases的数量。

1databash 16

Spring Data Redis

依赖

Spring Data Redis的依赖坐标为：

1<!-- Spring Date Redis -->
2<dependency>
3    <groupId>org.springframework.boot</groupId>
4    <artifactId>spring-boot-starter-data-redis</artifactId>
5    <!-- version在spring-boot-starter-parent中定义 -->
6</dependency>

配置

application.yml：

 1spring:
 2  application:
 3    name: springdataredis-demo
 4  # Redis相关配置
 5  data:
 6    redis:
 7      host: localhost
 8      port: 6379
 9      password: 123456
10      database: 0       # 操作0号数据库
11      jedis:
12        # Redis连接池配置
13        pool:
14          max-active: 8 # 最大连接数
15          max-wait: 1ms # 连接池最大阻塞等待时间
16          max-idle: 4   # 连接池中的最大空闲连接
17          min-idle: 0   # 连接池中的最小空闲连接

配置类（修改默认序列化器，防止因序列化在Redis上产生乱码，但并不妨碍读值。因为读取时会自动反序列化）：

 1@Configuration
 2public class RedisConfig extends CachingConfigurerSupport {
 3
 4    @Bean
 5    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
 6
 7        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
 8
 9        // 默认的Key序列化器为：JdkSerializationRedisSerializer
10        redisTemplate.setKeySerializer(new StringRedisSerializer());
11        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
12
13        redisTemplate.setConnectionFactory(connectionFactory);
14
15        return redisTemplate;
16    }
17
18}

测试

  1@SpringBootTest
  2@RunWith(SpringRunner.class)
  3public class SpringDataRedisTest {
  4    @Autowired
  5    private RedisTemplate redisTemplate;
  6
  7    /**
  8     * 操作字符串类型数据
  9     */
 10    @Test
 11    public void testString() {
 12        // 获得String类型数据操作对象
 13        ValueOperations valueOperations = redisTemplate.opsForValue();
 14
 15        valueOperations.set("city", "guangzhou");
 16
 17        String city = (String) valueOperations.get("city");
 18        System.out.println(city);
 19
 20        // 设置超时
 21        valueOperations.set("key1", "value1", 10L, TimeUnit.SECONDS);
 22
 23        // 不存在才设置
 24        Boolean setIfAbsent1 = valueOperations.setIfAbsent("city", "foshang");
 25        System.out.println(Boolean.TRUE.equals(setIfAbsent1) ? "city设置成功" : "city已存在");
 26        Boolean setIfAbsent2 = valueOperations.setIfAbsent("city_name", "foshang",
 27                                                   10L, TimeUnit.SECONDS);
 28        Object cityName = valueOperations.get("city_name");
 29        System.out.println(setIfAbsent2 ? "city_name设置成功:" + cityName
 30                                        : "city_name已存在");
 31    }
 32
 33    /**
 34     * 操作哈希类型数据
 35     */
 36    @Test
 37    public void testHash() {
 38        HashOperations hashOperations = redisTemplate.opsForHash();
 39
 40        String id = "002";
 41        // 存值
 42        hashOperations.put(id, "name", "xiaoming");
 43        hashOperations.put(id, "age", "20");
 44        hashOperations.put(id, "address", "guangzhou");
 45
 46        // 取值
 47        String name = (String) hashOperations.get(id, "name");
 48        String age = (String) hashOperations.get(id, "age");
 49        String address = (String) hashOperations.get(id, "address");
 50        System.out.println("name:" + name + ",age:" + age + ",address:" + address);
 51
 52        // 获取hash结构中的所有字段
 53        Set keys = hashOperations.keys(id);
 54        for (Object key : keys) {
 55            System.out.println(key);
 56        }
 57
 58        // 删除
 59        //hashOperations.delete(keys, "address", "age");
 60
 61        // 获得hash结构中的所有值
 62        List<String> values = hashOperations.values(id);
 63        for (String value : values) {
 64            System.out.println(value);
 65        }
 66    }
 67
 68    /**
 69     * 操作列表类型数据
 70     */
 71    @Test
 72    public void testList() {
 73        ListOperations listOperations = redisTemplate.opsForList();
 74
 75        String key = "mylist";
 76        // 存储
 77        listOperations.leftPush(key, "a");
 78        listOperations.leftPushAll(key, "b", "c", "d");
 79
 80        // 取值
 81        System.out.printf("入队：");
 82        List<String> myList = listOperations.range(key, 0, -1);
 83        for (String s : myList) {
 84            System.out.printf(s + " ");
 85        }
 86        System.out.println();
 87
 88        // 获得列表长度 llen
 89        int size = listOperations.size(key).intValue();
 90        System.out.printf("出队：");
 91        for (int i = 0; i < size; i++) {
 92            // 出队列
 93            String element = (String) listOperations.rightPop(key);
 94            System.out.printf(element + " ");
 95        }
 96        System.out.println();
 97    }
 98
 99    /**
100     * 操作集合类型数据
101     */
102    @Test
103    public void testSet() {
104        SetOperations setOperations = redisTemplate.opsForSet();
105
106        String key = "myset";
107        // 存值
108        setOperations.add(key, "a", "b", "c", "d", "a");
109
110        // 取值
111        Set<String> myset = setOperations.members(key);
112        for (String s : myset) {
113            System.out.printf(s + " ");
114        }
115        System.out.println();
116
117        // 删除成员
118        setOperations.remove(key, "a", "b");
119
120        // 取值
121        myset = setOperations.members(key);
122        for (String s : myset) {
123            System.out.printf(s + " ");
124        }
125        System.out.println();
126    }
127
128    /**
129     * 操作有序集合类型数据
130     */
131    @Test
132    public void testZset() {
133        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
134
135        String key = "myZset";
136        // 存储
137        zSetOperations.add(key, "a", 10.);
138        zSetOperations.add(key, "b", 11.);
139        zSetOperations.add(key, "c", 12.);
140        zSetOperations.add(key, "d", 13.);
141        zSetOperations.add(key, "a", 14.);
142
143        // 取值
144        Set<String> range = zSetOperations.range(key, 0, -1);
145        for (String s : range) {
146            System.out.printf(s + " ");
147        }
148        System.out.println();
149
150        // 修改分数
151        zSetOperations.incrementScore(key, "b", 20.);
152
153        // 删除成员
154        zSetOperations.remove(key, "a", "c");
155
156        // 取值
157        range = zSetOperations.range(key, 0, -1);
158        for (String s : range) {
159            System.out.printf(s + " ");
160        }
161        System.out.println();
162    }
163
164    /**
165     * 通用操作
166     */
167    @Test
168    public void testCommon() {
169        // 获取Redis中所有key
170        Set<String> keys = redisTemplate.keys("*");
171        for (String key : keys) {
172            System.out.println(key);
173        }
174
175        // 判断m某个key是否存在
176        Boolean hasKey = redisTemplate.hasKey("linner");
177        System.out.println(hasKey ? "linner存在" : "linner不存在");
178
179        // 删除指定key
180        redisTemplate.delete("myZset");
181
182        // 获取指定key对应的value的数据类型
183        DataType dataType = redisTemplate.type("myset");
184        System.out.println(dataType.name());
185    }
186}