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

我這邊把業務寫進去了。通過反射找到對應的方法。執行。只能幫到這裏了