Redis三大特殊数据类型

1、geospatial

地理位置

朋友的定位，附近的人，打车距离计算？

Redis的Geo在Redis3.2版本就已经推出！这个功能可以推算地理位置的信息，两地之间的距离，方圆几里的人！

经纬度查询测试：经纬度查询

1.1 geoadd

将指定的地理空间位置（纬度、经度、名称）添加到指定的key中。这些数据将会存储到sorted set这样的目的是为了方便使用GEORADIUS或者GEORADIUSBYMEMBER命令对数据进行半径查询等操作。

有效的经度从-180度到180度。

有效的纬度从-85.05112878度到85.05112878度

127.0.0.1:6379> geoadd china:city 116.23 40.22 beijing
(integer) 1
127.0.0.1:6379> geoadd china:city 121.49 31.41 shanghai 
(integer) 1
127.0.0.1:6379> geoadd china:city 113.88 22.55 shenzhen 106.54 29.40 chongqing
(integer) 2
127.0.0.1:6379> geoadd china:city 120.21 30.12 hangzhou 108.93 34.23 xian
(integer) 2

1.2 geopos

127.0.0.1:6379> geopos china:city beijing # 获取指定的经度和纬度
1) 1) "116.23000055551528931"
   2) "40.2200010338739844"
127.0.0.1:6379> geopos china:city beijing chongqing
1) 1) "116.23000055551528931"
   2) "40.2200010338739844"
2) 1) "106.54000014066696167"
   2) "29.39999880018641676"

1.3 geodist

返回两个给定位置之间的距离。

如果两个位置之间的其中一个不存在，那么命令返回空值。

指定单位的参数 unit 必须是以下单位的其中一个：

m 表示单位为米。（默认）

km 表示单位为千米。

mi 表示单位为英里。

ft 表示单位为英尺。

127.0.0.1:6379> geodist china:city beijing wuhan
(nil)
127.0.0.1:6379> geodist china:city beijing shanghai # 查看北京到上海的直线距离 单位：米
"1088162.3001"
127.0.0.1:6379> geodist china:city beijing chongqing # 查看北京到重庆的直线距离
"1491671.5628"
127.0.0.1:6379> geodist china:city beijing shanghai km 
"1088.1623"

1.4 georidus

以给定的经纬度为中心，返回键包含的位置元素当中，与中心的距离不超过给定最大距离的所有位置元素。

范围可以使用以下其中一个单位：

m 表示单位为米。

km 表示单位为千米。

mi 表示单位为英里。

ft 表示单位为英尺。

127.0.0.1:6379> georadius china:city 110 30 1000 km # 以100，30这个经纬度为中心，寻找方圆1000km内的城市
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
127.0.0.1:6379> georadius china:city 110 30 500 km
1) "chongqing"
2) "xian"
127.0.0.1:6379> georadius china:city 110 30 500 km withdist # 显示到中心距离的位置
1) 1) "chongqing"
   2) "340.8679"
2) 1) "xian"
   2) "481.1540"
127.0.0.1:6379> georadius china:city 110 30 500 km withcoord # 显示他人的定位信息
1) 1) "chongqing"
   2) 1) "106.54000014066696167"
      2) "29.39999880018641676"
2) 1) "xian"
   2) 1) "108.92999857664108276"
      2) "34.23000121926852302"
127.0.0.1:6379> georadius china:city 110 30 500 km withcoord count 1 # 筛选指定的结果
1) 1) "chongqing"
   2) 1) "106.54000014066696167"
      2) "29.39999880018641676"
127.0.0.1:6379> georadius china:city 110 30 500 km withcoord count 2
1) 1) "chongqing"
   2) 1) "106.54000014066696167"
      2) "29.39999880018641676"
2) 1) "xian"
   2) 1) "108.92999857664108276"
      2) "34.23000121926852302"

1.5 georadiusbymember

这个命令和 GEORADIUS 命令一样，都可以找出位于指定范围内的元素，但是 GEORADIUSBYMEMBER 的中心点是由给定的位置元素决定的，而不是像 GEORADIUS 那样，使用输入的经度和纬度来决定中心点

# 找出位于指定元素周围的其他元素
127.0.0.1:6379> georadiusbymember china:city beijing 1000 km
1) "beijing"
2) "xian"
127.0.0.1:6379> georadiusbymember china:city shanghai 400 km
1) "hangzhou"
2) "shanghai"

