Introduction to Redis and introduction to Redis deployment, principles and usage

[Chapter 1]-NoSQL background knowledge review

What is NoSQL

The most common explanation for NoSQL is "non-relational", and usually many people also say it is explained as "Not Only SQL"
NoSQL is just a concept, generally referring to non-relational databases
Different from relational databases, they do not guarantee the ACID properties of relational data
NoSQL is a brand-new revolutionary database movement that advocates the use of non-relational data storage. Compared with the overwhelming application of relational databases, this concept is undoubtedly an injection of new thinking.

Features of NoSQL

Application scenarios

Highly concurrent reading and writing
Massive data reading and writing
High scalability
high speed

Unsuitable application scenarios

Scenarios that require transaction support
SQL-based structured query storage, processing complex relationships and requiring ad hoc queries

Common NoSQL databases

memcache

NoSql database that appeared very early
The data is all in memory and generally not persisted.
Supports simple key-value mode
Generally, it is a database used as a cache database to assist persistence.

redis

Almost covers most of the functions of Memcached
The data is all in memory, supports persistence, and is mainly used for backup and recovery.
In addition to supporting simple key-value mode, it also supports the storage of multiple data structures, such as list, set, hash, zset, etc.
Generally, it is a database used as a cache database to assist persistence.
An in-memory database that is widely used and popular on the market today

mongoDB

High-performance, open source, schema free document database
The data is all in the memory. If the memory is insufficient, the less commonly used data is saved to the hard disk.
Although it is a key-value mode, it provides rich query functions for value (especially json)
Supports binary data and large objects
RDBMS can be replaced according to the characteristics of the data and become an independent database. Or cooperate with RDBMS to store specific data

HBase

Strong consistency read/write
- HBASE is not an "eventually consistent" data store
- It is well suited for tasks such as high-speed counter aggregation
Automatic chunking
- HBase tables are distributed on the cluster through Regions. As data grows, regions are automatically split and redistributed.
Automatic RegionServer failover
Hadoop/HDFS integration
- HBase supports HDFS out of the box as its distributed file system
MapReduce
- HBase supports massively parallel processing via MapReduce, using HBase as source and sink
Operation management
- HBase provides built-in web pages for business insights and JMX metrics

[Chapter 2]-Introduction to Redis

Introduction to Redis

Redis Chinese official website

Redis Chinese official website: http://www.redis.cn/

The official website can quickly check common commands, user manuals, community communication, download installation packages, etc.

Redis basic knowledge

Redis is one of the more popular NoSQL frameworks currently
It is an open source key-value storage system written in ANSI C language (different from MySQL's two-dimensional table storage)
Similar to Memcache, but it largely compensates for the shortcomings of Memcache. Redis data is cached in computer memory. The difference is that Memcache can only cache data in memory and cannot automatically and regularly write to the hard disk. This means that once Power outage or restart, memory cleared, data lost

Common business usage scenarios of Redis

Scenario 1: Get the latest N data

For example, to typically get the latest comments on a website article, you can put the latest 5,000 comment IDs in the Redis List collection, and get the parts beyond the collection from the database.

Scenario 2: Applied to various rankings to obtain TOP N operations

The difference between this scenario and the above need to get the latest N data is that the previous operation uses time as the weight, and this TOP N is based on a certain condition as the weight, such as sorting by the number of likes, you can use Redis' sorted set , set the value to be sorted to the score of the sorted set, set the specific data to the corresponding value, and only need to execute one ZADD command each time.

Redis zadd, the command is used to add one or more member elements and their score values to an ordered set (just understand it simply)

If a member is already a member of the ordered set, update the member's score and re-insert the member element to ensure that the member is in the correct position.

Fractional values can be integer values or double-precision floating point numbers.

If the sorted set key does not exist, create an empty sorted set and perform the zadd operation

When key exists but is not an ordered set type, an error is returned

Scenario 3: Applications that require precise expiration time settings

For example, you can set the score value of the sorted set mentioned in Scenario 2 above to the timestamp of the expiration time. Then you can simply sort by the expiration time and clear the expired data regularly. Not only does it clear the expired data in Redis, you can also You can think of the expiration time in Redis as an index of data in the database. Use Redis to find out which data needs to be expired and delete it, and then accurately delete the corresponding records from the database.

Scenario 4: Counter application

Redis commands are all atomic. You can easily use INCR and DECR commands to build a counter system.

Command:
incr key adds 1 to the value stored in key, and uses the final result as the return value;
decr key adds -1 to the value stored in key, and uses the final result as the return value;

Scenario 5: Uniq operation to obtain all data deduplication values for a certain period of time

It is most suitable to use the set data structure of Redis. You only need to keep throwing data into the set. Set means collection, so it will be automatically deduplicated.

Scenario 6: Real-time system, anti-spam system

Through the set function mentioned in Scenario 5 above, the background can obtain whether an end user has performed a certain operation at this time, and can find the set of operations and perform analysis and statistical comparison.

Scenario 7: Caching

Store data directly into memory, with better performance than Memcached and more diverse data structures.

Features of Redis

Efficiency
- The reading speed of Redis is 110,000 times/s and the writing speed is 81,000 times/s.
atomicity
- All operations of Redis are atomic, and Redis also supports atomic execution of several operations after they are fully merged.
Supports multiple data structures
- string
- list
- hash
- set
- zset (ordered set)
Stability: persistence, master-slave replication (cluster)
Other features: Support expiration time, support transactions, message subscription

To support transactions here, please note that redis transactions do not support complete acid transactions. Although redis provides transaction functions, redis transactions are not the same as relational database transactions. Redis transactions can only guarantee isolation and consistency. Atomicity and durability are not guaranteed.

[Chapter 3]-Redis stand-alone environment installation

All the various installation and deployment methods of redis are archived in "Redis Various Methods of Deployment" https://blog.csdn.net/wt334502157/article/details/123211953. If you just want to check the installation and deployment, you can refer to the installation and deployment article practice. This document is relatively large and focuses on the combing and sharing of all redis knowledge and the introduction of the development API. Of course, it also includes installation and deployment content.

Redis stand-alone environment linux installation and deployment

The official download address of the redis installation package

You can download any version at the official download address: http://download.redis.io/releases/

You can install the installation version as needed. The method and process are basically the same.

redis installation and deployment

[root@redis01 ~]# cat /etc/redhat-release 
CentOS Linux release 7.4.1708 (Core)
[root@redis01 ~]# mkdir -p /opt/software
[root@redis01 ~]# cd /opt/software
[root@redis01 software]# wget http://download.redis.io/releases/redis-3.2.8.tar.gz
[root@redis01 software]# tar -xf redis-3.2.8.tar.gz
[root@redis01 software]# ln -s redis-3.2.8 redis
[root@redis01 software]# ll
total 4
lrwxrwxrwx 1 root root   11 Sep 12 16:55 redis -> redis-3.2.8
drwxrwxr-x 6 root root 4096 Sep 12 16:52 redis-3.2.8
[root@redis01 redis]# cd redis
[root@redis01 redis]# make && make install
...
...
[root@redis01 redis]# mkdir /data
[root@redis01 redis]# mkdir -p /opt/software/redis/logs/
[root@redis01 redis]# vim redis.conf 
#常用需要更改的配置项:
daemonize yes  # 是否以守护进程启动
pidfile /opt/software/redis/redis_6379.pid   # 进程号文件的位置
port 6379    # 端口号
dir "/root/redis/data"  # 数据目录
logfile "/opt/software/redis/logs/6379.log"  # 日志位置及日志文件名
bind 0.0.0.0        # 0.0.0.0 可以远程访问
protected-mode no  # 保护模式

Start and shut down redis

# 启动redis
[root@redis01 redis]# /opt/software/redis/src/redis-server /opt/software/redis/redis.conf 
[root@redis01 redis]# 
[root@redis01 redis]# netstat -tnlpu|grep 6379
tcp        0      0 0.0.0.0:6379            0.0.0.0:*               LISTEN      4475/redis-server 0 
[root@redis01 redis]# ps -ef | grep redis|grep -v grep 
root      4475     1  0 17:08 ?        00:00:00 /opt/software/redis/src/redis-server 0.0.0.0:6379
# 关闭redis
[root@redis01 redis]# src/redis-cli -h 127.0.0.1 shutdown
[root@redis01 redis]# netstat -tnlpu|grep 6379
[root@redis01 redis]# ps -ef | grep redis|grep -v grep 
[root@redis01 redis]# 
# 此时redis已经被关闭,再次启动redis
[root@redis01 redis]# /opt/software/redis/src/redis-server /opt/software/redis/redis.conf

Connect redis

# -h指定redis的服务ip地址，不加默认本地localhost
[root@redis01 redis]# src/redis-cli -h 39.101.78.174
39.101.78.174:6379> 
# 当输入ping命令时，如果redis可以返回PONG，则连接正常
39.101.78.174:6379> ping
PONG

[Chapter 4]-Introduction to Redis data types

The five most commonly used data types in Redis

Type 1: String string operations

1. Set the value of the specified key

SET key value

39.101.78.174:6379> SET hello world
OK

2. Get the value of the specified key

GET key

39.101.78.174:6379> GET hello
"world"

3. Set the value of the given key to value and return the old value of the key

GETSET key value

39.101.78.174:6379> GETSET hello newworld
"world"
39.101.78.174:6379> GET hello
"newworld"

4. Get the values of all (one or more) given keys

MGET key1 key2 [key3…]

39.101.78.174:6379> SET k1 v1
OK
39.101.78.174:6379> SET k2 v2
OK
39.101.78.174:6379> SET k3 v3
OK
39.101.78.174:6379> MGET k1 k2 k3
1) "v1"
2) "v2"
3) "v3"
39.101.78.174:6379>

