04Redis--三种特殊数据类型、事务、乐观锁、Jedis

目录

geospatial(地理位置)

（1）geoadd 添加地址位置

（2）geodist 两人之间的距离

（3）geopos 获取当前的定位：一定是一个坐标值

（4）georadius 以给定的经纬度为中心，找出某一半径的元素

（5）georadiusbymember 找出位于指定元素周围的其他元素

（6）geohash 返回一个或多个位置元素的 geohash表示 

查看地图中所有的元素信息

移除地图中指的元素

Hyperloglog 基数统计

（1）创建 pfadd

（2）合并 pferage

（3）查看 pfcount

bitmap (位存储 ) 两个状态

（1）设置值

（2） 查看某个具体的值

（3）统计操作，统计打卡的天数

---

geospatial(地理位置)

朋友定位，附近的人，打车距离技术，这个功能可以推算地理位置信息，两地之间的距离，方圆几里的人！

Redis 的 Geo 在reids 3.2 版本就推出了
可以查询一些测试数据：经纬度查询 - 坐标拾取系统

（1）geoadd 添加地址位置

规则：两级无法直接添加，我们一般会下载城市数据，直接通过java程序一下性导入！

参数 key 值 （经度、纬度、名称）
127.0.0.1:6379> geoadd china:city 116 39 beijing
(integer) 1
127.0.0.1:6379> geoadd china:city 121 31 shanghai
(integer) 1
127.0.0.1:6379> geoadd china:city 120 30 hangzhou
(integer) 1
127.0.0.1:6379> geoadd china:city 113 22 shenzhen
(integer) 1
127.0.0.1:6379> geoadd china:city 117 39 tianjin
(integer) 1
127.0.0.1:6379> geoadd china:city 117 21212 tianjin   # 错误添加数值 超过范围
(error) ERR invalid longitude,latitude pair 117.000000,21212.000000

（2）geodist 两人之间的距离

单位： m、km、mi 英里 、 ft英尺

127.0.0.1:6379> geodist china:city beijing shanghai km # 查看北京到上海的直线距离
"999.2077"
127.0.0.1:6379> geodist china:city shenzhen tianjin km # 查看深圳到天津的直线距离
"1928.7377"

（3）geopos 获取当前的定位：一定是一个坐标值

127.0.0.1:6379> geopos china:city shenzhen  # 获取制定城市的精度和维度
1) 1) "112.99999862909317017"
   2) "21.99999950739083232"
127.0.0.1:6379> geopos china:city beijing
1) 1) "116.00000113248825073"
   2) "38.99999918434559731"

（4）georadius 以给定的经纬度为中心，找出某一半径的元素

127.0.0.1:6379> zrange china:city 0 -1   # 获取全部的地图中元素
1) "shenzhen"
2) "hangzhou"
3) "shanghai"
4) "beijing"
5) "tianjin"
127.0.0.1:6379> GEORADIUS china:city 110 30 2000 km # 查看 以 100 30 为中心 2000 为半径 周围内的城市
1) "shenzhen"
2) "hangzhou"
3) "shanghai"
4) "beijing"
5) "tianjin"
127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km # 查看 以 100 30 为中心 1000 为半径 周围内的城市
1) "shenzhen"
2) "hangzhou"
127.0.0.1:6379> georadius china:city 110 30 1000 km withdist # 查看 以 100 30 为中心 1000 为半径 周围内的城市 并且显示 到中间的距离位置
1) 1) "shenzhen"
   2) "938.8574"
2) 1) "hangzhou"
   2) "962.9418"
127.0.0.1:6379> georadius china:city 110 30 1000 km withcoord # 显示他人的定位信息
1) 1) "shenzhen"
   2) 1) "112.99999862909317017"
      2) "21.99999950739083232"
2) 1) "hangzhou"
   2) 1) "120.00000089406967163"
      2) "30.00000024997701331"
127.0.0.1:6379> georadius china:city 110 30 1000 km withcoord count 1 # 筛选出指定的结果
1) 1) "shenzhen"
   2) 1) "112.99999862909317017"
      2) "21.99999950739083232"
127.0.0.1:6379> georadius china:city 110 30 1000 km withcoord count 2
1) 1) "shenzhen"
   2) 1) "112.99999862909317017"
      2) "21.99999950739083232"
2) 1) "hangzhou"
   2) 1) "120.00000089406967163"
      2) "30.00000024997701331"

（5）georadiusbymember 找出位于指定元素周围的其他元素