1.6 geohash

返回一个或多个位置元素的 Geohash 表示。

该命令将返回11个字符的Geohash字符串。

# 将二维的经纬度转换为一维的字符串，如果两个字符串越接近，则距离越近
127.0.0.1:6379> geohash china:city beijing chongqing
1) "wx4sucu47r0"
2) "wm5z22h53v0"

GEO底层的实现原理其实就是ZSet！我们可以使用ZSet命令来操作geo！

127.0.0.1:6379> zrange china:city 0 -1 # 查看地图中的全部元素
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
6) "beijing"
127.0.0.1:6379> zrem china:city beijing # 移除指定的元素
(integer) 1
127.0.0.1:6379> zrange china:city 0 -1
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"

2、Hyperloglog

什么是基数？

A{1,3,5,7,8,7}

B{1,3,5,7,8}

基数（不重复的元素） = 5，可以接受误差

简介

Redis2.8.9版本就更新了Hyperloglog数据结构

Redis Hyperloglog基数统计的算法！

优点：占用的内存是固定的，2^64不同的元素的基数，只需要废12KB内存！如果从内存角度来比较的话，Hyperloglog首选！

网页的UV（一个人访问一个网站多次，但是还是算作一个人！）

传统的方式，set保存用户的id，然后就可以统计set中的元素数量作为标准判断！

这个方式如果保存大量的用户id，就会比较麻烦，我们的目的是为了计数，而不是保存用户id！

0.81%的错误率！统计UV任务，是可以忽略不计的！

127.0.0.1:6379> pfadd mykey a b c d e f g h i j  # 创建第一组元素 mykey
(integer) 1
127.0.0.1:6379> pfcount mykey # 统计mykey 元素的基数数量
(integer) 10
127.0.0.1:6379> pfadd mykey2 i j z x c v b n m # 创建第二组元素 mykey2
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 9
127.0.0.1:6379> pfmerge mykey3 mykey mykey2 # 合并两组mykey mykey2 =>mykey3 并集
OK
127.0.0.1:6379> pfcount mykey3 # 看并集的数量！
(inteer) 15

如果允许容错，那么一定可以使用Hyperloglog！

如果不允许容错，就是用set或者自己的数据类型即可！

3、Bitmaps

位存储

统计疫情感染人数：0 1 0 1 0

统计用户信息，活跃，不活跃！登录、未登录！打卡，365天打卡！两个状态的，都可以使用Bitmaps！

Bitmaps位图，数据结构！都是操作二进制位来进行记录，就只有0和1两个状态！

使用bitmap来记录周一到周日的打卡！

周一：1，周二：0，周三：0，周四：1

127.0.0.1:6379> setbit sign 0 1
(integer) 0
127.0.0.1:6379> setbit sign 1 0
(integer) 0
127.0.0.1:6379> setbit sign 2 0
(integer) 0
127.0.0.1:6379> setbit sign 3 1
(integer) 0
127.0.0.1:6379> setbit sign 4 1
(integer) 0
127.0.0.1:6379> setbit sign 5 0
(integer) 0
127.0.0.1:6379> setbit sign 6 0
(integer) 0

查看某一天是否有打卡！

127.0.0.1:6379> getbit sign 3
(integer) 1
127.0.0.1:6379> getbit sign 6
(integer) 0

统计操作，统计打卡的天数！

1 2	127.0.0.1:6379> bitcount sign # 统计这周的打卡记录，就可以看到这周是否全勤 (integer) 3

事务

Redis事务本质：一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行！

一次性、顺序性、排他性！执行一系列的命令！

1	----队列 set set set 执行--------

**Redis事务没有隔离级别的概念！**

所有的命令在事务中，并没有直接被执行！只有发起执行命令的时候才会执行！

**Redis单条命令是保证原子性的，但是事务不保证原子性（要么同时成功，要么同时失败！）**

Redis的事务：

开启事务（multi）
命令入队
执行事务（exec）

正常执行事务

127.0.0.1:6379> multi # 开启事务
OK
# 命令入队
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> exec # 执行事务
1) OK
2) OK
3) "v2"
4) OK

放弃事务

127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> discard # 取消事务
OK
127.0.0.1:6379> get k4 # 事务队列中命令都不会被执行！
(nil)

