springAop，注解annotation + redis 实现分布式锁

当前流行的系统，就是分布式系统。所谓分布式，我个人理解，是很多的服务分布在不同的机器上，都是相同功能模块。但是容易出现一个问题，就是并发时的问题。

我们传统的锁，只能锁住一个服务器上的方法，让其在一个服务上同步，然后，分布式。怎么办。经上网查询资料后，抄袭+整理，得到这个结果：redis + spring 实现注解式锁。

实现后，我们需要同步的方法，只需要加上标签@RedisLock()就可以了。

以下是实现步骤。在此，搭建spring + redis 的工程就不再详细说明。

首先是spring的配置加上

    <!-- 切面开关 -->
    <aop:aspectj-autoproxy />

然后是redis相应配置。

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">  
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxTotal" value="${redis.maxActive}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="poolConfig" ref="poolConfig" /> 
         <property name="port" value="${redis.port}" /> 
         <property name="hostName" value="${redis.host}" /> 
         <property name="password" value="${redis.pass}" /> 
        </bean>
    <bean id="stringSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"/>    
    <bean id="jdkSerializationRedisSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>    
    <bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory" />
        <property name="keySerializer" ref="stringSerializer" />
        <!-- <property name="valueSerializer" ref="jdkSerializationRedisSerializer"/> -->
    </bean>
</beans>

再试pom文件引入相应jar包。在此不说。

直接上代码。

1、是共享类文件，就是我们会有很多方法都去调用的。

package com.iafclub.demo.commonData;

import org.springframework.stereotype.Service;

import com.iafclub.demo.aop.RedisLock;

/**共享数据
 * 
 * @author chenweixian
 *
 */
@Service
public class Mydata {
    private static int i = 0;

    @RedisLock()
    public void add(String key1) {
        i++;
        System.out.println(key1+"=-===========" + i);
    }
}

2、是注解标签声明实现@RedisLock()，具体锁的释放时间什么的，根据自己项目需要更改。

package com.iafclub.demo.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * <b>同步锁：</b><br/>
 * 主要作用是在服务器集群环境下保证方法的synchronize；<br/>
 * 标记在方法上，使该方法的执行具有互斥性，并不保证并发执行方法的先后顺序；<br/>
 * 如果原有“A任务”获取锁后任务执行时间超过最大允许持锁时间，且锁被“B任务”获取到，在“B任务”成功货物锁会并不会终止“A任务”的执行；<br/>
 * <br/>
 * <b>注意：</b><br/>
 * 使用过程中需要注意keepMills、toWait、sleepMills、maxSleepMills等参数的场景使用；<br/>
 * 需要安装redis，并使用spring和spring-data-redis等，借助redis NX等方法实现。
 * 
 * @author partner4java
 *
 */
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface RedisLock {

    /**
     * 锁的key<br/>
     * 如果想增加坑的个数添加非固定锁，可以在参数上添加@RedisLock注解，但是本参数是必写选项<br/>
     * redis key的拼写规则为 当前注解类+所在的方法 + synKey + @RedisLock<br/>
     * 
     */
    String synKey() default "";

    /**
     * 持锁时间，超时时间，持锁超过此时间自动丢弃锁<br/>
     * 单位毫秒,默认20秒<br/>
     * 如果为0表示永远不释放锁，在设置为0的情况下toWait为true是没有意义的<br/>
     * 但是没有比较强的业务要求下，不建议设置为0
     */
    long keepMills() default 20 * 1000;

    /**
     * 当获取锁失败，是继续等待还是放弃<br/>
     * 默认为继续等待
     */
    boolean toWait() default true;

    /**
     * 没有获取到锁的情况下且toWait()为继续等待，睡眠指定毫秒数继续获取锁，也就是轮训获取锁的时间<br/>
     * 默认为10毫秒
     * 
     * @return
     */
    long sleepMills() default 10;

    /**
     * 锁获取超时时间：<br/>
     * 没有获取到锁的情况下且toWait()为true继续等待，最大等待时间，如果超时抛出
     * {@link java.util.concurrent.TimeoutException.TimeoutException}
     * ，可捕获此异常做相应业务处理；<br/>
     * 单位毫秒,默认一分钟，如果设置为0即为没有超时时间，一直获取下去；
     * 
     * @return
     */
    long maxSleepMills() default 60 * 1000;
}

3、切面实现，注意，需要加上切面的注解，与annotation的拦截service或Component

package com.iafclub.demo.aop;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import org.apache.log4j.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundValueOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import com.opensymphony.oscache.util.StringUtil;

/**
 * 锁的切面编程<br/>
 * 针对添加@RedisLock 注解的方法进行加锁
 * 
 * @author chenweixain
 *
 */