127.0.0.1:6379> GEORADIUSBYMEMBER china:city shenzhen 1000 km
1) "shenzhen"
127.0.0.1:6379> GEORADIUSBYMEMBER china:city hangzhou 1000 km
1) "hangzhou"
2) "shanghai"

（6）geohash 返回一个或多个位置元素的 geohash表示 

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

127.0.0.1:6379> geohash china:city hangzhou beijing
1) "wtm6dtm6dt0"
2) "wwfmzesx7y0"

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

查看地图中所有的元素信息

移除地图中指的元素

127.0.0.1:6379> zrange china:city 0 -1  # 查看地图中所有的元素信息
1) "shenzhen"
2) "hangzhou"
3) "shanghai"
4) "beijing"
5) "tianjin"
127.0.0.1:6379> zrem china:city beijing  # 移除地图中指的元素
(integer) 1
127.0.0.1:6379> zrem china:city shenzhen 
(integer) 1
127.0.0.1:6379> zrange china:city 0 -1
1) "hangzhou"
2) "shanghai"
3) "tianjin"

Hyperloglog 基数统计

什么是基数

a{1，3，5，7，8，7}
b{1，2，5，7，8}
基数（不重复的元素）=5，可以接受误差

Redis hyperloglog 基数统计算法
优点：占用内存是固定的，2^64不同元素计数，只需要费12kb的内存，如果要从内存角度比较hyperloglog首选
网页的uv（一个人访问一个网站多次，但是还是算作一个人）
传统的方式，set保护用户的id，其元素不重复，然后就可以统计set中元素的数量作为标准判断
这个方式如果保持大量用户id就会比较麻烦，我们的目的就是为了计数，而不是保存用户id；
0.81%的错误率，可以接受

（1）创建 pfadd

（2）合并 pferage

（3）查看 pfcount

127.0.0.1:6379> pfadd mykey a s d f g h z x c v # 创建第一组元素 mykey
(integer) 1
127.0.0.1:6379> pfcount mykey # 统计 mykey 元素的基数数量
(integer) 10
127.0.0.1:6379> pfadd mykey2 q w e r t y z x c v # 创建第二组元素 mykey2
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 10
127.0.0.1:6379> pfmerge mykey3 mykey mykey2 # 合并两组 mykey mykey2 -> mykey3 并集
OK
127.0.0.1:6379> pfcount mykey3 # 查看并集的数量
(integer) 15

如果允许容错统计数量，可以使用hyperloglog
如果不允许使用set或者其他数据类型

bitmap (位存储 ) 两个状态

位存储

统计用户信息，活跃，不活跃，登入，为登入，打卡，365打卡！两个状态的都可以使用bitmaps
bitmaps位图，数据结构，都是操作二进制位来进行记录的，就只有0，1两个状态
365=365 bit 1 字节=8 bit 46字节左右！

测试
记录周一到周日打卡
周一：1，周二：1，周三：0 周四 0 周五 1周六 1周日 1

（1）设置值

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

（2） 查看某个具体的值

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

（3）统计操作，统计打卡的天数

127.0.0.1:6379> bitcount sing  # 统计这周打卡的记录，查看是否有全勤
(integer) 5

 redis事务本质：一组命令的集合!一个事务中的所有命令都会被序列化，执行过程中按照顺序执行
一次性，顺序性，排他性，执行一些列的命令

redis单条命令是保持原子性，但是事务不保证原子性
redis事务没有隔离级别的概念

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

redis事务

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

正常执行事务

127.0.0.1:6379> multi            # 将开启是事务
OK
# 命令入队
127.0.0.1:6379(TX)> set k1 v1
QUEUED                           # QUEUED 排队 
127.0.0.1:6379(TX)> set k2 v2 
QUEUED
127.0.0.1:6379(TX)> get k1
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> exec        # 执行
1) OK
2) OK
3) "v1"
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 k3 v3
QUEUED
127.0.0.1:6379(TX)> DISCARD  # 取消事务
OK
127.0.0.1:6379> get k3       # 事务队列中命令都不会被执行 
(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 v3
QUEUED
127.0.0.1:6379(TX)> setget k4 v4  # 错误的命令
(error) ERR unknown command `setget`, with args beginning with: `k4`, `v4`, 
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)

运行时异常（I/O）

（其他命令正常执行，错误命令抛出异常）

127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incr k1    # 执行时报错 incr 只能自增数字类型 不能 是String类型
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"
127.0.0.1:6379> get k2
"v2"
127.0.0.1:6379> get k3
"v3"

监控  Watch（面试常问）