5. Associate the value value to the key and set the expiration time of the key to seconds (in seconds)

SETEX key seconds value

39.101.78.174:6379> SETEX hello 10 world3
OK
39.101.78.174:6379> get hello
"world3"
# 等待超过10秒后再次查询
39.101.78.174:6379> get hello
(nil)
39.101.78.174:6379>

6. Only set the value of key when the key does not exist

SETNX key value

39.101.78.174:6379> GET k3
"v3"
39.101.78.174:6379> SETNX k3 v33
(integer) 0
# k3已有v3的值所以设置失败
39.101.78.174:6379> GET k3
"v3"
39.101.78.174:6379> SETNX k4 v4
(integer) 1
39.101.78.174:6379> GET k4
"v4"
39.101.78.174:6379> SETNX k4 v44
(integer) 0
39.101.78.174:6379> GET k4
"v4"
39.101.78.174:6379>

7. Return the length of the string value stored in key

STRLEN key

39.101.78.174:6379> SET a a
OK
39.101.78.174:6379> SET bb bb
OK
39.101.78.174:6379> SET ccc ccc
OK
39.101.78.174:6379> SET dddd dddd
OK
39.101.78.174:6379> STRLEN a
(integer) 1
39.101.78.174:6379> STRLEN bb
(integer) 2
39.101.78.174:6379> STRLEN ccc
(integer) 3
39.101.78.174:6379> STRLEN dddd
(integer) 4
39.101.78.174:6379> STRLEN k1
(integer) 2
39.101.78.174:6379> STRLEN k2
(integer) 2

8. Set one or more key-value pairs at the same time

MSET key value [key value …]

39.101.78.174:6379> MSET k5 v5 k6 v6 k7 v7
OK
39.101.78.174:6379> GET k5
"v5"
39.101.78.174:6379> GET k6
"v6"
39.101.78.174:6379> GET k7
"v7"
39.101.78.174:6379>

9. Set one or more key-value pairs at the same time, if and only if all given keys do not exist

MSETNX key value [key value …]

39.101.78.174:6379> MSETNX k7 v7 k8 v8 k9 v9 k10 v10
(integer) 0
# 因为k7-k10中，k7已经存在，所以设置失败
39.101.78.174:6379> GET k8
(nil)
39.101.78.174:6379> MSETNX k8 v8 k9 v9 k10 v10
(integer) 1
39.101.78.174:6379> GET k8
"v8"
39.101.78.174:6379>

10.PSETEX command, this command is similar to the SETEX command, but it sets the key's survival time in milliseconds instead of seconds like the SETEX command.

PSETEX key milliseconds value

39.101.78.174:6379> PSETEX k11 10000 v11
OK
39.101.78.174:6379> GET k11
"v11"
39.101.78.174:6379> GET k11
(nil)
39.101.78.174:6379>

11. Increase the numerical value stored in key by one

INCR key

39.101.78.174:6379> SET tps 1
OK
39.101.78.174:6379> GET tps
"1"
39.101.78.174:6379> INCR tps
(integer) 2
39.101.78.174:6379> GET tps
"2"
39.101.78.174:6379> INCR tps
(integer) 3
39.101.78.174:6379> GET tps
"3"
39.101.78.174:6379>

