redis锁aop实现

最新推荐文章于 2024-07-25 12:03:58 发布
最新推荐文章于 2024-07-25 12:03:58 发布
阅读量623 收藏 1
点赞数
分类专栏： Redis 文章标签： redis java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Smy_0114/article/details/122165230
版权

理解：基于aop编程离不开注解的加持

步骤：

  1. 编写注解，运行时可见
  2. aop织入想要被加锁的方法

实现：

  • 注解
package com.example.annotation;
import java.lang.annotation.*;
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface RedisLockTarget {
    /**请求唯一标识*/
    String key() default "";
}
  • aop织入
package com.example.annotation;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;

@Aspect
@Component
@Slf4j
public class RedisLockAop {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    @Autowired
    private RedisLock redisLock;

    @Around("@annotation(RedisLockTarget)")
    public void doAround(ProceedingJoinPoint joinPoint){
        Boolean redisLockFlag = false;
        String redisKey = null;
        // 获得当前访问的class
        Class<?> clazz = joinPoint.getTarget().getClass();
        // 获得访问的方法名
        String methodName = joinPoint.getSignature().getName();
        // 得到方法的参数的类型
        Class<?>[] argClass = ((MethodSignature) joinPoint.getSignature()).getParameterTypes();
        try {
            // 得到访问的方法对象
            Method method = clazz.getMethod(methodName, argClass);
            method.setAccessible(true);
            if (method.isAnnotationPresent(RedisLockTarget.class)) {
                RedisLockTarget annotation = method.getAnnotation(RedisLockTarget.class);
                redisKey = getRedisKey(annotation);
                //加锁
                redisLockFlag = RedisLock.initRedisLock(redisTemplate,redisKey);
            }
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            log.error(throwable.getMessage());
        }finally {
            //释放锁
            if (redisLockFlag) {
                if (log.isDebugEnabled()) {
                    log.debug(redisKey, "释放时间:", System.currentTimeMillis());
                }
                redisLock.unLock(redisKey);
            }
        }
    }
    /**
     * 解析key对应的参数
     *
     *
     * @param annotation
     * @return
     * @throws Exception
     */
    private String getRedisKey(RedisLockTarget annotation) throws Exception {
        String redisKey = annotation.key();
        //String format = DateFormatUtils.format(new Date(), "yyyyMMddHHmmss");
        //log.info("分布式锁注解获取到的key值：{}",redisKey+":"+format);
        return redisKey;
    }
}

package com.example.annotation;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.function.Function;

/**
 * redis分布式锁
 */
@Slf4j
@Component
public class RedisLock {


    public RedisLock() {
    }

    /**
     * 日志打印对象
     */
    private static Logger logger = LoggerFactory.getLogger(RedisLock.class);

    /**
     * 默认超时时间：2小时
     * 单位：秒
     */
    private static final int DEFAULT_LOCK_TIMEOUT =  60 * 60;

    /**
     * redis连接对象
     */
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * redis锁的list
     */
    private List<String> lockKeyList;

    /**
     * Lock key path.
     */
    private String lockKey;

    /**
     * redis的超时时间
     * 单位：秒
     */
    private int lockTimeout = DEFAULT_LOCK_TIMEOUT;


    /**
     * 单个key值的锁，默认超时时间(2小时)
     *
     * @param redisTemplate redis连接对象
     * @param lockKey       redis锁得key
     */
    public RedisLock(RedisTemplate<String, String> redisTemplate, String lockKey) {
        this.redisTemplate = redisTemplate;
        this.lockKey = lockKey;
    }

    /**
     * 单个key值的锁，自定义超时时间
     *
     * @param redisTemplate redis连接对象
     * @param lockKey       锁的key值
     * @param lockTimeout   超时时间：单位秒
     */
    public RedisLock(RedisTemplate<String, String> redisTemplate, String lockKey, int lockTimeout) {
        this(redisTemplate, lockKey);
        this.lockTimeout = lockTimeout;
    }