悲观锁：很悲观，认为什么时候都会出现问题，无论什么都会加锁，效率降低
乐观锁：

• 很乐观，认为什么时候都不会出现问题，所以不上锁，更新数据时会判断在此期间是否有人改动数据，version！
• 获取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
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(TX)> exec
(nil)
127.0.0.1:6379> unwatch         # 1.如果发现事务执行失败，就先解锁
OK
127.0.0.1:6379> watch money     # 2.获取最新的值，在次监视 类似于MySql select version   
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 money 10
QUEUED
127.0.0.1:6379(TX)> exec        # 比对监视的值是否发生了变化，如果没有变化，那么可以执行成功
1) (integer) 990                  如果发生了变化就执行失败  
2) (integer) 1000

Jedis

我们要使用java操作redis，要知其然并知其所以然

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

测试： 

1、导入对应的依赖

        <!--导入jedis的包-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>
        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.70</version>
        </dependency>

2、编码测试：

• 链接redis
• 操作命令
• 断开链接

开放端口6379
firewall-cmd --permanent --zone=public --add-port=6379/tcp --permanent

重启防火墙服务
systemctl restart firewalld.service

重启redis-server
redis-server gconfig/redis.conf 

public class RedisTest {
    public static void main(String[] args) {

        //1、 new  jedis 对象
        Jedis jedis = new Jedis("127.0.0.1",6379);
        //Jedis 所有的命令就是我们之前学习的所有指令
        System.out.println(jedis.ping());
    }
}

输出：

 

Redis -Key

/**
 * @author gh  Email:@2495140780qq.com
 * @Description
 * @date 2022-03-04-上午 11:54
 */
public class TestKey {
    public static void main(String[] args) {

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

Redis -String

/**
 * @author gh  Email:@2495140780qq.com
 * @Description
 * @date 2022-03-04-下午 12:06
 */
public class TestString {
    public static void main(String[] args) {

        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();
        System.out.println(" ===========增加数据 ===========");
        System.out.println(jedis.set("key1", "value1"));
        System.out.println(jedis.set("key2", "value2"));
        System.out.println(jedis.set("key3", "value3"));
        System.out.println("删除键key2:" + jedis.del("key2"));
        System.out.println("获取键key2:" + jedis.get("key2"));
        System.out.println("修改key1:" + jedis.set("key1", "value1Changed"));
        System.out.println("获取key1的值：" + jedis.get("key1"));
        System.out.println("在key3后面加入值：" + jedis.append("key3", "End"));
        System.out.println("key3的值：" + jedis.get("key3"));

        System.out.println("增加多个键值对：" + jedis.mset("key01", "value01", "key02", "value02", "key03", "values03"));
        System.out.println("获取多个健值对：" + jedis.mget("key01", "key02", "key03"));
        System.out.println("获取多个键值对：" + jedis.mget("key01", "key02", "key03", "key04"));
        System.out.println(" 删除多个键值对：" + jedis.del("key01", " key02"));
        System.out.println(" 获取多个键值对：" + jedis.mget("key01", "key02", "key03"));

        jedis.flushDB();
        System.out.println("===========新增键值对防止覆盖原先值==========");
        System.out.println(jedis.setnx("key1", "value1"));
        System.out.println(jedis.setnx("key2", "value2"));
        System.out.println(jedis.setnx("key2", "value2-new"));
        System.out.println(jedis.get("key1"));
        System.out.println(jedis.get("key2"));

        System.out.println("===========新增键值对并设置有效时间=============");
        System.out.println(jedis.setex("key3", 2, "value3"));
        System.out.println(jedis.get("key3"));
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println(jedis.get("key3"));
            System.out.println("===========获取原值，更新为新值==========");
            System.out.println(jedis.getSet("key2", "key2GetSet"));
            System.out.println(jedis.get("kev2"));
            System.out.println("获得key2的值的字串：" + jedis.getrange("key2", 2, 4));
        }
    }
}

 Redis-List

/**
 * @author gh  Email:@2495140780qq.com
 * @Description
 * @date 2022-03-04-下午 12:28
 */
public class TestList {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();

        System.out.println("=========添加一个list========");
        jedis.lpush("collections", "ArrayList", "Vector", "Stack", "HashMap", "WeakHashMap", "LinkedHashmap");
        jedis.lpush("collections", "Hashset");
        jedis.lpush("collections", "TreeSet");
        jedis.lpush("collections", "TreeMap");
        System.out.println("collections的内容 : "+jedis.lrange("collections", 0 , -1));
        System.out.println("collections区间 0 -3 的内容 : "+jedis.lrange("collections", 0 , 3));