12. Add the given increment to the value stored in the key

INCRBY key increment

39.101.78.174:6379> GET tps
"3"
39.101.78.174:6379> INCRBY tps 10
(integer) 13
39.101.78.174:6379> GET tps
"13"
39.101.78.174:6379> INCRBY tps 2
(integer) 15
39.101.78.174:6379> GET tps
"15"
39.101.78.174:6379>

13. Add the value stored in key to the given floating point increment value (increment)

INCRBYFLOAT key increment

39.101.78.174:6379> SET score 50
OK
39.101.78.174:6379> GET score
"50"
39.101.78.174:6379> INCRBYFLOAT score 0.5
"50.5"
39.101.78.174:6379> GET score
"50.5"
39.101.78.174:6379> INCRBYFLOAT score 7.5
"58"
39.101.78.174:6379> GET score
"58"
39.101.78.174:6379> INCRBYFLOAT score 1
"59"
39.101.78.174:6379> GET score
"59"
# 对比INCRBY
39.101.78.174:6379> INCRBY score 1
(integer) 60
39.101.78.174:6379> GET score
"60"
39.101.78.174:6379> INCRBY score 0.5
(error) ERR value is not an integer or out of range
39.101.78.174:6379> GET score
"60"
39.101.78.174:6379>

14. Decrement the numerical value stored in key by one.

DECR key

39.101.78.174:6379> GET tps
"15"
39.101.78.174:6379> DECR tps
(integer) 14
39.101.78.174:6379> GET tps
"14"
39.101.78.174:6379> DECR tps
(integer) 13
39.101.78.174:6379> GET tps
"13"

15.The value stored in key minus the given decrement value (decrement)

DECRBY key decrement

39.101.78.174:6379> GET tps
"13"
39.101.78.174:6379> DECRBY tps 3
(integer) 10
39.101.78.174:6379> GET tps
"10"
39.101.78.174:6379> DECRBY tps 2
(integer) 8
39.101.78.174:6379> GET tps
"8"
# 可以传负数
39.101.78.174:6379> DECRBY tps -1
(integer) 9
39.101.78.174:6379> GET tps
"9"
# 对比DECR则报错
39.101.78.174:6379> DECR tps 2
(error) ERR wrong number of arguments for 'decr' command
39.101.78.174:6379>

16.APPEND command, if the key already exists and is a string, the APPEND command will append the specified value to the end of the original value of the key.

APPEND key value

39.101.78.174:6379> SET wang t
OK
39.101.78.174:6379> GET wang
"t"
39.101.78.174:6379> APPEND wang i
(integer) 2
39.101.78.174:6379> GET wang
"ti"
39.101.78.174:6379> APPEND wang n
(integer) 3
39.101.78.174:6379> GET wang
"tin"
39.101.78.174:6379> APPEND wang g
(integer) 4
39.101.78.174:6379> GET wang
"ting"
39.101.78.174:6379> 
39.101.78.174:6379> APPEND wang _
(integer) 5
39.101.78.174:6379> GET wang
"ting_"
39.101.78.174:6379> APPEND wang 666
(integer) 8
39.101.78.174:6379> GET wang
"ting_666"
39.101.78.174:6379>

Type 2: hash list operation

Redis hash is a mapping table of string type fields and values. Hash is particularly suitable for storing objects.

Each hash in Redis can store 2 ³² - 1 key-value pairs

1. Set the value of the field field in the hash table key to value

HSET key field value

39.101.78.174:6379> HSET key1 field1 value1
(integer) 1
39.101.78.174:6379> HGET key1 field1
"value1"
39.101.78.174:6379>

2. Set the value of the hash table field only when the field field does not exist.

HSETNX key field value

127.0.0.1:6379> HGET key1 field1
"value1"
127.0.0.1:6379> HSETNX key1 field1 value2
(integer) 0
127.0.0.1:6379> HGET key1 field1
"value1"
127.0.0.1:6379> HSETNX key1 field2 value2
(integer) 1
127.0.0.1:6379> HGET key1 field2
"value2"
127.0.0.1:6379>

3. Set multiple field-value pairs to the hash table key at the same time

HMSET key field1 value1 [field2 value2 …]

127.0.0.1:6379> HMSET key1 field3 value3 field4 value4 field5 value5
OK
127.0.0.1:6379> HGET key1 field3
"value3"
127.0.0.1:6379> HGET key1 field4
"value4"
127.0.0.1:6379> HGET key1 field5
"value5"
127.0.0.1:6379>

4. Check whether the specified field exists in the hash table key

HEXISTS key field

127.0.0.1:6379> HEXISTS key1 field1
(integer) 1
127.0.0.1:6379> HEXISTS key1 field2
(integer) 1
127.0.0.1:6379> HEXISTS key1 field100
(integer) 0
127.0.0.1:6379>

5. Get all fields and values of the specified key in the hash table

HGETALL key

127.0.0.1:6379> HGETALL key1
 1) "field1"
 2) "value1"
 3) "field2"
 4) "value2"
 5) "field3"
 6) "value3"
 7) "field4"
 8) "value4"
 9) "field5"
10) "value5"
127.0.0.1:6379>

6. Get all fields in the hash table

HKEY key

127.0.0.1:6379> HKEYS key1
1) "field1"
2) "field2"
3) "field3"
4) "field4"
5) "field5"
127.0.0.1:6379>

7. Get the number of fields in the hash table

HLEN key

127.0.0.1:6379> HLEN key1
(integer) 5
127.0.0.1:6379> HSET key1 field6 value6
(integer) 1
127.0.0.1:6379> HLEN key1
(integer) 6
127.0.0.1:6379>

8. Get the values of all given fields

HMGET key field1 field2 …

127.0.0.1:6379> HMGET key1 field1 field3 field5
1) "value1"
2) "value3"
3) "value5"
127.0.0.1:6379>

9. Add increment to the integer value of the specified field in the hash table key

HINCRBY key field increment

127.0.0.1:6379> HSET key2 field1 100
(integer) 1
127.0.0.1:6379> HGET key2 field1
"100"
127.0.0.1:6379> HINCRBY key2 field1 2
(integer) 102
127.0.0.1:6379> HINCRBY key2 field1 2
(integer) 104
127.0.0.1:6379> HGET key2 field1
"104"
127.0.0.1:6379>

10. Add increment to the floating point value of the specified field in the hash table key

HINCRBYFLOAT key field increment