编译型异常（代码有问题！命令有错！），事务中所有的命令都不会被执行！

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v4
QUEUED
127.0.0.1:6379(TX)> getset k3 # 错误的命令
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> set k5 v5
QUEUED
127.0.0.1:6379(TX)> exec # 执行事务报错
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k5 # 所有的命令都不会被执行
(nil)

运行时异常（1/0），如果事务队列中存在语法性，那么执行命令的时候，其他的命令是可以正常执行的，错误命令抛出异常！

127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> multi 
OK
127.0.0.1:6379(TX)> incr k1 # 执行的时候会失败
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> get k3
QUEUED
127.0.0.1:6379(TX)> exec
1) (error) ERR value is not an integer or out of range # 虽然第一条命令报错了，但是依旧正常执行成功了！
2) OK
3) OK
4) "v3"

监控

悲观锁：

很悲观，认为什么时候都会出问题，无论做什么都会加锁！

乐观锁：

很乐观，认为什么时候都不会出问题，所以不会上锁！更新数据的时候去判断一下，在此期间是否有人修改过这个数据。
获取version
更新的时候比较version

Redis测监视测试

正常执行成功！

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> watch money # 监视money对象
OK
127.0.0.1:6379> multi # 事务正常结束，数据期间没有发生变动，这个时候就正常执行成功！
OK
127.0.0.1:6379(TX)> decrby money 20
QUEUED
127.0.0.1:6379(TX)> incrby out 20
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 80
2) (integer) 20

测试多线程修改值，使用watch可以当作redis的乐观锁操作！

127.0.0.1:6379> watch money # 监视money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> decrby money 10
QUEUED
127.0.0.1:6379(TX)> incrby out 10
QUEUED
==========
# 另一个线程修改money的值 --见后面的代码
==========
127.0.0.1:6379(TX)> exec # 执行之前，另外一个线程修改了我们的值，这个时候，就会导致事务执行失败！
(nil)

# 另起线程修改值
127.0.0.1:6379> get money
"80"
127.0.0.1:6379> set money 1000
OK

如果修改失败，获取最新的值就好

127.0.0.1:6379> unwatch # 1、如果发现事务执行失败，就先解锁
OK
127.0.0.1:6379> watch money # 2、获取最新的值，再次监视，select version
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> decrby money 1
QUEUED
127.0.0.1:6379(TX)> incrby money 1
QUEUED
127.0.0.1:6379(TX)> exec # 3、比对监视的值是否发生了变化，如果没有变化，那么可以执行成功，如果变化就执行失败
1) (integer) 999
2) (integer) 1000

Jedis

我们要使用Java来操作Redis

什么是Jedis？

Jedis是Redis官方推荐的Java连接开发工具！使用Java操作Redis中间件！如果你要使用Java操作Redis，那么一定要对Jedis十分的熟悉！

测试

1、导入对应的依赖

<!-- 导入jedis包-->
<dependencies>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.6.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.76</version>
    </dependency>
</dependencies>

2、编码测试

连接数据库
操作命令
断开连接！

import redis.clients.jedis.Jedis;

public class TestPing {
    public static void main(String[] args) {
        // 1、new  Jedis 对象即可
        Jedis jedis = new Jedis("110.40.138.125",6379);
        // jedis 所有的命令就是我们之前学习的所有指令! 所以之前的指令学习很重要
        System.out.println(jedis.ping());
        jedis.close();
    }
}

输出：

1635175424147

连接过程中出现的问题：

Exception in thread "main" redis.clients.jedis.exceptions.JedisConnectionException: Failed to create socket.
	at redis.clients.jedis.DefaultJedisSocketFactory.createSocket(DefaultJedisSocketFactory.java:110)
	at redis.clients.jedis.Connection.connect(Connection.java:226)
	at redis.clients.jedis.BinaryClient.connect(BinaryClient.java:135)
	at redis.clients.jedis.Connection.sendCommand(Connection.java:163)
	at redis.clients.jedis.Connection.sendCommand(Connection.java:158)
	at redis.clients.jedis.BinaryClient.ping(BinaryClient.java:186)
	at redis.clients.jedis.BinaryJedis.ping(BinaryJedis.java:380)
	at com.ldg.TestPing.main(TestPing.java:10)