        System.out.println("======================");
        //删除列表中指定的值，第二个参数为删除的个数（有重复时），后add进去的值被先删，类似于出栈
        System.out.println("删除指定的元素:" + jedis.lrem("collections",2,"HashMap"));
        System.out.println("collections的内容 : "+jedis.lrange("collections", 0 , -1));
        System.out.println("collections区间 0 -3 的内容 : "+jedis.lrange("collections", 0 , 3));
        System.out.println("collections列表出栈（左端） : "+jedis.lpop("collections"));
        System.out.println("collections的内容 : "+jedis.lrange("collections", 0 , -1));
        System.out.println("collections添加元素，从列表的右端添加 rpush : "+jedis.rpush("collections", "EnumMap"));
        System.out.println("collections的内容 : "+jedis.lrange("collections", 0 , -1));
        System.out.println("collections列表出栈（右端） : "+jedis.rpop("collections"));
        System.out.println("collections的内容 : "+jedis.lrange("collections", 0 , -1));
        System.out.println("修改collections指定下标1的内容:" + jedis.lset("collections",1,"LinkArrayList"));
        System.out.println("collections的内容 : "+jedis.lrange("collections", 0 , -1));

        System.out.println("=============================");
        System.out.println("collections的长度 : "+jedis.llen("collections"));
        System.out.println("获取collections指定下标 2 的内容:" + jedis.lindex("collections",2));

        System.out.println("=============================");
        jedis.lpush("sortedList", "3", "6", "2", "0", "7", "4");
        System.out.println("sortedList排序前" + jedis.lrange("sortedList",0,-1));
        System.out.println(jedis.sort("sortedList"));
        System.out.println("sortedList排序后" + jedis.lrange("sortedList",0,-1));
    }
}

 Redis-Set

/**
 * @author gh  Email:@2495140780qq.com
 * @Description
 * @date 2022-03-06-下午 1:52
 */
public class TestSet {
    public static void main(String[] args) {

        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();
        System.out.println("==============像集合中廷加元素（不重复）==============");
        System.out.println(jedis.sadd("eleSet","e1","e2","e3","e4","e5","e7","e8","e0"));
        System.out.println(jedis.sadd("eleSet","e6"));

        System.out.println("eleSet的所有元素为：" + jedis.smembers("eleSet"));
        System.out.println("删除一个元素e0 :" + jedis.srem("eleSet", "e0"));
        System.out.println("eleSet的所有元素为：" + jedis.smembers("eleSet"));
        System.out.println("删除连个个元素e7 和 e6 :" + jedis.srem("eleSet", "e6","e7"));
        System.out.println("eleSet的所有元素为：" + jedis.smembers("eleSet"));
        System.out.println("随机的移除集合中一个元素：" + jedis.spop("eleSet"));
        System.out.println("随机的移除集合中一个元素：" + jedis.spop("eleSet"));
        System.out.println("eleSet的所有元素为：" + jedis.smembers("eleSet"));
        System.out.println("e3是否在 eleSet中 :" + jedis.sismember("eleSet", "e3"));
        System.out.println("e1是否在 eleSet中 :" + jedis.sismember("eleSet", "e1"));
        System.out.println("e5是否在 eleSet中 :" + jedis.sismember("eleSet", "e5"));

        System.out.println("========================================");
        System.out.println(jedis.sadd("eleSet1","e0","e1","e2","e3","e4","e5","e7","e8"));
        System.out.println(jedis.sadd("eleSet2","e0","e1","e2","e3","e4","e8"));
        System.out.println("将算了Set1中删除e1并存入 eleSet3 中" + jedis.smove("eleSet1", "eleSet3", "e1"));//移动到集合元素
        System.out.println("将算了Set1中删除e2并存入 eleSet3 中" + jedis.smove("eleSet1", "eleSet3", "e2"));
        System.out.println("eleSet1的所有元素为：" + jedis.smembers("eleSet1"));
        System.out.println("eleSet3的所有元素为：" + jedis.smembers("eleSet3"));

        System.out.println("===============集合运算=====================");
        System.out.println("eleSet1的所有元素为：" + jedis.smembers("eleSet1"));
        System.out.println("eleSet2的所有元素为：" + jedis.smembers("eleSet2"));
        System.out.println("eleSet1 和 eleSet2的交集 ：" + jedis.sinter("eleSet1","eleSet2"));
        System.out.println("eleSet1 和 eleSet2的交集 ：" + jedis.sunion("eleSet1","eleSet2"));
        System.out.println("eleSet1 和 eleSet2的交集 ：" + jedis.sdiff("eleSet1","eleSet2"));
        jedis.sinterstore("eleSet4", "eleSet1", "eleSet2");//求交集并将交集保存到  eleSet4 中
        System.out.println("eleSet4的所有元素为：" + jedis.smembers("eleSet4"));
        System.out.println();

    }
}

