《Try Redis》笔记

最新推荐文章于 2024-08-11 10:32:52 发布

captxb

最新推荐文章于 2024-08-11 10:32:52 发布

阅读量107

点赞数

分类专栏： Redis相关

本文链接：https://blog.csdn.net/captxb/article/details/90114130

版权

Redis相关专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。它支持多种类型的数据结构，如字符串（strings），散列（hashes），列表（lists），集合（sets），有序集合（sorted sets）与范围查询， bitmaps， hyperloglogs 和地理空间（geospatial）索引半径查询
Redis 内置了复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions）和不同级别的磁盘持久化（persistence），并通过 Redis哨兵（Sentinel）和自动分区（Cluster）提供高可用性（high availability）。
Redis支持

(1) 基本类型: int, double…

(2) 字符串

(3) list
Redis__区分大小写__

connection和CONNECTION是两个变量
redis-cli -h {host} -p {port}

和主机名为host、端口号为port上的redis进行交互

Redis Command

  DECR
  
  DECRBY
  
  DEL
  
  EXISTS
  
  EXPIRE
  
  GET
  
  GETSET
  
  HDEL
  
  HEXISTS
  
  HGET
  
  HGETALL
  
  HINCRBY
  
  HKEYS
  
  HLEN
  
  HMGET
  
  HMSET
  
  HSET
  
  HVALS
  
  INCR
  
  INCRBY
  
  KEYS
  
  LINDEX
  
  LLEN
  
  LPOP
  
  LPUSH
  
  LRANGE
  
  LREM
  
  LSET
  
  LTRIM
  
  MGET
  
  MSET
  
  MSETNX
  
  MULTI
  
  PEXPIRE
  
  RENAME
  
  RENAMENX
  
  RPOP
  
  RPOPLPUSH
  
  RPUSH
  
  SADD
  
  SCARD
  
  SDIFF
  
  SDIFFSTORE
  
  SET
  
  SETEX
  
  SETNX
  
  SINTER
  
  SINTERSTORE
  
  SISMEMBER
  
  SMEMBERS
  
  SMOVE
  
  SORT
  
  SPOP
  
  SRANDMEMBER
  
  SREM
  
  SUNION
  
  SUNIONSTORE
  
  TTL
  
  TYPE
  
  ZADD
  
  ZCARD
  
  ZCOUNT
  
  ZINCRBY
  
  ZRANGE
  
  ZRANGEBYSCORE
  
  ZRANK
  
  ZREM
  
  ZREMRANGEBYSCORE
  
  ZREVRANGE
  
  ZSCORE

Redis is what is called a key-value store, often referred to as a NoSQL database. The essence of a key-value store is the ability to store some data, called a value, inside a key. This data can later be retrieved only if we know the exact key used to store it. We can use the command SET to store the value “fido” at key “server:name”:
```
  SET server:name "fido"
```
Redis will store our data permanently, so we can later ask “What is the value stored at key server:name?” and Redis will reply with “fido”:
```
  GET server:name => "fido"
```
Tip: You can click the commands above to automatically execute them. The text after the arrow (=>) shows the expected output.
Other common operations provided by key-value stores are DEL to delete a given key and associated value, SET-if-not-exists (called SETNX on Redis) that sets a key only if it does not already exist, and INCR to atomically increment a number stored at a given key:
```
  SET connections 10
  INCR connections => 11
  INCR connections => 12
  DEL connections
  INCR connections => 1
```
There is something special about INCR. Why do we provide such an operation if we can do it ourself with a bit of code? After all it is as simple as:
```
  x = GET count
  x = x + 1
  SET count x
```
The problem is that doing the increment in this way will only work as long as there is a single client using the key. See what happens if two clients are accessing this key at the same time:
```
  Client A reads count as 10.
  Client B reads count as 10.
  Client A increments 10 and sets count to 11.
  Client B increments 10 and sets count to 11.
```
We wanted the value to be 12, but instead it is 11! This is because incrementing the value in this way is not an atomic operation. Calling the INCR command in Redis will prevent this from happening, because it is an atomic operation.

Redis provides many of these atomic operations on different types of data.
Redis can be told that a key should only exist for a certain length of time. This is accomplished with the EXPIRE and TTL commands.
```
  SET resource:lock "Redis Demo"
  EXPIRE resource:lock 120
```
This causes the key resource:lock to be deleted in 120 seconds. You can test how long a key will exist with the TTL command. It returns the number of seconds until it will be deleted.
```
  TTL resource:lock => 113
  // after 113s
  TTL resource:lock => -2
```
The -2 for the TTL of the key means that the key does not exist (anymore). A -1 for the TTL of the key means that it will never expire.

