分布式锁的实现工具类

蔚落 2024-03-31 11:26 77阅读 0赞

分布式锁一般使用缓存实现的，下面提供一个工具类，

##### 1、缓存配置： #####

bootstrap.yml 或者 application.properties：

spring.redis.cluster.nodes: " x.x.x.x:6379, x.x.x.x:6379"
    spring.cache.redis.timeToLive: 360

##### 2、添加pom依赖： #####

<dependency>
                <groupId>com.alibaba.fastjson2</groupId>
                <artifactId>fastjson2</artifactId>
                <version>2.0.17</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.12.0</version>
            </dependency>
    
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <version>2.7.0</version>
            </dependency>

##### 3、辅助工具类： #####

ErrorInfoEnum.java

/**
     * 系统及业务级别的通用错误码
     */
    public enum ErrorInfoEnum  {
        
      //成功
      SUCCESS("0", "success"),
    	
      ORDER_RESERVATION_GET_LOCK_ERROR("-110","加锁失败"),
      
      //失败
      FAILED("-1", "system exception");
    
      private String code;
    
      private String message;
    
      ErrorInfoEnum(String code, String message) {
        
        this.code = code;
        this.message = message;
      }
    
      public String getCode() {
        
        return code;
      }
    
      public void setCode(String code) {
        
        this.code = code;
      }
    
      public String getMessage() {
        
        return message;
      }
    
      public void setMessage(String message) {
        
        this.message = message;
      }
    
      @Override
      public String toString() {
        
        return "ErrorInfoEnum{" +
            "code='" + code + '\'' +
            ", message='" + message + '\'' +
            '}';
      }
    }

ReqBody.java

/**
     * 请求体
     * @param <T>
     */
    public final class ReqBody<T> {
        
    
      private static final long serialVersionUID = 1L;
    
      // 调用方应用名称
      protected String appName;
    
      // 数据来源
      protected String source;
    
      // 加密签名
      private String sign;
    
      //时间戳
      private String timestamp;
    
      //参数体
      protected T param;
    
      public String getAppName() {
        
        return appName;
      }
    
      public void setAppName(String appName) {
        
        this.appName = appName;
      }
    
      public String getSource() {
        
        return source;
      }
    
      public void setSource(String source) {
        
        this.source = source;
      }
    
      public String getSign() {
        
        return sign;
      }
    
      public void setSign(String sign) {
        
        this.sign = sign;
      }
    
      public String getTimestamp() {
        
        return timestamp;
      }
    
      public void setTimestamp(String timestamp) {
        
        this.timestamp = timestamp;
      }
    
      public T getParam() {
        
        return param;
      }
    
      public void setParam(T param) {
        
        this.param = param;
      }
    
      @Override
      public String toString() {
        
        return "ReqBody{" +
            "appName='" + appName + '\'' +
            ", source='" + source + '\'' +
            ", sign='" + sign + '\'' +
            ", timestamp='" + timestamp + '\'' +
            ", param=" + param +
            '}';
      }
    }

RespBody.java

/**
     * 返回体
     */
    public final class RespBody<T> implements Serializable {
        
    
      private static final long serialVersionUID = -3455864552409084052L;
    
      /**
       * 响应代码
       */
      private String code;
    
      /**
       * 响应消息
       */
      private String message;
    
      /**
       * 响应结果
       */
      private transient T result;
    
      public RespBody() {
        
        successParam();
      }
    
      public RespBody(T result) {
        
        successParam();
        this.result = result;
      }
    
      public void setIErrorInfo(ErrorInfoEnum errorInfo) {
        
        this.code = errorInfo.getCode();
        this.message = errorInfo.getMessage();
      }
    
      private void successParam() {
        
        this.code = ErrorInfoEnum.SUCCESS.getCode();
        this.message = ErrorInfoEnum.SUCCESS.getMessage();
      }
    }

##### 4、缓存工具类： #####