Caused by: java.net.SocketTimeoutException: connect timed out
	at java.net.DualStackPlainSocketImpl.waitForConnect(Native Method)
	at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:85)
	at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:350)
	at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:206)
	at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:188)
	at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:172)
	at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:392)
	at java.net.Socket.connect(Socket.java:589)
	at redis.clients.jedis.DefaultJedisSocketFactory.createSocket(DefaultJedisSocketFactory.java:80)
	... 7 more

解决方法：

关闭linux的6379防火墙
在redis.conf文件中将 bind 127.0.0.1 注释，将protected-mode设置为no
在服务器上使用redis-cli -p 6379 连接成功，然后输入shutdown ，然后exit，最后重新输入redis-server redis.conf 重启
最后查看redis的进程，如下即可

1635175621415

Key测试：

import redis.clients.jedis.Jedis;
import java.util.Set;

public class TestKey {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("110.40.138.125",6378);//修改linux服务器上的端口为6378

        System.out.println("清空数据："+jedis.flushDB());
        System.out.println("判断某个键是否存在："+jedis.exists("username"));
        System.out.println("新增<'username','ldg'>键值对："+jedis.set("username","ldg"));
        System.out.println("新增<'password','password'>键值对："+jedis.set("password","password"));
        System.out.println("系统中所有的键如下：");
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);
        System.out.println("删除键password："+jedis.del("password"));
        System.out.println("判断某个键是否存在："+jedis.exists("password"));
        System.out.println("查看键username所存储的值类型："+jedis.type("username"));
        System.out.println("随机返回key空间的一个："+jedis.randomKey());
        System.out.println("重命名key："+jedis.rename("username","name"));
        System.out.println("取出改名后的name："+jedis.get("name"));
        System.out.println("按索引查询："+jedis.select(0));
        System.out.println("删除当前数据库中所有的key："+jedis.flushDB());
        System.out.println("返回当前数据库key的数目："+jedis.dbSize());
        System.out.println("删除所有数据库中的所有key："+jedis.flushAll());
        jedis.close();
    }
}

输出：

清空数据：OK
判断某个键是否存在：false
新增<'username','ldg'>键值对：OK
新增<'password','password'>键值对：OK
系统中所有的键如下：
[password, username]
删除键password：1
判断某个键是否存在：false
查看键username所存储的值类型：string
随机返回key空间的一个：username
重命名key：OK
取出改名后的name：ldg
按索引查询：OK
删除当前数据库中所有的key：OK
返回当前数据库key的数目：0
删除所有数据库中的所有key：OK

Process finished with exit code 0

TestString

import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;

public class TestString {
    public static void main(String[] args) throws InterruptedException {
        Jedis jedis = new Jedis("110.40.138.125",6378);

        jedis.flushDB();
        System.out.println("=======增加数据=========");
        System.out.println(jedis.set("k1","v1"));
        System.out.println(jedis.set("k2","v2"));
        System.out.println(jedis.set("k3","v3"));
        System.out.println("删除k2："+jedis.del("k2"));
        System.out.println("获取键k2："+jedis.get("k2"));
        System.out.println("修改k1："+jedis.set("k1","k1Changed"));
        System.out.println("获取k1的值："+jedis.get("k1"));
        System.out.println("在k3后面加入值："+jedis.append("k3","End"));
        System.out.println("k3的值："+jedis.get("k3"));
        System.out.println("增加多个键值对："+jedis.mset("k01","v01","k02","v02","k03","v03"));
        System.out.println("获取多个键值对："+jedis.mget("k01","k02","k03"));
        System.out.println("获取多个键值对："+jedis.mget("k01","k02","k03","k04"));
        System.out.println("删除多个键值对："+jedis.del("k01","k02"));
        System.out.println("获取多个键值对："+jedis.mget("k01","k02","k03"));
        jedis.flushDB();
        System.out.println("========新增键值对防止覆盖原先值==============");
        System.out.println(jedis.setnx("k1","v1"));
        System.out.println(jedis.setnx("k2","v2"));
        System.out.println(jedis.setnx("k2","v2-new"));
        System.out.println(jedis.get("k1"));
        System.out.println(jedis.get("k2"));

        System.out.println("========新增键值对并设置有效时间==============");
        System.out.println(jedis.setex("k3",2,"v3"));
        TimeUnit.SECONDS.sleep(3);
        System.out.println(jedis.get("k3"));
        System.out.println("=========获取原值，更新为新值=========");
        System.out.println(jedis.getSet("k2","k2GetSet"));
        System.out.println(jedis.get("k2"));
        System.out.println("获得k2值的字符串："+jedis.getrange("k2",2,4));


        jedis.close();
    }
}

