spring boot 利用redisson实现redis的分布式锁

原文：http://liaoke0123.iteye.com/blog/2375469

利用redis实现分布式锁，网上搜索的大部分是使用java jedis实现的。

redis官方推荐的分布式锁实现为redisson http://ifeve.com/redis-lock/

以下为spring boot实现分布式锁的步骤

项目pom中需要添加官方依赖 我是1.8JDK固为

1. <!-- redisson -->
2. <dependency>
3. <groupId>org.redisson</groupId>
4. <artifactId>redisson</artifactId>
5. <version>3.4.2</version>
6. </dependency>

定义一个分布式锁的回调类

1. package com.example.demo.redis2;
2. /**
3. * 分布式锁回调接口
4. *
5. * @author lk
6. */
7. public interface DistributedLockCallback<T> {
8. /**
9. * 调用者必须在此方法中实现需要加分布式锁的业务逻辑
10. *
11. * @return
12. */
13. public T process();
14. /**
15. * 得到分布式锁名称
16. *
17. * @return
18. */
19. public String getLockName();
20. }

分布式锁操作模板

1. package com.example.demo.redis2;
2. import java.util.concurrent.TimeUnit;
3. /**
4. * 分布式锁操作模板
5. *
6. * @author lk
7. */
8. public interface DistributedLockTemplate {
9. /**
10. * 使用分布式锁，使用锁默认超时时间。
11. *
12. * @param callback
13. * @return
14. */
15. public <T> T lock(DistributedLockCallback<T> callback);
16. /**
17. * 使用分布式锁。自定义锁的超时时间
18. *
19. * @param callback
20. * @param leaseTime 锁超时时间。超时后自动释放锁。
21. * @param timeUnit
22. * @return
23. */
24. public <T> T lock(DistributedLockCallback<T> callback, long leaseTime, TimeUnit timeUnit);
25. }

使用redisson最简单的Single instance mode实现分布式锁模板接口

1. package com.example.demo.redis2;
2. import org.redisson.api.RLock;
3. import org.redisson.api.RedissonClient;
4. import java.util.concurrent.TimeUnit;
5. /**
6. * Single Instance mode 分布式锁模板
7. *
8. * @author lk
9. */
10. public class SingleDistributedLockTemplate implements DistributedLockTemplate {
11. private static final long     DEFAULT_TIMEOUT   = 5;
12. private static final TimeUnit DEFAULT_TIME_UNIT = TimeUnit.SECONDS;
13. private RedissonClient    redisson;
14. public SingleDistributedLockTemplate() {
15. }
16. public SingleDistributedLockTemplate(RedissonClient redisson) {
17. this.redisson = redisson;
18. }
19. @Override
20. public <T> T lock(DistributedLockCallback<T> callback) {
21. return lock(callback, DEFAULT_TIMEOUT, DEFAULT_TIME_UNIT);
22. }
23. @Override
24. public <T> T lock(DistributedLockCallback<T> callback, long leaseTime, TimeUnit timeUnit) {
25. RLock lock = null;
26. try {
27. lock = redisson.getLock(callback.getLockName());
28. lock.lock(leaseTime, timeUnit);
29. return callback.process();
30. } finally {
31. if (lock != null) {
32. lock.unlock();
33. }
34. }
35. }
36. public void setRedisson(RedissonClient redisson) {
37. this.redisson = redisson;
38. }
39. }

创建可以被spring管理的 Bean

1. package com.example.demo.redis2;
2. import java.io.IOException;
3. import java.io.InputStream;
4. import javax.annotation.PostConstruct;
5. import javax.annotation.PreDestroy;
6. import org.apache.log4j.Logger;
7. import org.redisson.Redisson;
8. import org.redisson.api.RedissonClient;
9. import org.redisson.config.Config;
10. import org.springframework.beans.factory.FactoryBean;
11. /**
12. * 创建分布式锁模板实例的工厂Bean
13. *
14. * @author lk
15. */
16. public class DistributedLockFactoryBean implements FactoryBean<DistributedLockTemplate> {
17. private Logger                  logger = Logger.getLogger(DistributedLockFactoryBean.class);
18. private LockInstanceMode        mode;
19. private DistributedLockTemplate distributedLockTemplate;
20. private RedissonClient redisson;
21. @PostConstruct
22. public void init() {
23. String ip = "127.0.0.1";
24. String port = "6379";
25. Config config=new Config();
26. config.useSingleServer().setAddress(ip+":"+port);
27. redisson=Redisson.create(config);
28. System.out.println("成功连接Redis Server"+"\t"+"连接"+ip+":"+port+"服务器");
29. }
30. @PreDestroy
31. public void destroy() {
32. logger.debug("销毁分布式锁模板");
33. redisson.shutdown();
34. }
35. @Override
36. public DistributedLockTemplate getObject() throws Exception {
37. switch (mode) {
38. case SINGLE:
39. distributedLockTemplate = new SingleDistributedLockTemplate(redisson);
40. break;
41. }
42. return distributedLockTemplate;
43. }
44. @Override
45. public Class<?> getObjectType() {
46. return DistributedLockTemplate.class;
47. }
48. @Override
49. public boolean isSingleton() {
50. return true;
51. }
52. public void setMode(String mode) {
53. if (mode==null||mode.length()<=0||mode.equals("")) {
54. throw new IllegalArgumentException("未找到dlm.redisson.mode配置项");
55. }
56. this.mode = LockInstanceMode.parse(mode);
57. if (this.mode == null) {
58. throw new IllegalArgumentException("不支持的分布式锁模式");
59. }
60. }
61. private enum LockInstanceMode {
62. SINGLE;
63. public static LockInstanceMode parse(String name) {
64. for (LockInstanceMode modeIns : LockInstanceMode.values()) {
65. if (modeIns.name().equals(name.toUpperCase())) {
66. return modeIns;
67. }
68. }
69. return null;
70. }
71. }
72. }