    /**
     * 锁一批数据,多个key，默认超时时间(2小时)
     *
     * @param redisTemplate redis连接对象
     * @param lockKeyList   key的集合
     */
    public RedisLock(RedisTemplate<String, String> redisTemplate, List<String> lockKeyList) {
        //已经加了锁的RedisLock,防止其中某笔数据已经锁住,后面需要释放
        if (CollectionUtils.isNotEmpty(lockKeyList)) {
            this.redisTemplate = redisTemplate;
            this.lockKeyList = lockKeyList;
        }
    }


    /**
     * 锁一批数据,多个key，自定义超时时间
     *
     * @param redisTemplate redis连接对象
     * @param lockKeyList   key的集合
     * @param lockTimeout   超时时间：单位秒
     */
    public RedisLock(RedisTemplate<String, String> redisTemplate, List<String> lockKeyList, int lockTimeout) {
        this(redisTemplate, lockKeyList);
        this.lockTimeout = lockTimeout;
    }

    /**
     * 获取对应key的值
     *
     * @param key key
     * @return value
     */
    private String get(final String key) {
        String result = null;
        try {
            result = this.redisTemplate.execute((RedisCallback<String>) connection -> {
                StringRedisSerializer serializer = new StringRedisSerializer();
                byte[] data = connection.get(Objects.requireNonNull(serializer.serialize(key)));
                if (data == null) {
                    return null;
                }
                return serializer.deserialize(data);
            });
        } catch (Exception e) {
            logger.error("get redis error, key : {}", key);
        }
        return result;
    }

    /**
     * 获取旧值，并设置新值
     *
     * @param key   redis的key
     * @param value redis的新值
     * @return redis的旧值
     */
    private String getSet(final String key, final String value) {
        String result = null;
        try {
            result = this.redisTemplate.execute((RedisCallback<String>) connection -> {
                StringRedisSerializer serializer = new StringRedisSerializer();
                byte[] data = connection.getSet(Objects.requireNonNull(serializer.serialize(key)), Objects.requireNonNull(serializer.serialize(value)));
                return serializer.deserialize(data);
            });
        } catch (Exception e) {
            logger.error("getSet redis error, key : {}", key);
        }
        return result;
    }

    /**
     * 移除key
     *
     * @param lockKey redis的key
     */
    private void del(final String lockKey) {
        try {
            this.redisTemplate.execute((RedisCallback<Object>) connection -> {
                StringRedisSerializer serializer = new StringRedisSerializer();
                return connection.del(serializer.serialize(lockKey));
            });
        } catch (Exception e) {
            logger.error("del redis error, key : {}", lockKey);
        }
    }

    /**
     * 设置key的超时时间
     *
     * @param lockKey    redis的key
     * @param expireTime 超时时间，单位秒
     */
    private void expire(final String lockKey, final long expireTime) {
        try {
            this.redisTemplate.execute((RedisCallback<Boolean>) connection ->
                    connection.expire(Objects.requireNonNull(new StringRedisSerializer().serialize(lockKey)), expireTime));
        } catch (Exception e) {
            logger.error("expire redis error, key : {}", lockKey);
        }
    }

    /**
     * 批量设置key的超时时间
     *
     * @param lockkeyList 被锁的keys
     * @param expireTime  失效时间
     */
    private void batchExpire(final List<String> lockkeyList, final long expireTime) {
        StringRedisSerializer serializer = new StringRedisSerializer();
        try {
            this.redisTemplate.executePipelined(new RedisCallback<Object>() {
                @Override
                public Object doInRedis(RedisConnection connection) throws DataAccessException {
                    for (String key : lockkeyList) {
                        connection.expire(Objects.requireNonNull(serializer.serialize(key)), expireTime);
                    }
                    return null;
                }
            });
        } catch (Exception e) {
            logger.error("expire redis error, key : {}", lockKey);
        }

    }