输出：

=======增加数据=========
OK
OK
OK
删除k2：1
获取键k2：null
修改k1：OK
获取k1的值：k1Changed
在k3后面加入值：5
k3的值：v3End
增加多个键值对：OK
获取多个键值对：[v01, v02, v03]
获取多个键值对：[v01, v02, v03, null]
删除多个键值对：2
获取多个键值对：[null, null, v03]
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
========新增键值对防止覆盖原先值==============
1
1
0
v1
v2
========新增键值对并设置有效时间==============
OK
null
=========获取原值，更新为新值=========
v2
k2GetSet
获得k2值的字符串：Get

Process finished with exit code 0

其他的也就不在这里一一练习，和Redis的基本命令完全一样，可以多看基本命令操作

事务

正常执行

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class TestTx {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("110.40.138.125",6378);
        
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello","world");
        jsonObject.put("name","ldg");

        //开启事务
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
        try{
            multi.set("user1",result);
            multi.set("user2",result);
            multi.exec();//执行事务
        }catch(Exception ex){
            multi.discard();//放弃事务
        }finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            jedis.close();
        }
    }
}

输出：

1 2	{"name":"ldg","hello":"world"} {"name":"ldg","hello":"world"}

异常执行

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class TestTx {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("110.40.138.125",6378);

        jedis.flushDB();
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello","world");
        jsonObject.put("name","ldg");

        //开启事务
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
        try{
            multi.set("user1",result);
            multi.set("user2",result);
            int i = 1 / 0;//代码抛出异常，执行失败！
            multi.exec();//执行事务
        }catch(Exception ex){
            multi.discard();//放弃事务
            ex.printStackTrace();
        }finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            jedis.close();
        }
    }
}

输出：

java.lang.ArithmeticException: / by zero
	at com.ldg.TestTx.main(TestTx.java:22)
null
null

SpringBoot整合

SpringBoot操作数据：spring-data、jpa、jdbc、mongodb、redis！

SpeingData也是和SpringBoot齐名的项目！

说明：在SpringBoot2.x之后，原来得Jedis被替换为了lettuce？

jedis：采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全，使用jedis pool连接池！更像BIO模式！

lettuce：使用netty，实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数据，更像NIO模式！

源码分析：

RedisAutoConfiguration类

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}//我们可以自定义个redisTemplate来替换这个默认的
    )
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 默认的RedisTemplate没有过多的设置，redis对象都是需要序列化的
        // 两个泛型都是Object，Object的类型，我们使用后需要强制转换<String,Object>
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean // 由于String是redis最长使用的类型，所以单独提出来了一个bean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

整合测试

1、导入测试

<!-- 操作redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2、配置连接

# SpringBoot 所有的配置类，都有一个自动配置类 RedisAutoConfiguration
# 自动配置类都会绑定一个properties配置文件 RedisProperties
spring.redis.host = 110.40.138.125
spring.redis.port = 6378

3、测试

@SpringBootTest
class Redis02SpringbootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        // redusTemplate 操作不同类型的数据类型，api和我们的指令是一样的
        // opsForValue 操作字符串，类似String
        // opsForList 操作List 类似List
        // opsForSet
        // opsForHash
        // opsForZSet
        // opsForGeo
        // opsForHyperLogLog
        // 除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务和基本的CRUD
        // 获取redis的连接对象
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushDb();
//        connection.flushAll();

        redisTemplate.opsForValue().set("mykey","ldg");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
        redisTemplate.opsForValue().set("chinesekey","redis中文测试");
        System.out.println(redisTemplate.opsForValue().get("chinesekey"));
    }
}

IDEA 输出：

1 2	ldg redis中文测试

Linux服务器上查看keys *，发现乱码

1
2
3

127.0.0.1:6378> keys *
1) "\xac\xed\x00\x05t\x00\nchinesekey"
2) "\xac\xed\x00\x05t\x00\x05mykey"

解决服务器上乱码问题：

1635599024458

1635599187762

若在测试代码中，不对对象进行序列化，则会提示如下错误