事务

事务成功执行

/**
 * @author gh  Email:@2495140780qq.com
 * @Description
 * @date 2022-03-04-下午 2:30
 */
public class TestTx {
    public static void main(String[] args) {

        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.flushDB();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "zhangsan");
        jsonObject.put("age", 15);

        String result = jsonObject.toString();

        Transaction multi = jedis.multi();//开启事务
        try {
            multi.set("user1", result);
            multi.set("user2", result);

            multi.exec();//执行事务
        } catch (Exception e) {
            //出现异常，就放弃事务
            multi.discard();
            e.printStackTrace();
        } finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            jedis.close();//关闭链接
        }
    }
}

事务出现异常

/**
 * @author gh  Email:@2495140780qq.com
 * @Description
 * @date 2022-03-04-下午 2:30
 */
public class TestTx {
    public static void main(String[] args) {

        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.flushDB();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "zhangsan");
        jsonObject.put("age", 15);

        String result = jsonObject.toString();

        Transaction multi = jedis.multi();//开启事务
        try {
            multi.set("user1", result);
            multi.set("user2", result);

            int i = 1 / 0;  //制造异常
            
            multi.exec();//执行事务
        } catch (Exception e) {
            //出现异常，就放弃事务
            multi.discard();
            e.printStackTrace();
        } finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            jedis.close();//关闭链接
        }
    }
}

Jedis实例

完成一个手机验证码功能

要求：
1、输入手机号，点击发送后随机生成6位数字码，2分钟有效
2、输入验证码，点击验证，返回成功或失败
3、每个手机号每天只能输入3次

import redis.clients.jedis.Jedis;

import java.util.Random;
import java.util.Scanner;
/**
 * @author gh  Email:@2495140780qq.com
 * @Description
 * @date 2022-03-04-下午 3:25
 */
public class PhoneVerificationCode {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (true) {
            System.out.println("请输入手机号：");
            String phone = in.nextLine();
            if (verifyPhone(phone)) {
                System.out.println("请输入验证码：");
                String code = in.nextLine();
                if(verifyCode(phone,code)) System.out.println("成功");
                else System.out.println("失败");
            }
        }
    }
    /**
     * 生成六位验证码
     *
     * @return 返回生成的验证码
     */
    public static String createCode() {
        Random random = new Random();
        StringBuilder code = new StringBuilder();
        for (int i = 0; i < 6; i++) {
            int temp = random.nextInt(10);
            code.append(temp);
        }
        return String.valueOf(code);
    }
    /**
     * 验证码存入redis中，设置过期时间；每个手机每天只能发三次
     *
     * @param phone 手机号
     * @return 是否发送三次以内
     */
    public static boolean verifyPhone(String phone) {
        //链接redis
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        //手机发送次数key
        String phoneKey = "verifyKey " + phone + ":counts";
        //验证码key
        String codeKey = "VerifyKey " + phone + ":code";
        //判断是否发送验证码
        boolean flag = false;
        //每个手机只能发送三次
        String count = jedis.get(phoneKey);
        if (count == null) {  //不存在这个手机号，生成一个
            jedis.setex(phoneKey, 24 * 60 * 60, "1");
            flag = true;
        } else if (Integer.parseInt(count) <= 2) {  //存在这个手机号，并且发送次数小于等于2
            jedis.incr(phoneKey);
            flag = true;
        } else  //存在这个手机号，并且发送次数达到3次
            System.out.println("该手机号一天内已经发送三次验证码，请一天后再次尝试");
        if (flag) {
            String code = createCode();
            System.out.println("验证码为：" + code);
            jedis.set(codeKey, code);
        }
        jedis.close();
        return flag;
    }
    /**
     * 判断验证码是否正确
     *
     * @param phone 手机号
     * @param code  验证码
     * @return 验证码是否正确
     */
    public static boolean verifyCode(String phone, String code) {
        //链接redis
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        //验证码key
        String codeKey = "VerifyKey " + phone + ":code";
        jedis.close();
        return jedis.get(codeKey).equals(code);
    }
}