redis13---事务处理。

Jedis事务
我们使用JDBC连接Mysql的时候，每次执行sql语句之前，都需要开启事务；在MyBatis中，
也需要使用openSession()来获取session事务对象，来进行sql执行、查询等操作。当我们
对数据库的操作结束的时候，是事务对象负责关闭数据库连接。

事务对象用于管理、执行各种数据库操作的动作。它能够开启和关闭数据库连接，执行sql
语句，回滚错误的操作。

我们的Redis也有事务管理对象，其位于redis.clients.jedis.Transaction下。

Jedis事务的相关代码:

1. package cn.com.redis;
2. import redis.clients.jedis.Jedis;
3. import redis.clients.jedis.Transaction;
4. public class Test7 {
5. public static void main(String[] args) {
6. Jedis jedis = new Jedis("192.168.248.129",6379);
7. Transaction transaction=jedis.multi();//返回一个事务控制对象
8. //预先在事务对象中装入要执行的操作
9. transaction.set("k4", "v4");
10. transaction.set("k5", "v5");
11. transaction.exec();//执行
12. }
13. }

我们查看一下redis:

发现数据已经加入进去

我们把k4的value和k5的value改为“v44”和“v55”,
然后在transaction.exec()语句后加入transaction.discard()语句:

1. package cn.com.redis;
2. import redis.clients.jedis.Jedis;
3. import redis.clients.jedis.Transaction;
4. public class Test7 {
5. public static void main(String[] args) {
6. Jedis jedis = new Jedis("192.168.248.129",6379);
7. Transaction transaction=jedis.multi();//返回一个事务控制对象
8. //预先在事务对象中装入要执行的操作
9. transaction.set("k4", "v44");
10. transaction.set("k5", "v55");
11. transaction.discard();//回滚
12. }
13. }

会发现数据插入操作被回滚，redis中那两个值未被改变:


我们模拟一个刷一次信用卡的交易，使用redis的事务来处理一些逻辑:

1. package cn.com.redis;
2. import redis.clients.jedis.Jedis;
3. import redis.clients.jedis.Transaction;
4. public class TestTransaction {
5. //模拟信用卡消费和还款
6. public static void main(String[] args) {
7. TestTransaction t = new TestTransaction();
8. boolean retValue = t.transMethod(100);
9. if(retValue){
10. System.out.println("使用信用卡消费成功！");
11. }else{
12. System.out.println("使用信用卡消费失败！");
13. }
14. }
15. /**
16. * 通俗点讲，watch命令就是标记一个键，如果标记了一个键，
17. * 在提交事务前如果该键被别人修改过，那事务就会失败，这种情况通常可以在程序中
18. * 重新再尝试一次。
19. *
20. * 首先标记了balance，然后检查余额是否足够，不足就取消标记，并不做扣减；
21. * 足够的话，就启动事务进行更新操作。
22. * 如果在此期间键balance被其他人修改，拿在提交事务(执行exec)时就会报错，
23. * 程序中通常可以捕获这类错误再重新执行一次，直到成功。
24. * */
25. private boolean transMethod(int amount) {
26. System.out.println("您使用信用卡预付款"+amount+"元");
27. Jedis jedis = new Jedis("192.168.248.129",6379);
28. int balance = 1000;//可用余额
29. int debt;//欠额
30. int amtToSubtract = amount;//实刷额度
31. jedis.set("balance", String.valueOf(balance));
32. jedis.watch("balance");
33. //jedis.set("balance", "1100");//此句不该出现，为了模拟其他程序已经修改了该条目
34. balance = Integer.parseInt(jedis.get("balance"));
35. if(balance < amtToSubtract){//可用余额小于实刷金额，拒绝交易
36. jedis.unwatch();
37. System.out.println("可用余额不足！");
38. return false;
39. }else{//可用余额够用的时候再去执行扣费操作
40. System.out.println("扣费transaction事务开始执行...");
41. Transaction transaction = jedis.multi();
42. transaction.decrBy("balance",amtToSubtract);//余额减去amtToSubtract的钱数
43. transaction.incrBy("debt", amtToSubtract);//信用卡欠款增加amtToSubtract的钱数
44. transaction.exec();//执行事务
45. balance = Integer.parseInt(jedis.get("balance"));
46. debt = Integer.parseInt(jedis.get("debt"));
47. System.out.println("扣费transaction事务执行结束...");
48. System.out.println("您的可用余额:"+balance);
49. System.out.println("您目前欠款:"+debt);
50. return true;
51. }
52. }
53. }