    /**
     * 设置键值对，并返回是否设置成功
     *
     * @param key   键
     * @param value 值
     * @return 处理结果
     */
    private Boolean setNX(final String key, final String value) {
        Boolean result = Boolean.FALSE;
        try {
            //执行
            result = this.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
                StringRedisSerializer serializer = new StringRedisSerializer();
                return connection.setNX(serializer.serialize(key), serializer.serialize(value));
            });
        } catch (Exception e) {
            logger.error("setNX redis error, key : {}", key);
        }

        //返回结果
        return result;
    }

    /**
     * 批量设置键值对，并返回是否设置成功
     *
     * @param keysMap
     * @return
     */
    private Boolean mSetNx(final Map<byte[], byte[]> keysMap) {
        Boolean result = false;
        try {
            //执行
            result = this.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
                return connection.mSetNX(keysMap);
            });
        } catch (Exception e) {
            logger.error("setNX redis error, key : {}", keysMap);
        }
        return result;
    }

    /**
     * 加锁
     * 取到锁加锁，取不到锁就返回
     *
     * @return 是否加锁成功
     */
    public synchronized boolean lock() {
        //锁释放时间
        long lockTime = currtTimeForRedis() + this.lockTimeout;

        //设置值，并判断设置结果
        if (setNX(this.lockKey, String.valueOf(lockTime))) {
            //设置超时时间，释放内存
            expire(this.lockKey, this.lockTimeout);
            return true;
        } else {
            //获取redis里面的时间
            Object result = get(this.lockKey);
            Long currtLockTimeoutStr = result == null ? null : Long.parseLong(result.toString());
            //锁已经失效
            if (currtLockTimeoutStr != null && currtLockTimeoutStr < currtTimeForRedis()) {
                //判断是否为空，不为空时，说明已经失效，如果被其他线程设置了值，则第二个条件判断无法执行
                //获取上一个锁到期时间，并设置现在的锁到期时间
                Long oldLockTimeoutStr = Long.valueOf(getSet(this.lockKey, String.valueOf(lockTime)));
                if (oldLockTimeoutStr.equals(currtLockTimeoutStr)) {
                    //多线程运行时，多个线程签好都到了这里，但只有一个线程的设置值和当前值相同，它才有权利获取锁
                    //设置超时间，释放内存
                    expire(this.lockKey, this.lockTimeout);
                    //返回加锁时间
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 解锁
     */
    public synchronized void unLock() {
        //获取redis中设置的时间
        String result = get(this.lockKey);
        Long currtLockTimeoutStr = result == null ? null : Long.valueOf(result);
        if (currtLockTimeoutStr != null) {
            this.del(this.lockKey);
        }
    }
    /**
     * 解锁
     */
    public synchronized void unLock(String lockKey) {
        //获取redis中设置的时间
        String result = get(lockKey);
        Long currtLockTimeoutStr = result == null ? null : Long.valueOf(result);
        if (currtLockTimeoutStr != null) {
            this.del(lockKey);
        }
    }


    /**
     * 多服务器集群，使用下面的方法，代替System.currentTimeMillis()，获取redis时间，避免多服务的时间不一致问题！！！
     *
     * @return 当前redis服务的时间秒
     */
    private long currtTimeForRedis() {
        return this.redisTemplate.execute((RedisCallback<Long>) redisConnection -> redisConnection.time() / 1000);
    }

    /**
     * 锁List
     *
     * @return 锁的结果
     */
    public boolean lockList() {
        Boolean result = false;
        if (CollectionUtils.isEmpty(this.lockKeyList)) {
            //change by shencai.li@hand-china.com
            //当列表为空时应返回true
            return true;
        }
        //临时存放lock,方便后面锁有冲突的释放
        if (!CollectionUtils.isEmpty(this.lockKeyList)) {
            //锁释放时间
            long lockTime = currtTimeForRedis() + this.lockTimeout;

            Map<byte[], byte[]> keysMap = new HashMap<>();
            for (String key : this.lockKeyList) {
                StringRedisSerializer serializer = new StringRedisSerializer();
                lockTime = lockTime + 1;
                keysMap.put(serializer.serialize(key), serializer.serialize(String.valueOf(lockTime)));
            }
            //加锁
            if (mSetNx(keysMap)) {
                //设置失效时间
                batchExpire(this.lockKeyList, this.lockTimeout);
                result=true;
            }
        }
        return result;
    }


    /**
     * 批量解锁
     */
    public void unLockList() {
        if (CollectionUtils.isNotEmpty(this.lockKeyList)) {
            this.redisTemplate.delete(this.lockKeyList);
        }
    }

    /**
     * 单个分布式锁方法
     *
     * @param redisTemplate 缓存对象
     * @param lockKey       锁Key值
     * @throws InterruptedException 抛出异常处理
     */
    public static Boolean initRedisLock(RedisTemplate<String, String> redisTemplate, String lockKey) throws InterruptedException {
        //redis锁对象
        RedisLock redisLock = null;
        Boolean redisLockFlag = false;
        try {
            redisLock = new RedisLock(redisTemplate, lockKey);
            redisLockFlag = redisLock.lock();
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug(lockKey, "Lock Time:", System.currentTimeMillis());
                }
            } else {
                throw new RuntimeException("数据正在处理中,redis锁:["+lockKey+"]");
            }
        }catch (Exception e){
            throw new RuntimeException("加锁异常:"+e.getMessage());
        }
        return redisLockFlag;

    }

    /**
     * 单个分布式锁方法
     *
     * @param redisTemplate 缓存对象
     * @param lockKey       锁Key值
     * @param voidFunction  执行方法 (不返回值)
     * @throws InterruptedException 抛出异常处理
     */
    public static void initRedisLock(RedisTemplate<String, String> redisTemplate, String lockKey, VoidFunction
            voidFunction) throws InterruptedException {
        log.info("=========redis锁===>>>>>>>>>>>>>>"+lockKey);

        //redis锁对象
        RedisLock redisLock = null;
        Boolean redisLockFlag = false;
        try {
            redisLock = new RedisLock(redisTemplate, lockKey);
            redisLockFlag = redisLock.lock();
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug(lockKey, "Lock Time:", System.currentTimeMillis());
                }
                voidFunction.apply();
            } else {
                throw new RuntimeException("数据正在处理中,redis锁:["+lockKey+"]");
            }
        } finally {
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug(lockKey, "释放时间:", System.currentTimeMillis());
                }
                redisLock.unLock();
            }
        }

    }

    /**
     * 多个分布式锁方法
     *
     * @param redisTemplate 缓存对象
     * @param redisKeyList  锁Key值集合
     * @param voidFunction  执行方法 (不返回值)
     * @throws InterruptedException 抛出异常处理(redis连接异常不做处理)
     */
    public static void initRedisLock(RedisTemplate<String, String> redisTemplate, List<String> redisKeyList, VoidFunction voidFunction) throws
            InterruptedException {
        log.info("=========redis锁===>>>>>>>>>>>>>>"+redisKeyList);

        //redis锁对象
        RedisLock redisLock = null;
        Boolean redisLockFlag = false;
        try {
            redisLock = new RedisLock(redisTemplate, redisKeyList);
            redisLockFlag = redisLock.lockList();
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug(redisKeyList.toString(), "Lock Time:", System.currentTimeMillis());
                }
                voidFunction.apply();
            } else {
                throw new RuntimeException("数据正在处理中,redis锁:"+redisKeyList);
            }
        } finally {
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug(redisKeyList.toString(), "unLock Time:", System.currentTimeMillis());
                }
                redisLock.unLockList();
            }
        }
    }


    /**
     * 单个分布式锁方法
     *
     * @param redisTemplate 缓存对象
     * @param redisKey      锁Key值
     * @param resultObject  返回结果
     * @param voidFunction  执行方法 (返回结果对象)
     * @return
     * @throws InterruptedException 抛出异常处理(redis连接异常不做处理)
     */
    public static <T, R> R initRedisLock(RedisTemplate<String, String> redisTemplate, String redisKey, Object resultObject, Function<T, R> voidFunction) {
        log.info("=========redis锁===>>>>>>>>>>>>>>"+redisKey);
        //redis锁对象
        RedisLock redisLock = null;
        Boolean redisLockFlag = false;
        try {
            redisLock = new RedisLock(redisTemplate, redisKey);
            redisLockFlag = redisLock.lockList();
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug( redisKey, "Lock Time:", System.currentTimeMillis());
                }
                return voidFunction.apply((T) resultObject);
            } else {
                throw new RuntimeException("数据正在处理中,redis锁:"+redisKey);
            }
        } finally {
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug( redisKey, "unLock Time:", System.currentTimeMillis());
                }
                redisLock.unLockList();
            }
        }
    }

    /**
     * 单个分布式锁方法（存在则过滤）
     *
     * @param redisTemplate 缓存对象
     * @param redisKey      锁Key值
     * @param resultObject  返回结果
     * @param voidFunction  执行方法 (返回结果对象)
     * @return
     */
    public static <T, R> R initRedisLockFilter(RedisTemplate<String, String> redisTemplate, String redisKey, Object resultObject, Function<T, R> voidFunction) {
        log.info("=========redis锁===>>>>>>>>>>>>>>"+redisKey);
        //redis锁对象
        RedisLock redisLock = null;
        Boolean redisLockFlag = false;
        try {
            redisLock = new RedisLock(redisTemplate, redisKey);
            redisLockFlag = redisLock.lockList();
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug(redisKey, "Lock Time:", System.currentTimeMillis());
                }
                return voidFunction.apply((T) resultObject);
            }
        } finally {
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug( redisKey, "unLock Time::", System.currentTimeMillis());
                }
                redisLock.unLockList();
            }
        }
        return null;
    }

    /**
     * 多个分布式锁方法
     *
     * @param redisTemplate 缓存对象
     * @param redisKeyList  锁Key值集合
     * @param resultList    返回结果集合
     * @param voidFunction  执行方法 (返回结果对象)
     * @return
     */
    public static <T, R> List<R> initRedisLock(RedisTemplate<String, String> redisTemplate, List<String> redisKeyList, List<T> resultList, Function<List<T>, List<R>> voidFunction) {
        log.info("=========redis锁===>>>>>>>>>>>>>>"+redisKeyList);
        //redis锁对象
        RedisLock redisLock = null;
        Boolean redisLockFlag = false;
        try {
            redisLock = new RedisLock(redisTemplate, redisKeyList);
            redisLockFlag = redisLock.lockList();
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug(redisKeyList.toString(), "Lock time:", System.currentTimeMillis());
                }
                return voidFunction.apply(resultList);
            } else {
                throw new RuntimeException("数据正在处理中,redis锁:"+redisKeyList);
            }
        } finally {
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug( redisKeyList.toString(), "unLock Time:", System.currentTimeMillis());
                }
                redisLock.unLockList();
            }
        }
    }

    /**
     * 多个分布式锁方法（存在则过滤）
     *
     * @param redisTemplate 缓存对象
     * @param redisKeyList  锁Key值集合
     * @param resultList    返回结果集合
     * @param voidFunction  执行方法 (返回结果对象)
     * @return
     * @throws InterruptedException 抛出异常处理(redis连接异常不做处理)
     */
    public static <T, R> List<R> initRedisLockFilter(RedisTemplate<String, String> redisTemplate, List<String> redisKeyList, List<T> resultList, Function<List<T>, List<R>> voidFunction) {
        log.info("=========redis锁===>>>>>>>>>>>>>>"+redisKeyList);
        //redis锁对象
        RedisLock redisLock = null;
        Boolean redisLockFlag = false;
        try {
            redisLock = new RedisLock(redisTemplate, redisKeyList);
            redisLockFlag = redisLock.lockList();
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug(redisKeyList.toString(), "Lock Time:", System.currentTimeMillis());
                }
                return voidFunction.apply(resultList);
            }
        } finally {
            if (redisLockFlag) {
                if (logger.isDebugEnabled()) {
                    logger.debug( redisKeyList.toString(), "unLock Time:", System.currentTimeMillis());
                }
                redisLock.unLockList();
            }
        }

        return null;
    }

    /**
     * 多个分布式锁方法
     *
     * @param redisTemplate 缓存对象
     * @param redisKeyList  锁Key值集合
     * @param inParam       Function<T,R> 传入参数
     * @param voidFunction  执行方法 (返回结果对象)
     * @return
     * @throws InterruptedException 抛出异常处理(redis连接异常不做处理)
     */
    public static <T, R> R initRedisLock(RedisTemplate<String, String> redisTemplate, List<String> redisKeyList, T inParam, Function<T, R> voidFunction) {
        log.info("=========redis锁===>>>>>>>>>>>>>>"+redisKeyList);
        //redis锁对象
        RedisLock redisLock = null;
        Boolean redisLockFlag = false;
        try {
            redisLock = new RedisLock(redisTemplate, redisKeyList);
            redisLockFlag = redisLock.lockList();
            if (redisLockFlag) {
                return voidFunction.apply(inParam);
            } else {
                throw new RuntimeException("数据正在处理中,redis锁:"+redisKeyList);
            }
        } finally {
            if (redisLockFlag) {
                redisLock.unLockList();
            }
        }
    }


    /**
     * 多个分布式锁方法(存在则过滤)
     *
     * @param redisTemplate 缓存对象
     * @param redisKeyList  锁Key值集合
     * @param inParam       Function<T,R> 传入参数
     * @param voidFunction  执行方法 (返回结果对象)
     * @return
     * @throws InterruptedException 抛出异常处理(redis连接异常不做处理)
     */
    public static <T, R> R initRedisLockFilter(RedisTemplate<String, String> redisTemplate, List<String> redisKeyList, T inParam, Function<T, R> voidFunction) {
        //redis锁对象
        RedisLock redisLock = null;
        Boolean redisLockFlag = false;
        try {
            redisLock = new RedisLock(redisTemplate, redisKeyList);
            redisLockFlag = redisLock.lockList();
            if (redisLockFlag) {
                return voidFunction.apply(inParam);
            }
        } finally {
            if (redisLockFlag) {
                redisLock.unLockList();
            }
        }
        return null;
    }


}

  • 业务代码