127.0.0.1:6379> HGET key2 field1
"104"
127.0.0.1:6379> HINCRBYFLOAT key2 field1 0.01
"104.01"
127.0.0.1:6379> HGET key2 field1
"104.01"
127.0.0.1:6379> HINCRBYFLOAT key2 field1 10.1
"114.11"
127.0.0.1:6379> HGET key2 field1
"114.11"
127.0.0.1:6379>

11. Get all values in the hash table

HVALS key

127.0.0.1:6379> HVALS key1
1) "value1"
2) "value2"
3) "value3"
4) "value4"
5) "value5"
6) "value6"
127.0.0.1:6379> HVALS key2
1) "114.11"
127.0.0.1:6379>

12. Delete one or more hash table fields

HDEL key field1 field2 …

127.0.0.1:6379> HKEYS key1
1) "field1"
2) "field2"
3) "field3"
4) "field4"
5) "field5"
6) "field6"
127.0.0.1:6379> HDEL key1 field1 field3
(integer) 2
127.0.0.1:6379> HKEYS key1
1) "field2"
2) "field4"
3) "field5"
4) "field6"
127.0.0.1:6379> HVALS key1
1) "value2"
2) "value4"
3) "value5"
4) "value6"
127.0.0.1:6379>

Type 3: list list operation

A Redis list is a simple list of strings, sorted in insertion order. You can add an element to the head (left) or tail (right) of the list

A list can contain at most 2 ³² - 1 elements (4294967295, over 4 billion elements per list)

1. Insert one or more values into the head of the list

LPUSH key value1 value2 …

127.0.0.1:6379> LPUSH l1 v1 v2 v3
(integer) 3

2. View all data in the list

LRANGE key start stop

127.0.0.1:6379> LRANGE l1 0 100
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> LRANGE l1 0 1
1) "v3"
2) "v2"
127.0.0.1:6379> LRANGE l1 0 2
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> LRANGE l1 0 0
1) "v3"
127.0.0.1:6379> LRANGE l1 -10 2
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> 
# 0 -1 所有数据
127.0.0.1:6379> LRANGE l1 0 -1
1) "v3"
2) "v2"
3) "v1"

3. Insert a value into the head of an existing list

LPUSH key value

127.0.0.1:6379> LRANGE l1 0 -1
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> LPUSH l1 V4
(integer) 4
127.0.0.1:6379> LRANGE l1 0 -1
1) "V4"
2) "v3"
3) "v2"
4) "v1"
127.0.0.1:6379> LINDEX l1 0
"V4"
127.0.0.1:6379>

4. Add one or more values to the end of the list

RPUSH key value1 value2 …

127.0.0.1:6379> RPUSH l1 v5 v6 v7 v8
(integer) 8
127.0.0.1:6379> LRANGE l1 0 -1
1) "V4"
2) "v3"
3) "v2"
4) "v1"
5) "v5"
6) "v6"
7) "v7"
8) "v8"
127.0.0.1:6379>

5. Add a single value to the end of an existing list

RPUSH key value

127.0.0.1:6379> RPUSH l1 v9
(integer) 9
127.0.0.1:6379> LRANGE l1 0 -1
1) "V4"
2) "v3"
3) "v2"
4) "v1"
5) "v5"
6) "v6"
7) "v7"
8) "v8"
9) "v9"
127.0.0.1:6379>

6. Insert elements before or after the elements in the list

LINSERT key BEFORE|AFTER pivot value

127.0.0.1:6379> LINSERT l1 BEFORE v5 before_v5
(integer) 10
127.0.0.1:6379> LINSERT l1 AFTER v7 after_v7
(integer) 11
127.0.0.1:6379> LRANGE l1 0 -1
 1) "V4"
 2) "v3"
 3) "v2"
 4) "v1"
 5) "before_v5"
 6) "v5"
 7) "v6"
 8) "v7"
 9) "after_v7"
10) "v8"
11) "v9"
127.0.0.1:6379>

7. Get elements in the list by index

LINDEX key index

127.0.0.1:6379> LINDEX l1 0
"V4"
127.0.0.1:6379> LINDEX l1 8
"after_v7"
127.0.0.1:6379>

8. Set the value of a list element by index

LSET key index value

127.0.0.1:6379> LINDEX l1 5
"v5"
127.0.0.1:6379> LSET l1 5 v555
OK
127.0.0.1:6379> LINDEX l1 5
"v555"

9. Get the length of the list

LLEN key

127.0.0.1:6379> LLEN l1
(integer) 11

10. Remove and get the first element of the list

LPOP key

127.0.0.1:6379> LRANGE l1 0 -1
 1) "V4"
 2) "v3"
 3) "v2"
 4) "v1"
 5) "before_v5"
 6) "v5"
 7) "v6"
 8) "v7"
 9) "after_v7"
10) "v8"
11) "v9"
127.0.0.1:6379> LINDEX l1 0
"V4"
127.0.0.1:6379> LPOP l1
"V4"

11. Remove the last element of the list and the return value is the removed element

RPOP key

127.0.0.1:6379> LRANGE l1 0 -1
1) "v3"
2) "v2"
3) "v1"
4) "before_v5"
5) "v555"
6) "v6"
7) "v7"
8) "after_v7"
9) "v8"
10) "v9"
127.0.0.1:6379> RPOP l1
"V9"

12. Remove and get the first element of the list. If there is no element in the list, the list will be blocked until the wait times out or a pop-up element is found.

BLPOP key1 [key2 ] timeout

127.0.0.1:6379> LRANGE l1 0 -1
1) "v3"
2) "v2"
3) "v1"
4) "before_v5"
5) "v555"
6) "v6"
7) "v7"
8) "after_v7"
9) "v8"
127.0.0.1:6379> BLPOP l1 2000
1) "l1"
2) "v3"
127.0.0.1:6379> LRANGE l1 0 -1
1) "v2"
2) "v1"
3) "before_v5"
4) "v555"
5) "v6"
6) "v7"
7) "after_v7"
8) "v8"

13. Remove and get the last element of the list. If there is no element in the list, the list will be blocked until the wait times out or a pop-up element is found.

BRPOP key1 [key2 ] timeout

127.0.0.1:6379> BRPOP l1 2000
1) "l1"
2) "v8"

14. Remove the last element of the list and add that element to another list and return

RPOPLPUSH source destination