1635667875633

测试代码：

@Test
public void test() throws JsonProcessingException {
    // 真实的开发一般都使用json来传递对象
    User user = new User("ldg",21);
    // String jsonUser = new ObjectMapper().writeValueAsString(user);
    redisTemplate.opsForValue().set("user",user);
    System.out.println(redisTemplate.opsForValue().get("user"));
}

User的Pojo类：

@Component
@AllArgsConstructor
@NoArgsConstructor
@Data
// 在企业中，我们的POJO类都会序列化
public class User {
    private String name;
    private int age;
}

解决序列化方式一：在POJO类中实现Serializable接口

@Component
@AllArgsConstructor
@NoArgsConstructor
@Data
// 在企业中，我们的POJO类都会序列化
public class User implements Serializable {
    private String name;
    private int age;
}

结果：

1	User(name=ldg, age=21)

解决序列化方式二：在测试代码中，自动进行序列化

@Test
public void test() throws JsonProcessingException {
    // 真实的开发一般都使用json来传递对象
    User user = new User("ldg",21);
    String jsonUser = new ObjectMapper().writeValueAsString(user);
    redisTemplate.opsForValue().set("user",jsonUser);
    System.out.println(redisTemplate.opsForValue().get("user"));
}

输出:

1	{"name":"ldg","age":21}

解决服务器乱码问题：

配置自己的RedisConfig，通过设置序列化的方式，解决服务端乱码的问题

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    // 固定模板
    // 编写我们对自己的redisTemplate
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
//        // 序列化配置
        Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        objectJackson2JsonRedisSerializer.setObjectMapper(om);
        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(objectJackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

测试代码：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.ldg.redis02springboot.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class Redis02SpringbootApplicationTests {

    @Autowired
    @Qualifier("redisTemplate") // 自定义的RedisConfig
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        // redusTemplate 操作不同类型的数据类型，api和我们的指令是一样的
        // opsForValue 操作字符串，类似String
        // opsForList 操作List 类似List
        // opsForSet
        // opsForHash
        // opsForZSet
        // opsForGeo
        // opsForHyperLogLog
        // 除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务和基本的CRUD
        // 获取redis的连接对象
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushDb();
//        connection.flushAll();

        redisTemplate.opsForValue().set("mykey","ldg");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
        redisTemplate.opsForValue().set("chinesekey","redis中文测试");
        System.out.println(redisTemplate.opsForValue().get("chinesekey"));
    }

    @Test
    public void test() throws JsonProcessingException {
        // 真实的开发一般都使用json来传递对象
        User user = new User("ldg",21);
        // String jsonUser = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("user",user);
        System.out.println(redisTemplate.opsForValue().get("user"));
    }
}

服务器端的keys *:

1 2	127.0.0.1:6378> keys * 1) "user"

RedisUtil工具类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

// 在我们真实的开发中，一般都会有一个封装的Utilslei
@Component
public class RedisUtil {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    // ================================= Common ===========================
    /*
        指定缓存失效时间
        @param key  键
        @param time 时间(秒)
     */
    public boolean expire(String key,long time){
        try{
            if(time > 0){
                redisTemplate.expire(key,time, TimeUnit.SECONDS);
            }
            return true;
        }catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }

    /*
       根据key 获取过期时间
       @param key 键 不能为null
       @return 时间(秒) 返回0代表永久将有效
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /*
       判断key是否存在
       @param key 键
       @return true 存在 false 不存在
     */
    public boolean hasKey(String key){
        try{
            return redisTemplate.hasKey(key);
        }catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }

