springboot redis官方推荐的分布式锁redLock开发实战

redLock我这里不介绍了。想必大家应该都了解。毕竟在分布式锁领域，它被这么多人认可

引入maven依赖

<!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.11.5</version>
</dependency>

创建类RedisRedLock

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;

@Configuration
public class RedisRedLock{

    @Value("${spring.redis.sentinel.nodesRedis}")
    private String[] nodes;
    @Value("${spring.redis.sentinel.master}")
    private String master;

    /**
     * 单个服务
     * @return
     */
    @Bean
    public  RedissonClient redissonClientSign(){
        Config config = new Config();
        config.useSingleServer()
                .setIdleConnectionTimeout(10000)//如果当前连接池里的连接数量超过了最小空闲连接数，而同时有连接空闲时间超过了该数值，那么这些连接将会自动被关闭，并从连接池里去掉。时间单位是毫秒。
                .setConnectTimeout(30000)//同任何节点建立连接时的等待超时。时间单位是毫秒。
                .setTimeout(3000)//等待节点回复命令的时间。该时间从命令发送成功时开始计时。
                .setPingTimeout(30000)
                .setReconnectionTimeout(3000)//当与某个节点的连接断开时，等待与其重新建立
                .setPassword("root123456abc").setDatabase(0);
        return  Redisson.create(config);
    }

    /**
     * 哨兵模式
     * @return
     */
    @Bean
    public  RedissonClient redissonClient(){
        Config config = new Config();
        config.useSentinelServers().setMasterName(master)
                .setFailedSlaveReconnectionInterval(5000)
                .addSentinelAddress(nodes)
                .setMasterConnectionPoolSize(500)//设置对于master节点的连接池中连接数最大为500
                .setSlaveConnectionPoolSize(500)//设置对于slave节点的连接池中连接数最大为500
                .setIdleConnectionTimeout(10000)//如果当前连接池里的连接数量超过了最小空闲连接数，而同时有连接空闲时间超过了该数值，那么这些连接将会自动被关闭，并从连接池里去掉。时间单位是毫秒。
                .setConnectTimeout(30000)//同任何节点建立连接时的等待超时。时间单位是毫秒。
                .setTimeout(3000)//等待节点回复命令的时间。该时间从命令发送成功时开始计时。
                .setPingTimeout(30000)
                .setReconnectionTimeout(3000)//当与某个节点的连接断开时，等待与其重新建立
                .setPassword("root123456abc").setDatabase(0);
        return  Redisson.create(config);
    }


    @Autowired
    RedissonClient redissonClient;
  public RLock create(String key){
      return redissonClient.getRedLock(redissonClient.getLock(key));
  }


    /**
     * 分布式锁并利用反射进行业务处理
     * @param key
     * @param target
     * @param methodName
     * @param classes
     * @param args
     * @param <T>
     * @return
     */
   public  <T>boolean lockKey(String key,T target,String methodName,Class[] classes,Object...args){
       RLock redissonRedLock = create(key);
      try {
          if(redissonRedLock.tryLock(200, 60000, TimeUnit.MILLISECONDS)){
              Method method  = target.getClass().getMethod(methodName, classes);
              method.invoke(target,args);
              return true;
          }
      } catch (Exception e) {
          e.printStackTrace();
      }finally {
          try {
              //等待4秒释放锁
              Thread.sleep(4000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          redissonRedLock.unlock();
      }
      return false;
  }
}

这样就大功告成了。接下来调用

@RequestMapping("/isLock")
@ResponseBody
public Object isLock(HttpServletRequest request){
    String key = request.getParameter("key");
    EntityWrapper wrapper = new EntityWrapper<OmsOrder>();
    wrapper.eq("member_id","1");
    Class[] classes = new Class[]{Wrapper.class};
    if(redisRedLock.lockKey(key,portalOrderService,"selectCount",classes,wrapper)){
        System.out.println("获取锁成功");
    }else{
        System.out.println("获取锁失败");
    }
    return null;
}

我这边把业务写进去了。通过反射找到对应的方法。执行。只能帮到这里了