127.0.0.1:6379> LRANGE l1 0 -1
1) "v2"
2) "v1"
3) "before_v5"
4) "v555"
5) "v6"
6) "v7"
7) "after_v7"
127.0.0.1:6379> LRANGE l2 0 -1
(empty list or set)
127.0.0.1:6379> RPOPLPUSH l1 l2
"after_v7"
127.0.0.1:6379> LRANGE l1 0 -1
1) "v2"
2) "v1"
3) "before_v5"
4) "v555"
5) "v6"
6) "v7"
127.0.0.1:6379> LRANGE l2 0 -1
1) "after_v7"

15. Pop a value from the list, insert the popped element into another list and return it; if the list has no elements, the list will be blocked until the wait times out or a pop-up element is found.

BRPOPLPUSH source destination timeout

127.0.0.1:6379> BRPOPLPUSH l1 l2 2000
"v7"
127.0.0.1:6379> LRANGE l1 0 -1
1) "v2"
2) "v1"
3) "before_v5"
4) "v555"
5) "v6"
127.0.0.1:6379> LRANGE l2 0 -1
1) "v7"
2) "after_v7"

16. Trim a list so that only the elements within the specified range are retained in the list, and the elements that are not within the specified range will be deleted.

LTRIM key start stop

127.0.0.1:6379> LRANGE l1 0 -1
1) "v2"
2) "v1"
3) "before_v5"
4) "v555"
5) "v6"
127.0.0.1:6379> LTRIM l1 0 2
OK
127.0.0.1:6379> LRANGE l1 0 -1
1) "v2"
2) "v1"
3) "before_v5"

17. Delete the list of specified keys

DEL key

127.0.0.1:6379> DEL l2
(integer) 1
127.0.0.1:6379> LRANGE l2 0 -1
(empty list or set)

Type 4: set unordered set operation

Redis Set is an unordered collection of String type . Set members are unique, which means that duplicate data cannot appear in the set
Collections in Redis are implemented through hash tables, so the complexity of adding, deleting, and searching is all 0(1).
The maximum number of members in the set is 2 ³² - 1

1. Add one or more members to the collection

SADD key member1 member1 …

127.0.0.1:6379> SADD set1 v1 v2
(integer) 2

2. Return all members in the collection

SMEMBERS key

127.0.0.1:6379> SMEMBERS set1
1) "v2"
2) "v1"

3. Get the number of members of the collection

SCARD key

127.0.0.1:6379> SCARD set1
(integer) 2
127.0.0.1:6379> SADD set1 v3
(integer) 1
127.0.0.1:6379> SCARD set1
(integer) 3

4. Return the difference set of all given sets

SDIFF key1 key2 …

127.0.0.1:6379> SADD set2 v1 v3 v4
(integer) 3
127.0.0.1:6379> SMEMBERS set1
1) "v2"
2) "v1"
3) "v3"
127.0.0.1:6379> SMEMBERS set2
1) "v4"
2) "v1"
3) "v3"
127.0.0.1:6379> SDIFF set1 set2
1) "v2"

5. Return the difference set of all given sets and store it in destination

SDIFFSTORE destination key1 key2 …

127.0.0.1:6379> SMEMBERS set1
1) "v2"
2) "v1"
3) "v3"
127.0.0.1:6379> SMEMBERS set2
1) "v4"
2) "v1"
3) "v3"
127.0.0.1:6379> SMEMBERS set3
(empty list or set)
127.0.0.1:6379> SDIFFSTORE set3 set1 set2
(integer) 1
127.0.0.1:6379> SMEMBERS set3
1) "v2"

6. Return the intersection of all given sets

SINTER key1 key2 …

127.0.0.1:6379> SMEMBERS set1
1) "v2"
2) "v1"
3) "v3"
127.0.0.1:6379> SMEMBERS set2
1) "v4"
2) "v1"
3) "v3"
127.0.0.1:6379> SINTER set1 set2
1) "v1"
2) "v3"

7. Return the intersection of all given sets and store it in destination

SINTERSTORE destination key1 key2 …

127.0.0.1:6379> SINTERSTORE set4 set1 set2
(integer) 2
127.0.0.1:6379> SMEMBERS set4
1) "v1"
2) "v3"

8. Determine whether the member element is a member of the set key

SISMEMBER key member

127.0.0.1:6379> SMEMBERS set1
1) "v2"
2) "v1"
3) "v3"
127.0.0.1:6379> SISMEMBER set1 v1
(integer) 1
127.0.0.1:6379> SISMEMBER set1 v4
(integer) 0

9. Move the member element from the source collection to the destination collection

SMOVE source destination member

127.0.0.1:6379> SMEMBERS set3
1) "v2"
127.0.0.1:6379> SMEMBERS set4
1) "v1"
2) "v3"
127.0.0.1:6379> SMOVE set3 set4 v2
(integer) 1
127.0.0.1:6379> SMEMBERS set4
1) "v2"
2) "v1"
3) "v3"

10. Remove and return a random element from the collection

SPOP key

127.0.0.1:6379> SMEMBERS set2
1) "v4"
2) "v1"
3) "v3"
127.0.0.1:6379> SPOP set2
"v4"
127.0.0.1:6379> SPOP set2
"v1"
127.0.0.1:6379> SMEMBERS set2
1) "v3"

11. Return one or more random numbers in the collection

SRANDMEMBER key [count]

127.0.0.1:6379> SRANDMEMBER set1
"v3"
127.0.0.1:6379> SRANDMEMBER set1 2
1) "v1"
2) "v3"
127.0.0.1:6379> SRANDMEMBER set1 2
1) "v2"
2) "v1"

12. Remove one or more members from the collection

SREM key member1 [member2 …]

127.0.0.1:6379> SMEMBERS set1
1) "v2"
2) "v1"
3) "v3"
127.0.0.1:6379> SREM set1 v1 v2
(integer) 2
127.0.0.1:6379> SMEMBERS set1
1) "v3"

13.Return the union of all given sets

SUNION key1 [key2]

127.0.0.1:6379> SADD set1 v5 v6 v7
(integer) 3
127.0.0.1:6379> SMEMBERS set1
1) "v7"
2) "v5"
3) "v6"
4) "v3"
127.0.0.1:6379> SADD set2 v8 v9 
(integer) 2
127.0.0.1:6379> SMEMBERS set2
1) "v9"
2) "v8"
3) "v3"
127.0.0.1:6379> SUNION set1 set2
1) "v3"
2) "v5"
3) "v6"
4) "v9"
5) "v7"
6) "v8"

14.The union of all given collections is stored in the destination collection