此代码就是模拟用户使用信用卡刷了100元的东西，此时应该减去信用卡的可用余额100元，
增加100元的欠款。

运行结果:


redis的结果:

证明我们的操作是成功的。

加watch命令是为了在事务执行的过程中，防止其它的操作打断事务，或者是影响事务的计算结果，
导致“幻读”、“脏数据”等异常情况的发生。watch命令建立了一个键，一旦发现执行过程中该
键被别人修改过，那事务就会失败，程序中通常可以捕获这类错误再重新执行一次，直到成功。
所以watch命令可以保证数据的同步安全。

为了证明watch命令的用途，我们把上面代码里面的jedis.set("balance", "1100");注释释放，
然后transMethod方法抛出打断异常:throws InterruptedException，main方法捕获打断异常，
然后弹出相应警告框。

1. package cn.com.redis;
2. import java.util.List;
3. import redis.clients.jedis.Jedis;
4. import redis.clients.jedis.Transaction;
5. public class TestTransaction {
6. //模拟信用卡消费和还款
7. public static void main(String[] args) {
8. TestTransaction t = new TestTransaction();
9. boolean retValue=false;
10. boolean Interrupted = false;
11. try {
12. retValue = t.transMethod(100);
13. } catch (InterruptedException e) {
14. Interrupted = true;
15. System.out.println("事务被打断，请重新执行!");
16. }finally{
17. if(retValue){
18. System.out.println("使用信用卡消费成功！");
19. }else{
20. if(!Interrupted){
21. System.out.println("使用信用卡消费失败！余额不足！");
22. }
23. }
24. }
25. }
26. /**
27. * 通俗点讲，watch命令就是标记一个键，如果标记了一个键，
28. * 在提交事务前如果该键被别人修改过，那事务就会失败，这种情况通常可以在程序中
29. * 重新再尝试一次。
30. *
31. * 首先标记了balance，然后检查余额是否足够，不足就取消标记，并不做扣减；
32. * 足够的话，就启动事务进行更新操作。
33. * 如果在此期间键balance被其他人修改，拿在提交事务(执行exec)时就会报错，
34. * 程序中通常可以捕获这类错误再重新执行一次，直到成功。
35. * */
36. private boolean transMethod(int amount) throws InterruptedException{
37. System.out.println("您使用信用卡预付款"+amount+"元");
38. Jedis jedis = new Jedis("192.168.248.129",6379);
39. int balance = 1000;//可用余额
40. int debt;//欠额
41. int amtToSubtract = amount;//实刷额度
42. jedis.set("balance", String.valueOf(balance));
43. jedis.watch("balance");
44. jedis.set("balance", "1100");//此句不该出现，为了模拟其他程序已经修改了该条目
45. balance = Integer.parseInt(jedis.get("balance"));
46. if(balance < amtToSubtract){//可用余额小于实刷金额，拒绝交易
47. jedis.unwatch();
48. System.out.println("可用余额不足！");
49. return false;
50. }else{//可用余额够用的时候再去执行扣费操作
51. System.out.println("扣费transaction事务开始执行...");
52. Transaction transaction = jedis.multi();
53. transaction.decrBy("balance",amtToSubtract);//余额减去amtToSubtract的钱数
54. transaction.incrBy("debt", amtToSubtract);//信用卡欠款增加amtToSubtract的钱数
55. List<Object> result = transaction.exec();//执行事务
56. if(result==null){//事务提交失败，说明在执行期间数据被修改过
57. System.out.println("扣费transaction事务执行中断...");
58. throw new InterruptedException();
59. }else{//事务提交成功
60. balance = Integer.parseInt(jedis.get("balance"));
61. debt = Integer.parseInt(jedis.get("debt"));
62. System.out.println("扣费transaction事务执行结束...");
63. System.out.println("您的可用余额:"+balance);
64. System.out.println("您目前欠款:"+debt);
65. return true;
66. }
67. }
68. }
69. }

再运行一下，看一下效果：


这就说明了，如果在watch命令执行后和事务提交之前，如果数据发生了修改操作，事务执行就不会成功，