    /*
       删除缓存
       @param key 可以传一个值或多个
     */
    public void del(String... key){
        if(key != null && key.length > 0){
            if(key.length == 1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }

    // ======================String===============================
    /*
        普通缓存获取
        @param key 键
        @return 值
     */
    public Object get(String key){
        return key == null ? null:redisTemplate.opsForValue().get(key);
    }
    /*
        普通缓存放入
        @param key 键
        @param value 值
        @return true 成功 false 失败
     */
    public boolean set(String key,Object value){
        try{
            redisTemplate.opsForValue().set(key,value);
            return true;
        }catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }
    /*
        普通缓存放入并设置时间
        @param key 键
        @param value 值
        @param time 时间（秒） time 要大于0 如果time小于等于0 将设置无限期
        @return true 成功 false 失败
     */
    public boolean set(String key,Object value,long time){
        try{
            if(time > 0){
                redisTemplate.opsForValue().set(key,value,time,TimeUnit.SECONDS);
            }else{
                set(key,value);
            }
            return true;
        }catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }
    /*
        递增
        @param key 键
        @param delta 要增加几（大于0）
     */
    public long incr(String key,long delta){
        if(delta < 0){
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key,delta);
    }

    /*
        递减
        @param key 键
        @param delta 要减少几（小于0）
     */
    public long decr(String key,long delta){
        if(delta > 0){
            throw new RuntimeException("递增因子必须小于0");
        }
        return redisTemplate.opsForValue().decrement(key,delta);
    }
    // ======================Map===============================
    /*
        HashGet
        @param key 键 不能为null
        @param item 项 不能为null
     */
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key,item);
    }

