Springboot分布式锁实践（redis）

    springboot2本地锁实践一文中提到用Guava Cache实现锁机制，但在集群中就行不通了，所以我们还一般要借助类似Redis、ZooKeeper 之类的中间件实现分布式锁，下面我们将利用自定义注解、Spring Aop、Redis Cache 实现分布式锁。

项目代码结构整体图

一、导入依赖

在 pom.xml 中添加上 starter-web、starter-aop、starter-data-redis 的依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
</dependencies>

二、属性配置

在 application.properites 资源文件中添加 redis 相关的配置项

spring.redis.host=192.168.68.110
spring.redis.port=6379
spring.redis.password=123456

三、注解

1、创建一个 CacheLock 注解，属性配置如下

• prefix： 缓存中 key 的前缀
• expire： 过期时间，此处默认为 5 秒
• timeUnit： 超时单位，此处默认为秒
• delimiter： key 的分隔符，将不同参数值分割开来

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

/**
 * 锁的注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface CacheLock {

    /**
     * redis 锁key的前缀
     *
     * @return redis 锁key的前缀
     */
    String prefix() default "";

    /**
     * 过期秒数,默认为5秒
     *
     * @return 轮询锁的时间
     */
    int expire() default 5;

    /**
     * 超时时间单位
     *
     * @return 秒
     */
    TimeUnit timeUnit() default TimeUnit.SECONDS;

    /**
     * <p>Key的分隔符（默认 :）</p>
     * <p>生成的Key：N:SO1008:500</p>
     *
     * @return String
     */
    String delimiter() default ":";
}

2、 key 的生成规则是自己定义的，如果通过表达式语法自己得去写解析规则还是比较麻烦的，所以依旧是用注解的方式

import java.lang.annotation.*;

/**
 * 锁的参数
 *
 */
@Target({ElementType.PARAMETER, ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface CacheParam {

    /**
     * 字段名称
     *
     * @return String
     */
    String name() default "";
}

四、Key生成策略

1、接口

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * key生成器
 */
public interface CacheKeyGenerator {

    /**
     * 获取AOP参数,生成指定缓存Key
     *
     * @param pjp PJP
     * @return 缓存KEY
     */
    String getLockKey(ProceedingJoinPoint pjp);
}

2、接口实现

import com.carry.annotation.CacheLock;
import com.carry.annotation.CacheParam;
import com.carry.common.CacheKeyGenerator;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;
import java.lang.annotation.Annotation;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Parameter;
/**


通过接口注入的方式去写不同的生成规则;

*/

public class LockKeyGenerator implements CacheKeyGenerator {
@Override

public String getLockKey(ProceedingJoinPoint pjp) {

MethodSignature signature = (MethodSignature) pjp.getSignature();

Method method = signature.getMethod();

CacheLock lockAnnotation = method.getAnnotation(CacheLock.class);

final Object[] args = pjp.getArgs();

final Parameter[] parameters = method.getParameters();

StringBuilder builder = new StringBuilder();

//默认解析方法里面带 CacheParam 注解的属性,如果没有尝试着解析实体对象中的

for (int i = 0; i < parameters.length; i++) {

final CacheParam annotation = parameters[i].getAnnotation(CacheParam.class);

if (annotation == null) {

continue;

}

builder.append(lockAnnotation.delimiter()).append(args[i]);

}

if (StringUtils.isEmpty(builder.toString())) {

final Annotation[][] parameterAnnotations = method.getParameterAnnotations();

for (int i = 0; i < parameterAnnotations.length; i++) {

final Object object = args[i];

final Field[] fields = object.getClass().getDeclaredFields();

for (Field field : fields) {

final CacheParam annotation = field.getAnnotation(CacheParam.class);

if (annotation == null) {

continue;

}

field.setAccessible(true);

builder.append(lockAnnotation.delimiter()).append(ReflectionUtils.getField(field, object));

}

}

}

return lockAnnotation.prefix() + builder.toString();

}

}