SUNIONSTORE destination key1 [key2]

127.0.0.1:6379> SUNIONSTORE set5 set1 set2
(integer) 6
127.0.0.1:6379> SMEMBERS set5
1) "v3"
2) "v5"
3) "v6"
4) "v9"
5) "v7"
6) "v8"

Operations on keys

1.DEL delete key, this command is used to delete the key when the key exists

DEL key

127.0.0.1:6379> keys *
1) "L1"
2) "set1"
3) "set5"
4) "set4"
5) "set2"
6) "key2"
7) "key1"
8) "l1"
127.0.0.1:6379> DEL key1 key2
(integer) 2
127.0.0.1:6379> keys *
1) "L1"
2) "set1"
3) "set5"
4) "set4"
5) "set2"
6) "l1"

2. Serialize the given key and return the serialized value

DUMP key

127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> DUMP k1
"\x00\x02v1\a\x00\xa0\xd7e\xad\xc3\x9a\xacA"

3. Check whether the given key exists

EXISTS key

127.0.0.1:6379> EXISTS k1
(integer) 1
127.0.0.1:6379> EXISTS k100
(integer) 0

4. Set the expiration time for the given key, in seconds

EXPIRE key seconds

127.0.0.1:6379> EXPIRE k1 8
(integer) 1
127.0.0.1:6379> EXISTS k1
(integer) 1
# 等待超过8秒后查询
127.0.0.1:6379> EXISTS k1
(integer) 0
127.0.0.1:6379> keys *
1) "L1"
2) "set1"
3) "set5"
4) "set4"
5) "set2"
6) "l1"

5. Set the expiration time of the key in milliseconds

PEXPIRE key milliseconds

127.0.0.1:6379> SET k2 v2
OK
127.0.0.1:6379> PEXPIRE k2 3000
(integer) 1
127.0.0.1:6379> GET k2
"v2"
#  等待超过3秒后查询
127.0.0.1:6379> GET k2
(nil)

6. Find all keys that match the given pattern (pattern)

KEYS pattern

127.0.0.1:6379> keys *
1) "L1"
2) "set1"
3) "set5"
4) "set4"
5) "set2"
6) "l1"
127.0.0.1:6379> keys set*
1) "set1"
2) "set5"
3) "set4"
4) "set2"
127.0.0.1:6379> keys *1
1) "L1"
2) "set1"
3) "l1"

7. Remove the expiration time of the key and the key will be maintained permanently.

PERSIST key

127.0.0.1:6379> SET k1 v1
OK
127.0.0.1:6379> EXPIRE k1 15
(integer) 1
# 在过期之前执行PERSIST解除过期
127.0.0.1:6379> PERSIST k1
(integer) 1
# 等待超过15秒后查询依然可以查询到
127.0.0.1:6379> GET k1
"v1"

8. Return the remaining expiration time of the key in milliseconds

PTTL key

127.0.0.1:6379> EXPIRE k1 30
(integer) 1
127.0.0.1:6379> PTTL k1
(integer) 23007
127.0.0.1:6379> PTTL k1
(integer) 17000

9. Return the remaining survival time of the given key in seconds.

TTL key

127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> EXPIRE k1 30
(integer) 1
127.0.0.1:6379> TTL k1
(integer) 24
127.0.0.1:6379> TTL k1
(integer) 17

10. Randomly return a key from the current database

RANDOMKEY

127.0.0.1:6379> keys *
1) "L1"
2) "set1"
3) "set5"
4) "set4"
5) "set2"
6) "l1"
127.0.0.1:6379> RANDOMKEY
"l1"
127.0.0.1:6379> RANDOMKEY
"set1"
127.0.0.1:6379> RANDOMKEY
"set4"

11. Modify the name of the key

RENAME key newkey

127.0.0.1:6379> SET k1 v1
OK
127.0.0.1:6379> GET k1
"v1"
127.0.0.1:6379> RENAME k1 kkkkk1
OK
127.0.0.1:6379> GET k1
(nil)
127.0.0.1:6379> GET kkkkk1
"v1"

12. Only when newkey does not exist, rename the key to newkey

RENAMENX key newkey

127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> set k2 v2
OK
127.0.0.1:6379> renamenx k1 k2
(integer) 0
127.0.0.1:6379> get k1 
"v1"
127.0.0.1:6379> get k2
"v2"
127.0.0.1:6379> renamenx k1 k3
(integer) 1
127.0.0.1:6379> get k3
"v1"

13. Return the type of value stored in key

TYPE key

127.0.0.1:6379> keys *
1) "kkkkk1"
2) "k3"
3) "set2"
4) "set5"
5) "L1"
6) "set1"
7) "k2"
8) "set4"
9) "l1"
127.0.0.1:6379> 
127.0.0.1:6379> TYPE k2
string
127.0.0.1:6379> TYPE l1
list
127.0.0.1:6379> TYPE set1
set

14. Clear all keys

FLUSHALL

Operate with caution, equivalent to deleting the database in MySQL

Type 5: Zset ordered set operations

Redis ordered sets, like sets, are also collections of string type elements and do not allow duplicate members.
It is used to save data that needs to be sorted , such as rankings, Chinese scores of a class, employee salaries of a company, posts on a forum, etc.
In an ordered set, each element has a score (weight) to sort the elements.
It has three elements: key, member and score. Taking Chinese scores as an example, key is the name of the exam (midterm exam, final exam, etc.), member is the student's name, and score is the score.

1. Add one or more members to an ordered set, or update the score of an existing member

ZADD key score1 member1 [score2 member2]

127.0.0.1:6379> ZADD pv_zset 80 page1.html 100 page2.html 160 page3.html
(integer) 3

2. Get the number of members of an ordered set

ZCARD key

127.0.0.1:6379> ZCARD pv_zset
(integer) 3

3. Calculate the number of members with a specified interval score in an ordered set

ZCOUNT key min max

# 80  page1.html 
# 100 page2.html 
# 160 page3.html
# 60 ~ 110 之间  2个
127.0.0.1:6379> ZCOUNT pv_zset 60 110
(integer) 2

4. Add increment to the score of the specified member in the ordered set

ZINCRBY key increment member

127.0.0.1:6379> ZINCRBY pv_zset 10 page1.html
"90"

5. Calculate the intersection of one or more given ordered sets and store the result set in the new ordered set key

ZINTERSTORE destination numkeys key [key …]