    /*
        获取hashKey对应的所有键值
        @param key 键
        @return 对应的多个键值
     */
    public Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }
    /*
        HashSet
        @param key 键
        @param map 对应多个键值
     */
    public boolean hmset(String key,Map<String,Object> map){
        try{
            redisTemplate.opsForHash().putAll(key,map);
            return true;
        }catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }

    /*
        HashSet 并设置时间
        @param key 键
        @param map 对应多个键值
        @param time 时间（秒）
        @return true 成功 false 失败
     */
    public boolean hmset(String key,Map<String,Object> map,long time){
        try{
            redisTemplate.opsForHash().putAll(key,map);
            if(time > 0){
                expire(key,time);
            }
            return true;
        }catch(Exception ex){
            ex.printStackTrace();
            return false;
        }
    }
    /*
        同一张Hash表中放入数据，如果不存在，将创建
        @param key 键
        @param item 项
        @param value 值
        @return true 成功 false 失败
     */
    public boolean hset(String key,String item,Object value){
        try{
            redisTemplate.opsForHash().put(key,item,value);
            return true;
        }catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }
    /*
        同一张Hash表中放入数据，如果不存在，将创建
        @param key 键
        @param item 项
        @param value 值
        @param time 时间(秒) 注意：如果已存在的hash表有时间，这里将会替换原有的时间
        @return true 成功 false 失败
     */
    public boolean hset(String key,String item,Object value,long time){
        try{
            redisTemplate.opsForHash().put(key,item,value);
            if(time > 0){
                expire(key,time);
            }
            return true;
        }catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }
     /*
        删除hash表中的值
        @param key 键 不能为null
        @param item 项 可以是多个，不能为null
     */
    public void hdel(String key,Object... item){
        redisTemplate.opsForHash().delete(key,item);
    }
     /*
        判断hash表中是否有该项的值
        @param key 键 不能为null
        @param item 项 可以是多个，不能为null
        @return true存在 false 不存在
     */
    public boolean hHashKey(String key,String item){
        return redisTemplate.opsForHash().hasKey(key,item);
    }
     /*
        hash 递增 如果不存在，就会创建一个，并把新增后的值返回
        @param key 键 不能为null
        @param item 项 可以是多个，不能为null
        @param by 要增加几（大于0）
     */
    public double hincr(String key,String item,double by){
        return redisTemplate.opsForHash().increment(key,item,by);
    }
     /*
        hash 递减
        @param key 键 不能为null
        @param item 项 可以是多个，不能为null
        @param by 要减少几（小于0）
     */
     public double hdecr(String key,String item,double by){
         return redisTemplate.opsForHash().increment(key,item,-by);
     }

    // ======================Set===============================
     /*
        根据key获取Set中的所有值
        @param key 键
     */
    public Set<Object> sGet(String key){
        try{
            return redisTemplate.opsForSet().members(key);
        }catch (Exception ex){
            ex.printStackTrace();
            return null;
        }
    }
     /*
        根据value从一个set中查询，是否存在
        @param key 键
        @param value 值
        @return true 存在 false 不存在
     */
    public boolean sHasKey(String key,Object value){
        try{
            return redisTemplate.opsForSet().isMember(key,value);
        } catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }
     /*
        将数据放入set缓存
        @param key 键
        @param value 值 可以是多个
        @return 成功个数
     */
    public long sSet(String key,Object... values){
        try{
            return redisTemplate.opsForSet().add(key,values);
        } catch (Exception ex){
            ex.printStackTrace();
            return 0;
        }
    }
    /*
        将数据放入set缓存
        @param key 键
        @param time 时间(秒)
        @param value 值 可以是多个
        @return 成功个数
     */
    public long sSetAndTime(String key,long time,Object... values){
        try{
            Long count = redisTemplate.opsForSet().add(key,values);
            if(time > 0){
                expire(key,time);
            }
            return count;
        } catch (Exception ex){
            ex.printStackTrace();
            return 0;
        }
    }
    /*
        获取set缓存的长度
        @param key 键
     */
    public long sGetSetSize(String key){
        try{
            return redisTemplate.opsForSet().size(key);
        } catch (Exception ex){
            ex.printStackTrace();
            return 0;
        }
    }
    /*
        移除值为value的
        @param key 键
        @param values 值 可以是多个
        @return 移除的个数
     */
    public long setRemove(String key,Object... values){
        try{
            Long count = redisTemplate.opsForSet().remove(key,values);
            return count;
        } catch (Exception ex){
            ex.printStackTrace();
            return 0;
        }
    }
    // ======================List===============================
    /*
        获取list缓存的内容
        @param key 键
        @param start 开始
        @param end 结束 0到-1 代表所有值
     */
    public List<Object> lGet(String key, long start, long end){
        try{
            return redisTemplate.opsForList().range(key,start,end);
        } catch (Exception ex){
            ex.printStackTrace();
            return null;
        }
    }
    /*
        获取list缓存的长度
        @param key 键
     */
    public long lGetListSize(String key){
        try{
            return redisTemplate.opsForList().size(key);
        } catch (Exception ex){
            ex.printStackTrace();
            return 0;
        }
    }
    /*
        通过索引 获取list中的值
        @param key 键
        @param index 索引 index >= 0 时， 0 表头，1 第二个元素，以此类推，index < 0时，-1
     */
    public Object lGetIndex(String key,long index){
        try{
            return redisTemplate.opsForList().index(key,index);
        } catch (Exception ex){
            ex.printStackTrace();
            return null;
        }
    }
    /*
        将list放入缓存
        @param key 键
        @param value 值
     */
    public boolean lSet(String key,Object value){
        try{
            redisTemplate.opsForList().rightPush(key,value);
            return true;
        } catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }
    /*
        将list放入缓存
        @param key 键
        @param value 值
        @param time 时间(秒)
     */
    public boolean lSet(String key,Object value,long time){
        try{
            redisTemplate.opsForList().rightPush(key,value);
            if(time > 0){
                expire(key,time);
            }
            return true;
        } catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }
    /*
        将list放入缓存
        @param key 键
        @param value 值
        @return
     */
    public boolean lSet(String key,List<Object> value){
        try{
            redisTemplate.opsForList().rightPushAll(key,value);
            return true;
        } catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }
     /*
        将list放入缓存
        @param key 键
        @param value 值
        @param time 时间(秒)
        @return
     */
     public boolean lSet(String key,List<Object> value,long time){
         try{
             redisTemplate.opsForList().rightPushAll(key,value);
             if(time > 0){
                 expire(key,time);
             }
             return true;
         } catch (Exception ex){
             ex.printStackTrace();
             return false;
         }
     }
     /*
        根据索引修改list中的某条数据
        @param key 键
        @param index 索引
        @param value 值
        @return
     */
    public boolean lUpdateIndex(String key,long index,Object value){
        try{
            redisTemplate.opsForList().set(key,index,value);
            return true;
        } catch (Exception ex){
            ex.printStackTrace();
            return false;
        }
    }
    /*
        移除N个值为value
        @param key 键
        @param count 移除多少个
        @param value 值
        @return 移除的个数
     */
    public long lRemove(String key,long count,Object value){
        try{
            Long remove = redisTemplate.opsForList().remove(key,count,value);
            return remove;
        } catch (Exception ex){
            ex.printStackTrace();
            return 0;
        }
    }

}

IDEA测试：

@Test
public void test1(){
    redisUtil.set("name","ldg");
    System.out.println(redisUtil.get("name"));
}

IDEA输出：

ldg

服务器段输出：

127.0.0.1:6378> keys *
1) "user"
2) "name"
127.0.0.1:6378> get name
"\"ldg\""