05Redis --事务、乐观锁、Jedis -- 删除

gh-xiaohe

已于 2023-04-25 19:26:55 修改

阅读量583

点赞数 1

分类专栏： # Redis 文章标签： redis 数据库 nosql

于 2022-03-04 14:39:24 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/gh_xiaohe/article/details/123266005

版权

Redis 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

目录

正常执行事务

编译型异常

运行时异常（I/O）

监控 Watch（面试常问）

redis监视测试

正常执行成功！

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

1、导入对应的依赖

2、编码测试：

事务成功执行

事务出现异常

完成一个手机验证码功能

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);
    }
}

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

打赏作者

gh-xiaohe 你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20

扫码支付：¥1

获取中

扫码支付

您的余额不足，请更换扫码支付或充值

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。