127.0.0.1:6379> ZADD pv_zset1 10 page1.html 20 page2.html
(integer) 2
127.0.0.1:6379> ZADD pv_zset2 5 page1.html 10 page2.html
(integer) 2
127.0.0.1:6379> ZINTERSTORE pv_zset_result 2 pv_zset1 pv_zset2
(integer) 2

6. Return the members in the specified range of the ordered set through the index range

ZRANGE key start stop [WITHSCORES]

127.0.0.1:6379> ZRANGE pv_zset_result 0 -1 WITHSCORES
1) "page1.html"
2) "15"
3) "page2.html"
4) "30"

7. Return the members in the specified interval of the ordered set through scores

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]

127.0.0.1:6379> ZRANGE pv_zset 0 -1 WITHSCORES
1) "page1.html"
2) "90"
3) "page2.html"
4) "100"
5) "page3.html"
6) "160"
127.0.0.1:6379> ZRANGEBYSCORE pv_zset 95 180
1) "page2.html"
2) "page3.html"

8. Return the index of the specified member in the ordered set

ZRANK key member

127.0.0.1:6379> ZRANK pv_zset page1.html
(integer) 0
127.0.0.1:6379> ZRANK pv_zset page3.html
(integer) 2

9. Remove one or more members from an ordered set

ZREM key member [member …]

127.0.0.1:6379> ZRANGE pv_zset 0 -1 WITHSCORES
1) "page1.html"
2) "90"
3) "page2.html"
4) "100"
5) "page3.html"
6) "160"
127.0.0.1:6379> ZREM pv_zset page1.html
(integer) 1
127.0.0.1:6379> ZRANGE pv_zset 0 -1 WITHSCORES
1) "page2.html"
2) "100"
3) "page3.html"
4) "160"

10. Return the members in the specified range in the ordered set, through the index, the score is from high to low

ZREVRANGE key start stop [WITHSCORES]

127.0.0.1:6379> ZADD pv_zset 120 page1.html 140 page4.html 20 page5.html 300 page6.html
(integer) 4
127.0.0.1:6379> ZRANGE pv_zset 0 -1 WITHSCORES
 1) "page5.html"
 2) "20"
 3) "page2.html"
 4) "100"
 5) "page1.html"
 6) "120"
 7) "page4.html"
 8) "140"
 9) "page3.html"
10) "160"
11) "page6.html"
12) "300"
127.0.0.1:6379> ZREVRANGE pv_zset 0 -1
1) "page6.html"
2) "page3.html"
3) "page4.html"
4) "page1.html"
5) "page2.html"
6) "page5.html"

11. Returns the ranking of the specified member in the ordered set. The members of the ordered set are sorted by decreasing score (from large to small)

ZREVRANK key member

# 排序包含0
127.0.0.1:6379> ZREVRANK pv_zset page6.html
(integer) 0
127.0.0.1:6379> ZREVRANK pv_zset page4.html
(integer) 2
127.0.0.1:6379> ZREVRANK pv_zset page5.html
(integer) 5

12. Return the score value of the member in the ordered set

ZSCORE key member

127.0.0.1:6379> ZSCORE pv_zset page3.html
"160"
127.0.0.1:6379> ZSCORE pv_zset page5.html
"20"

Bitmap operations

The smallest storage unit of a computer is a bit. Bitmaps are for bit operations and are more space-saving than String, Hash, Set and other storage methods.
Bitmaps are not a data structure. The operation is based on the String structure. A String can store up to 512M, so a Bitmaps can set 232 ^bits .
Bitmaps provides a separate set of commands, so using Bitmaps in Redis is not the same as using strings. You can think of Bitmaps as an array in bits. Each unit of the array can only store 0 and 1. The subscript of the array is called an offset in Bitmaps.
An example of the BitMaps command: store each independent user in Bitmaps whether they have visited the website, record the visited user as 1, and the user who has not visited as 0, and use the offset as the user's ID

1.Set Bit value

SETBIT key offset value

The vlaue set by the setbit command can only be 0 or 1.

127.0.0.1:6379> setbit unique:users:2022-09-12 1 1
(integer) 0
127.0.0.1:6379> setbit unique:users:2022-09-12 2 1
(integer) 0
127.0.0.1:6379> setbit unique:users:2022-09-12 3 1
(integer) 0
127.0.0.1:6379> setbit unique:users:2022-09-12 4 0
(integer) 0
# unique:users:2022-09-12 -> 定义用户某日的标记
# 1,2,3，4可以是用户的UID等标记
# 1 代表用户访问 0代表未访问

2. Get the Bit value

GETBIT key offset

127.0.0.1:6379> getbit unique:users:2022-09-12 3
(integer) 1
127.0.0.1:6379> getbit unique:users:2022-09-12 4
(integer) 0

3. Get the number of Bitmaps with a specified range value of 1

BITCOUNT key [start end]

Assuming that there is a lot of data in the database and counting the records that users have accessed on that day, you only need to count the total number of 1

127.0.0.1:6379> bitcount unique:users:2022-09-12
(integer) 3

4.Operations between Bitmaps

BITOP operation destkey key [key, …]

127.0.0.1:6379> setbit unique:users:2022-09-13 1 0
(integer) 0
127.0.0.1:6379> setbit unique:users:2022-09-13 2 1
(integer) 0
127.0.0.1:6379> setbit unique:users:2022-09-13 3 1
(integer) 0
127.0.0.1:6379> setbit unique:users:2022-09-13 4 1
(integer) 0
# 2022-09-12 1 1
# 2022-09-12 2 1  **
# 2022-09-12 3 1  **
# 2022-09-12 4 0

# 2022-09-13 1 0
# 2022-09-13 2 1  **
# 2022-09-13 3 1  **
# 2022-09-13 4 1
# 统计出连续两天都为1的结果（2）
127.0.0.1:6379> bitop and unique:users:and:2022-09-12and13 unique:users:2022-09-12 unique:users:2022-09-13
(integer) 1
127.0.0.1:6379> bitcount unique:users:and:2022-09-12and13
(integer) 2
# 统计出连续两天中任意一天有1的结果（4）
127.0.0.1:6379> bitop or unique:users:or:2022-09-12or13 unique:users:2022-09-12 unique:users:2022-09-13
(integer) 1
127.0.0.1:6379> bitcount unique:users:or:2022-09-12or13
(integer) 4

Operations on HyperLogLog structure

HyperLogLog is often used for statistics of large amounts of data, such as page visit statistics or user visit statistics.