import com.alibaba.fastjson2.JSONObject;
    import com.zwt.common.ReqBody;
    import com.zwt.common.RespBody;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    import org.apache.commons.lang3.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Service;
    
    @Service
    public class RedisTemplateService {
        
    	private Logger log = LoggerFactory.getLogger(RedisTemplateService.class);
    	@Autowired
    	private RedisTemplate redisTemplate;
    
    	public RespBody<String> getRedisObjectByKey(ReqBody<String> reqBody) {
        
    		String result = null;
    		if (!StringUtils.isEmpty(reqBody.getParam())) {
        
    
    			Object lightObject = redisTemplate.opsForValue().get(reqBody.getParam());
    			result = JSONObject.toJSONString(lightObject);
    		}
    		return new RespBody<>(result);
    	}
    
    	public RespBody<String> getRedisListByKey(ReqBody<String> reqBody) {
        
    
    		String result = null;
    		if (!StringUtils.isEmpty(reqBody.getParam())) {
        
    
    			Object lightObject = redisTemplate.opsForList().range(reqBody.getParam(), 0, -1);
    			result = JSONObject.toJSONString(lightObject);
    		}
    		return new RespBody<>(result);
    	}
    
    	public RespBody<Object> setRedisObjectByKey(ReqBody<List<String>> reqBody) {
        
    
    		redisTemplate.opsForValue().set(reqBody.getParam().get(0), reqBody.getParam().get(1),
    				Integer.parseInt(reqBody.getParam().get(2)), TimeUnit.MINUTES);
    		return new RespBody<>();
    	}
    
    	public RespBody<Object> setRedisListByKey(ReqBody<List<String>> reqBody) {
        
    
    		Object ob = redisTemplate.opsForList().rightPush(reqBody.getParam().get(0), reqBody.getParam().get(1));
    
    		return new RespBody<>(ob);
    	}
    
    	public RespBody<Object> deleteRedisObjectByKey(ReqBody<String> reqBody) {
        
    
    		// 删除redis的值
    		redisTemplate.opsForValue().set(reqBody.getParam(), 1, 1, TimeUnit.MILLISECONDS);
    		return new RespBody<>();
    	}
    
    	public RespBody<Object> deleteRedisListByKey(ReqBody<List<String>> reqBody) {
        
    
    		// 删除redis的值
    		redisTemplate.opsForList().remove(reqBody.getParam().get(0), 0, reqBody.getParam().get(1));
    		return new RespBody<>();
    	}
    
    	/**
    	 * 加分布式锁
    	 *
    	 * @param key
    	 * @return
    	 */
    	public boolean lock(String key,int seconds) {
        
    		Boolean result = redisTemplate.opsForValue().setIfAbsent(key, System.currentTimeMillis(), seconds, TimeUnit.SECONDS);
    		log.info("[{}] 加分布式锁,过期时间 {} 秒,加锁结果 = {}", key, seconds, result);
    		return result;
    	}
    
    	/**
    	 * 解锁
    	 * @param key
    	 * @return
    	 */
    	public Boolean unlock(String key) {
        
    		log.info("{} 解锁", key);
    		return  redisTemplate.opsForValue().getOperations().delete(key);
    
    	}
    }

**3、业务代码中使用分布式锁：**  
1）引用缓存工具类

@Autowired
        private RedisTemplateService redisTemplateService;

2）方法中伪代码

// 加锁，一般1个固定字符串加一个字段（具有唯一性）
            String key = REDIS_KEY + reserveId;
            boolean lock = redisTemplateService.lock(key, EXPIRETIME_10S);
            if (!lock) {
        
                log.error("key={}加锁失败", key);
                throw new GlobalErrorInfoException(ErrorInfoEnum  .ORDER_RESERVATION_GET_LOCK_ERROR);
            }
            try {
        
    			// 业务代码
    		} finally {
        
                //锁释放
                redisTemplateService.unlock(key);
            }

**4、涉及的常量：**

// 锁的key，根据自身业务自定义
        public static final String REDIS_KEY = "MT:RESERVE:";
    
        // 锁过期时间，根据方法逻辑处理复杂度自定义
        public static final Integer EXPIRETIME_10S = 10;