Note that if you SET a key, its TTL will be reset.
```
  SET resource:lock "Redis Demo 1"
  EXPIRE resource:lock 120
  TTL resource:lock => 119
  SET resource:lock "Redis Demo 2"
  TTL resource:lock => -1
```
Redis also supports several more complex data structures. The first one we’ll look at is a list. A list is a series of ordered values. Some of the important commands for interacting with lists are RPUSH, LPUSH, LLEN, LRANGE, LPOP, and RPOP. You can immediately begin working with a key as a list, as long as it doesn’t already exist as a different type.

(1) RPUSH puts the new value at the end of the list.
```
  RPUSH friends "Alice"
  RPUSH friends "Bob"
```
(2) LPUSH puts the new value at the start of the list.
```
  LPUSH friends "Sam"
```
(3) LRANGE gives a subset of the list. It takes the index of the first element you want to retrieve (begin with 0, inclusive) as its first parameter and the index of the last element you want to retrieve(inclusive) as its second parameter. A value of -1 for the second parameter means to retrieve elements until the end of the list.
```
  LRANGE friends 0 -1 => 1) "Sam", 2) "Alice", 3) "Bob"
  LRANGE friends 0 1 => 1) "Sam", 2) "Alice"
  LRANGE friends 1 2 => 1) "Alice", 2) "Bob"
```
(4) LLEN returns the current length of the list.
```
  LLEN friends => 3
```
(5) LPOP removes the first element from the list and returns it.
```
  LPOP friends => "Sam"
```
(6) RPOP removes the last element from the list and returns it.
```
  RPOP friends => "Bob"
```
Note that the list now only has one element:
```
  LLEN friends => 1
  LRANGE friends 0 -1 => 1) "Alice"
```
The next data structure that we’ll look at is a set. A set is similar to a list, except it does not have a specific order and each element may only appear once. Some of the important commands in working with sets are SADD, SREM, SISMEMBER, SMEMBERS and SUNION.

(1) SADD adds the given value to the set.
```
  SADD superpowers "flight"
  SADD superpowers "x-ray vision"
  SADD superpowers "reflexes"
```
(2) SREM removes the given value from the set.
```
  SREM superpowers "reflexes"
```
(3) SISMEMBER tests if the given value is in the set. It returns 1 if the value is there and 0 if it is not.
```
  SISMEMBER superpowers "flight" => 1
  SISMEMBER superpowers "reflexes" => 0
```
(4) SMEMBERS returns a list of all the members of this set.
```
  SMEMBERS superpowers => 1) "flight", 2) "x-ray vision"
```
(5) SUNION combines two or more sets and returns the list of all elements (but never modify the two or more sets).
```
  SADD birdpowers "pecking"
  SADD birdpowers "flight"
  SUNION superpowers birdpowers => 1) "pecking", 2) "x-ray vision", 3) "flight"
```
Sets are a very handy data type, but as they are unsorted they don’t work well for a number of problems

A sorted set is similar to a regular set, but now each value has an associated score. This score is used to sort the elements in the set.

  ZADD hackers 1940 "Alan Kay"
  ZADD hackers 1906 "Grace Hopper"
  ZADD hackers 1953 "Richard Stallman"
  ZADD hackers 1965 "Yukihiro Matsumoto"
  ZADD hackers 1916 "Claude Shannon"
  ZADD hackers 1969 "Linus Torvalds"
  ZADD hackers 1957 "Sophie Wilson"
  ZADD hackers 1912 "Alan Turing"

In these examples, the scores are years of birth and the values are the names of famous hackers.

  ZRANGE hackers 2 4 => 1) "Claude Shannon", 2) "Alan Kay", 3) "Richard Stallman"

Simple strings, sets and sorted sets already get a lot done but there is one more data type Redis can handle: Hashes.

(1) Hashes are maps between string fields and string values, so they are the perfect data type to represent objects (eg: A User with a number of fields like name, surname, age, and so forth):
```
  HSET user:1000 name "John Smith"
  HSET user:1000 email "john.smith@example.com"
  HSET user:1000 password "s3cret"
```
(2) To get back the saved data use HGETALL:
```
  HGETALL user:1000
```
(3) You can also set multiple fields at once use HMSET:
```
  HMSET user:1001 name "Mary Jones" password "hidden" email "mjones@example.com"
```
(4) If you only need a single field value that is possible as well use HGET:
```
  HGET user:1001 name => "Mary Jones"
```
(5) Numerical values in hash fields are handled exactly the same as in simple strings and there are operations to increment this value in an atomic way.
```
  HSET user:1000 visits 10
  HINCRBY user:1000 visits 1 => 11
  HINCRBY user:1000 visits 10 => 21
  HDEL user:1000 visits
  HINCRBY user:1000 visits 1 => 1
```