@Aspect
@Component
public class RedisLockAspect {
    private Logger logger = Logger.getLogger(getClass());
    
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    @Pointcut("@annotation(com.iafclub.demo.aop.RedisLock)")  // 用于拦截标签
    private void anyMethod(){}

    @Around("anyMethod() && @annotation(lockInfo)")  
    public Object lock(ProceedingJoinPoint pjp, RedisLock lockInfo) throws Throwable {
        String synKey = getSynKey(pjp, lockInfo.synKey());
        boolean lock = false;
        Object obj = null;
        try {
            // 超时时间
            long maxSleepMills = System.currentTimeMillis() + lockInfo.maxSleepMills();

            while (!lock) {
                long keepMills = System.currentTimeMillis() + lockInfo.keepMills();
                lock = setIfAbsent(synKey, keepMills);

                // 得到锁，没有人加过相同的锁
                if (lock) {
                    obj = pjp.proceed();
                }
                // 锁设置了没有超时时间
                else if (lockInfo.keepMills() <= 0) {
                    // 继续等待获取锁
                    if (lockInfo.toWait()) {
                        // 如果超过最大等待时间抛出异常
                        if (lockInfo.maxSleepMills() > 0 && System.currentTimeMillis() > maxSleepMills) {
                            throw new TimeoutException("获取锁资源等待超时");
                        }
                        TimeUnit.MILLISECONDS.sleep(lockInfo.sleepMills());
                    } else {
                        break;
                    }
                }
                // 已过期，并且getAndSet后旧的时间戳依然是过期的，可以认为获取到了锁
                else if (System.currentTimeMillis() > getLock(synKey) && (System.currentTimeMillis() > getSet(synKey, keepMills))) {
                    lock = true;
                    obj = pjp.proceed();
                }
                // 没有得到任何锁
                else {
                    // 继续等待获取锁
                    if (lockInfo.toWait()) {
                        // 如果超过最大等待时间抛出异常
                        if (lockInfo.maxSleepMills() > 0 && System.currentTimeMillis() > maxSleepMills) {
                            throw new TimeoutException("获取锁资源等待超时");
                        }
                        TimeUnit.MILLISECONDS.sleep(lockInfo.sleepMills());
                    }
                    // 放弃等待
                    else {
                        break;
                    }
                }
            }

        } catch (Exception e) {
            logger.error("锁异常", e);
            throw e;
        } finally {
            // 如果获取到了锁，释放锁
            if (lock) {
                releaseLock(synKey);
            }
        }
        return obj;
    }

    /**获取包括方法参数上的key
     * 
     * @param pjp
     * @param synKey
     * @return
     */
    private String getSynKey(ProceedingJoinPoint pjp, String synKey) {
        StringBuffer synKeyBuffer = new StringBuffer(pjp.getSignature().getDeclaringTypeName()); 
        synKeyBuffer.append(".").append(pjp.getSignature().getName());
        if (!StringUtil.isEmpty(synKey)){
            synKeyBuffer.append(".").append(synKey);
        }
        return synKeyBuffer.toString();
    }
    
    public BoundValueOperations<String, String> getOperations(String key) {
        return stringRedisTemplate.boundValueOps(key);
    }

    /**
     * Set {@code value} for {@code key}, only if {@code key} does not exist.
     * <p>
     * See http://redis.io/commands/setnx
     * 
     * @param key
     *            must not be {@literal null}.
     * @param value
     *            must not be {@literal null}.
     * @return
     */
    public boolean setIfAbsent(String key, Long value) {
        return getOperations(key).setIfAbsent(value.toString());
    }

    public long getLock(String key) {
        String time = getOperations(key).get();
        if (time == null) {
            return 0;
        }
        return Long.valueOf(time);
    }

    public long getSet(String key, Long value) {
        String time = getOperations(key).getAndSet(value.toString());
        if (time == null) {
            return 0;
        }
        return Long.valueOf(time);
    }

    public void releaseLock(String key) {
        stringRedisTemplate.delete(key);
    }
}

4、测试类：

package test.iafclub.redis;

import java.util.concurrent.TimeUnit;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import test.iafclub.BaseTest;

import com.iafclub.demo.commonData.Mydata;

public class RedisTest2 extends BaseTest{
    
    @Autowired
    private Mydata sysTest;

    @Test
    public void testHello() throws InterruptedException {
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    sysTest.add("CHEN");
                }
            }).start();
        }

        TimeUnit.SECONDS.sleep(20);
    }
    
    @Test
    public void testHello2() throws InterruptedException{
        sysTest.add("xxxxx");
        TimeUnit.SECONDS.sleep(10);
    }
}

加上切面与不加切面控制测试结果：

springAop，注解annotation + redis 实现分布式锁

猜你喜欢