配置进spring boot中

1. package com.example.demo.redis2;
2. import org.springframework.context.annotation.Bean;
3. import org.springframework.context.annotation.Configuration;
4. /**
5. * Created by LiaoKe on 2017/5/22.
6. */
7. @Configuration
8. public class BeanConfig {
9. @Bean
10. public DistributedLockFactoryBean distributeLockTemplate(){
11. DistributedLockFactoryBean d  = new DistributedLockFactoryBean();
12. d.setMode("SINGLE");
13. return d;
14. }
15. }

目前为止已经可以使用。

为了验证锁是否成功，我做了如下例子。

首先建立了一个数据库实体（使用的JPA），模拟被购买的商品数量，当被购买后，num+1

在高并发环境下，这必定会有问题，因为在查询之后的设值，存在对同一数据库源的操作。

1. package com.example.demo.redis2.entity;
2. import org.hibernate.annotations.GenericGenerator;
3. import javax.persistence.Entity;
4. import javax.persistence.GeneratedValue;
5. import javax.persistence.Id;
6. /**
7. * 测试类实体
8. * Created by LiaoKe on 2017/5/22.
9. */
10. @Entity
11. public class TestEntity {
12. @Id
13. @GeneratedValue(generator = "system-uuid")
14. @GenericGenerator(name = "system-uuid", strategy = "uuid")
15. private String id;
16. private Integer num;
17. public String getId() {
18. return id;
19. }
20. public void setId(String id) {
21. this.id = id;
22. }
23. public Integer getNum() {
24. return num;
25. }
26. public void setNum(Integer num) {
27. this.num = num;
28. }
29. }

具体数据库操作，加锁和不加锁的操作，要注意我使用了@Async，异步任务注解，我没有配置线程池信息，使用的默认线程池。

1. package com.example.demo.redis2.service;
2. import com.example.demo.redis2.DistributedLockCallback;
3. import com.example.demo.redis2.DistributedLockTemplate;
4. import com.example.demo.redis2.dao.TestEntityRepository;
5. import com.example.demo.redis2.entity.TestEntity;
6. import org.springframework.scheduling.annotation.Async;
7. import org.springframework.stereotype.Service;
8. import javax.annotation.Resource;
9. /**
10. * Created by LiaoKe on 2017/5/22.
11. */
12. @Service
13. public class AsyncService {
14. @Resource
15. TestEntityRepository ts;
16. @Resource
17. DistributedLockTemplate distributedLockTemplate;
18. /**
19. * 加锁
20. */
21. @Async
22. public void addAsync(){
23. distributedLockTemplate.lock(new DistributedLockCallback<Object>(){
24. @Override
25. public Object process() {
26. add();
27. return null;
28. }
29. @Override
30. public String getLockName() {
31. return "MyLock";
32. }
33. });
34. }
35. /**
36. * 未加锁
37. */
38. @Async
39. public void addNoAsync(){
40. add();
41. }
42. /**
43. * 测试异步方法
44. * 在不加分布式锁的情况下
45. * num数目会混乱
46. */
47. @Async
48. private void add(){
49. if(ts.findAll().size()==0){
50. TestEntity  t  =  new TestEntity();
51. t.setNum(1);
52. ts.saveAndFlush(t);
53. }else{
54. TestEntity dbt = ts.findAll().get(0);
55. dbt.setNum(dbt.getNum()+1);
56. ts.saveAndFlush(dbt);
57. }
58. }
59. }

最后为了测试简单跑了两个接口

1. package com.example.demo;
2. import com.example.demo.redis2.DistributedLockTemplate;
3. import com.example.demo.redis2.service.AsyncService;
4. import oracle.jrockit.jfr.StringConstantPool;
5. import org.springframework.boot.SpringApplication;
6. import org.springframework.boot.autoconfigure.SpringBootApplication;
7. import org.springframework.context.annotation.Bean;
8. import org.springframework.scheduling.annotation.EnableAsync;
9. import org.springframework.stereotype.Controller;
10. import org.springframework.web.bind.annotation.GetMapping;
11. import org.springframework.web.bind.annotation.RestController;
12. import javax.annotation.Resource;
13. @SpringBootApplication
14. @RestController
15. @EnableAsync
16. public class DemoApplication {
17. public static void main(String[] args) {
18. SpringApplication.run(DemoApplication.class, args);
19. }
20. @Resource
21. AsyncService as;
22. @GetMapping("")
23. public void test(){
24. for(int i = 0 ;i<10000;i++){
25. as.addNoAsync();
26. }
27. }
28. @GetMapping("lock")
29. public void  test2(){
30. for(int i = 0 ;i<10000;i++){
31. as.addAsync();
32. }
33. }
34. }

访问localhost:8888 及 localhost:8888/lock

在不加锁的情况下

 数据库已经爆炸了

最后得到的数据奇奇怪怪

使用加锁后的访问

 可以看到库存增加绝对正确。

此处并未使用任何数据库锁，并且基于redis，可在不同的网络节点实现上锁。

这只是简单的实现，在真正的生产环境中，还要注意许多问题，超时和放锁时机需要好好研究，在此不便贴真正项目代码。

参考博客：http://layznet.iteye.com/blog/2307179   感谢作者