The syntax used by HyperLogLog integrated with Redis mainly includes pfadd and pfcount. As the name suggests, one is for adding data and the other is for statistics. Why use pf? It is because the inventor of the HyperLogLog data structure is Professor Philippe Flajolet, so the English abbreviation of the inventor is used.

pathd
pfcount
- pfadd and pfcount are commonly used in statistics

127.0.0.1:6379> pfadd uv user1
(integer) 1
127.0.0.1:6379> keys *
1) "uv"
127.0.0.1:6379> pfcount uv
(integer) 1
127.0.0.1:6379> pfadd uv user2
(integer) 1
127.0.0.1:6379> pfadd uv user3
(integer) 1
127.0.0.1:6379> pfadd uv user4
(integer) 1
127.0.0.1:6379> pfcount uv
(integer) 4
127.0.0.1:6379> pfadd uv user5 user6 user7 user8 user9 user10
(integer) 1
127.0.0.1:6379> pfcount uv
(integer) 10

127.0.0.1:6379> pfadd page1 user1 user2 user3 user4 user5
(integer) 1
127.0.0.1:6379> pfadd page2 user1 user2 user3 user6 user7
(integer) 1
127.0.0.1:6379> pfmerge page1+page2 page1 page2
OK
127.0.0.1:6379> pfcount page1+page2
(integer) 7

Why HyperLogLog is suitable for statistics of large amounts of data

Redis HyperLogLog is an algorithm used for cardinality statistics. The advantage of HyperLogLog is that when the number or volume of input elements is very large, the space required to calculate the cardinality is always fixed and very small.
In Redis, each HyperLogLog key only requires 12 KB of memory to calculate the cardinality of nearly 2 ⁶⁴ different elements. This is in sharp contrast to a collection that consumes more memory when calculating cardinality. The more elements there are, the more memory is consumed.
Because HyperLogLog only calculates the cardinality based on the input elements and does not store the input elements themselves, HyperLogLog cannot return individual elements of the input like a collection.

What is cardinality?

For example: Data set {1, 3, 5, 7, 5, 7, 8}, then the cardinality set of this data set is {1, 3, 5, 7, 8}, and the cardinality is 5 (the number of non-repeating elements) . Cardinality estimation is to quickly calculate the cardinality within the acceptable error range.

[Chapter 5]-Redis java api data development operations

Redis can be operated not only through the command line, but also through Java API. By using Java API, you can operate various data types in the Redis database.

Development environment preparation

Create a maven project to configure pom dependencies

groupId

cn.wangting

artifactId

redis_op

pom configuration file

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.wangting</groupId>
    <artifactId>redis_op</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.14.3</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                    <!--    <verbal>true</verbal>-->
                </configuration>
            </plugin>
        </plugins>
    </build>
    
</project>

Create packages and experimental classes

Create cn.wangting.redis.api_test package structure in the test directory
and create the RedisTest class

Because subsequent tests need to frequently use Redis connections, we first create a JedisPool to obtain Redis connections. Here, we test various APIs based on TestNG. Use @BeforeTest to create a Redis connection pool before executing the test case. Use @AfterTest to close the connection pool after executing the test case.

Implementation steps:

Create a JedisPoolConfig configuration object and specify a maximum idle connection of 10, a maximum waiting time of 3000 milliseconds, a maximum number of connections of 50, and a minimum of 5 idle connections.

Create JedisPool

Use the @Test annotation to write test cases and view all keys in Redis

Get Redis connection from Redis connection pool

Call the keys method to get all keys

Traverse and print all keys

RedisTest

package cn.wangting.redis.api_test;
import org.junit.After;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.List;
import java.util.Set;


public class RedisTest {
    
    

    private JedisPool jedisPool;
    private JedisPoolConfig config;

    @BeforeTest
    public void redisConnectionPool(){
    
    
        config = new JedisPoolConfig();
        config.setMaxIdle(10);
        config.setMaxWaitMillis(3000);
        config.setMaxTotal(50);
        config.setMinIdle(5);
        jedisPool = new JedisPool(config, "8.130.25.36", 6379);
    }

    // 功能测试
    public static void main(String[] args) {
    
    
        System.out.println("hello redis!");
    }

    

    @AfterTest
    public void closePool(){
    
    
        jedisPool.close();
    }

}

Run debugging. If the console outputs hello redis!, the environment is ready.

API operates string type data

Implement the following requirements through API operations:

Add a string type data, the key is pv, used to save the value of pv, the initial value is 0
Query the data corresponding to the key
Modify pv to 1000
Implement atomic auto-increment operation of plastic data +1
Implement the atomic auto-increment operation of shaping the data +1000

Current command line redis situation

[root@wangting ~]# redis-cli 
127.0.0.1:6379> keys *
1) "a"
2) "c"
127.0.0.1:6379>

string operation code RedisTest

package cn.wangting.redis.api_test;
import org.junit.After;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.List;
import java.util.Set;


public class RedisTest {
    
    

    private JedisPool jedisPool;
    private JedisPoolConfig config;

    @BeforeTest
    public void redisConnectionPool(){
    
    
        config = new JedisPoolConfig();
        config.setMaxIdle(10);
        config.setMaxWaitMillis(3000);
        config.setMaxTotal(50);
        config.setMinIdle(5);
        jedisPool = new JedisPool(config, "8.130.25.36", 6379);
    }

    // 功能测试
    @Test
    public void stringOpTest() {
    
    
        Jedis connection = jedisPool.getResource();
        // 1.  添加数据
        connection.set("pv", "0");

        // 2.  查询数据
        System.out.println("原始pv为:" + connection.get("pv"));

        // 3.  修改数据
        connection.set("pv", "1000");
        System.out.println("修改pv为:" + connection.get("pv"));

        // 4.  实现整形数据原子自增操作 +1
        connection.incr("pv");
        System.out.println("pv自增1：" + connection.get("pv"));

        // 5.  实现整形该数据原子自增操作 +1000
        connection.incrBy("pv", 1000);
        System.out.println("pv自增1000：" + connection.get("pv"));

    }
    
    @AfterTest
    public void closePool(){
    
    
        jedisPool.close();
    }

}

[Note]: In order to control the length, only part of the @Test code block will be posted later.

Console output:

原始pv为:0
修改pv为:1000
pv自增1：1001
pv自增1000：2001

===============================================
Default Suite
Total tests run: 1, Failures: 0, Skips: 0
===============================================

Check the redis situation on the command line again

127.0.0.1:6379> keys *
1) "a"
2) "pv"
3) "c"
127.0.0.1:6379> get pv
"2001"