@GetMapping("/queryForeach")
@RedisLockTarget(key="test-queryForeach")
public void queryForeach(User user,String str){

}

RT_0114
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AOP实现Redis缓存
weixin_49762948的博客
10-14 714
AOP AOP：面向切面编程 作用：降低系统中代码的耦合性，并且在不改变原有代码的条件下对原有的方法进行功能的扩展。 （公式：AOP=切入点表达式+通知方法） 通知类型 1.前置通知（before） 目标方法执行之前执行 2.后置通知（） 目标方法执行之后执行 3.异常通知（） 目标方法执行过程中抛出异常时执行 4.最终通知（after） 无论什么时候都要执行的通知 特点：上述的四大通知类型 不能干预目标方法是否执行，一般用来做程序运行状态的记录监控 5.环绕通知（around） 在目标方法执行
redis同步锁AOP实现
07-06
Redis同步锁AOP实现是一种在分布式系统中控制资源访问的有效机制。Redis，作为一个高性能的键值数据存储系统，常被用作分布式锁的底层支持。本文将深入探讨如何结合注解和面向切面编程（AOP）来实现Redis锁。 首先...
REDIS同步锁AOP实现-附代码
shengrim1993的博客
07-06 419
项目场景： 公司项目使用redis作为中间件，客户那边进行分布式部署，某些逻辑需要添加redis同步锁来保证数据唯一性，直接在逻辑层添加lock出现了一些问题。 问题描述： 加锁的代码大致如下： RLock lock = redisson.getLock(REDIS_KEY); try{ boolean tryLock = lock.tryLock(60, 600, TimeUnit.SECONDS); ... return ...; }catch(Exception e){ logger.er
实战 - 利用注解和Spring Aop实现Redis分布式锁
你今天真好看呀
05-01 1877
文章目录1. RedisLockDto2. RedisLockService3. RedisLockServiceImpl3.1 获取锁的key3.2 获取锁的值lockValue3.3 分布式锁异常RedisLockException3.4 获取锁3.5 锁续期3.6 释放锁4. 定义注解@RedisLock5. 定义注解@BusinessId6. 读取目标方法上加的注解并加锁7. Spring boot redis分布式锁自动化配置8. 测试9. 测试使用 1. RedisLockDto RedisLo
Redis+Aop 缓存
g3230863的博客
03-01 349
Redis+Aop 缓存
AOP+自定义注解+Redis实现分布式锁
小学生波波
10-29 2539
AOP+自定义注解+Redis实现分布式锁
分布式锁+AOP实现缓存
冲出仁川，走出马德里，故事还会再继续
04-19 1716
*** 元注解：简单理解就是修饰注解的注解* @Target:用于描述注解的使用范围，简单理解就是当前注解可以用在什么地方* @Retention:表示注解的生命周期* SOURCE:只存在类文件中，在class字节码不存在* CLASS：存在到字节码文件中* RUNTIME：运行时* @Inherited：表示被GmallCache修饰的类的子类会不会继承GmallCache* @Documented：表明这个注解应该被javadoc工具记录，因此可悲javadoc类的工具文档化。
【防止重复提交】Redis + AOP + 注解的方式实现分布式锁
weixin_44783506的博客
02-05 1886
Redis + AOP + 注解的方式实现分布式锁
Spring AOP +redisson的redis分布式锁实现
shadow_zed的博客
08-18 905
Spring AOP 结合redis分布式锁实现
redis锁基于注解实现
RT_0114的博客
09-05 341
Target({/**请求唯一标识*/ String key() default "";}// 获得当前访问的class Class
AOP方式实现的redis分布式锁
06-12
redis分布式锁的实现： ... 3、只需要在方法上声明@DistributedLock（可以是controller的方法也可以是service的公共方法）即可实现锁功能。 4、支持在@DistributedLock上动态传参，减少锁的颗粒度。
Spring AOP实现Redis缓存数据库查询
08-29
Spring AOP实现Redis缓存数据库查询 Spring AOP（Aspect-Oriented Programming，面向方面编程）是一种编程技术，可以将散落在各个对象之间的逻辑提取出来，封装成一个个独立的模块，并将这些模块组合起来，形成一...
记录redisson实现redis分布式事务锁
04-24
本篇文章将详细探讨如何使用Redisson实现Redis分布式事务锁，以及在Spring Boot环境中如何进行集成。 首先，Redis作为一个内存数据库，其高速读写性能使其成为实现分布式锁的理想选择。分布式锁的主要作用是在多...
spring-redis-aop:redis客户端集成spring实现aop方式
06-25
redis客户端集成spring实现aop方式,方便在程序中使用spring的时候更加方便的使用redis内存数据库， 采用aop的方式主要是为了不去污染业务代码，达到业务逻辑更加清晰易于阅读，在使用过程中可以设置 key的有效时间，...
Redis与MySQL数据一致性问题的策略模式及解决方案
qq_36451127的博客
07-24 2221
（1）实际开发中一般使用使用了缓存更新策略模式，此方案最大程度上保证了数据的一致性并且实现也最简单（2）无论是先操作数据库再删除缓存还是先删除缓存再操作数据库都有可能会出现删除缓存失败的情况，所以需要加入删除重试机制（3）如果想要Redis和Mysql的数据强一致性，可以考虑使用加锁的方式实现。
大数据-46 Redis 持久化 RDB AOF 配置参数 混合模式 具体原理 触发方式 优点与缺点
永远好奇，无限进步！
07-24 1207
上节Redis持久化概念介绍，RDB和AOF对比。本节配置RDB、AOF参数，运行原理，混合模式、两者的优点和缺点。Redis 加了一个 AOF 缓存，这个缓存在Fork出子进程之后，Redis主进程接收到新的写命令时，除了会将这个命令追加到现有的AOF文件，还会。RDB（Redis DataBase），是Redis的默认存储方式，RDB是通过快照的方式（snapshotting）完成的。如果在混合模式下，AOF rewrite时就直接把 RDB的内容写到 AOF 的开头。
外卖项目day08---店铺营业状态设置/用到redis
2301_79693537的博客
07-23 191
【代码】外卖项目day08---店铺营业状态设置/用到redis。
Redis使用场景---热点数据缓存
最新发布
2401_85014515的博客
07-25 550
redis应用场景,热点数据缓存 缓存（Cache）是计算机科学中的一种技术，旨在提高数据访问速度。它是一种临时存储机制，用于存储常用或近期访问的数据，以便快速访问，减少延迟。
springboot redis缓存查询 aop实现
08-27
通过使用AOP实现Redis缓存查询，可以有效地提高系统性能和响应速度。每次查询时，可以先从缓存中获取结果，避免重复查询数据库，从而减少对数据库的访问压力，提高系统的并发能力。 总而言之，使用Spring Boot和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值