Spring AOP<一>简介与基础使用

spring AOP

Spring AOP<一>简介与基础使用_第1张图片

基础定义

含义 使用
切面 组织多个Advice,Advice放在切面中定义。也就是说是定义通知的自定义类。 自定义的AOP类@Aspect
连接点 方法调用,异常抛出可以增强的点 JoinPoint :也就是**被增强的方法的总称,可以获取具体方法的信息,然后执行他。一般和环绕通知一起使用**
通知/增强处理(Advice) around, befor, afterafter returing ,after throwing对其进行增强 @Around(),获取连接点,然后前后执行增强代码
切入点 被增强的方法,规定什么条件下可以增强 @anotation():在有这个注解条件下增强execution():执行哪个接口方法,哪个包下方法的时候进行切入
目标
代理
织入 增强代码和目标代码通过代理的方式加入到代理类中

举例-Redis分布式锁

这里实现一个基于注解的AOP实现

  • 首先定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface RedisLock {
    /**
     * 业务键
     *
     * @return
     */
    String key();
    /**
     * 锁的过期秒数,默认是5秒
     *
     * @return
     */
    int expire() default 5;

    /**
     * 尝试加锁,最多等待时间
     *
     * @return
     */
    long waitTime() default Long.MIN_VALUE;
    /**
     * 锁的超时时间单位
     *
     * @return
     */
    TimeUnit timeUnit() default TimeUnit.SECONDS;
}

作者:pjmike_pj
链接:https://juejin.cn/post/6844903830442737671
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
  • 其次定义AOP
// 1. 定义切面
@Aspect
@Component
public class LockMethodAspect {
    @Autowired
    private RedisLockHelper redisLockHelper;
    @Autowired
    private JedisUtil jedisUtil;
    private Logger logger = LoggerFactory.getLogger(LockMethodAspect.class);

    // 2. 定义通知为Aroud类型
    // 3. 定义使用@RedisLock来定义切入点
    @Around("@annotation(com.redis.lock.annotation.RedisLock)")
    public Object around(ProceedingJoinPoint joinPoint) {
        Jedis jedis = jedisUtil.getJedis();
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        RedisLock redisLock = method.getAnnotation(RedisLock.class);
        String value = UUID.randomUUID().toString();
        String key = redisLock.key();
        // 4. 实现增强代码
        try {
            final boolean islock = redisLockHelper.lock(jedis,key, value, redisLock.expire(), redisLock.timeUnit());
            logger.info("isLock : {}",islock);
            if (!islock) {
                logger.error("获取锁失败");
                throw new RuntimeException("获取锁失败");
            }
            try {
                // 5. 执行目标代码
                return joinPoint.proceed();
            } catch (Throwable throwable) {
                throw new RuntimeException("系统异常");
            }
        }  finally {
            logger.info("释放锁");
            redisLockHelper.unlock(jedis,key, value);
            jedis.close();
        }
    }
}
  • 最后就可以使用了
@RestController
public class TestController {
    // 定义切入点
    @RedisLock(key = "redis_lock")
    @GetMapping("/index")
    public String index() {
        return "index";
    }
}
  • 辅助类
@Component
public class RedisLockHelper {
    private long sleepTime = 100;
    /**
     * 直接使用setnx + expire方式获取分布式锁
     * 非原子性
     *
     * @param key
     * @param value
     * @param timeout
     * @return
     */
    public boolean lock_setnx(Jedis jedis,String key, String value, int timeout) {
        Long result = jedis.setnx(key, value);
        // result = 1时,设置成功,否则设置失败
        if (result == 1L) {
            return jedis.expire(key, timeout) == 1L;
        } else {
            return false;
        }
    }

    /**
     * 使用Lua脚本,脚本中使用setnex+expire命令进行加锁操作
     *
     * @param jedis
     * @param key
     * @param UniqueId
     * @param seconds
     * @return
     */
    public boolean Lock_with_lua(Jedis jedis,String key, String UniqueId, int seconds) {
        String lua_scripts = "if redis.call('setnx',KEYS[1],ARGV[1]) == 1 then" +
                "redis.call('expire',KEYS[1],ARGV[2]) return 1 else return 0 end";
        List<String> keys = new ArrayList<>();
        List<String> values = new ArrayList<>();
        keys.add(key);
        values.add(UniqueId);
        values.add(String.valueOf(seconds));
        Object result = jedis.eval(lua_scripts, keys, values);
        //判断是否成功
        return result.equals(1L);
    }

    /**
     * 在Redis的2.6.12及以后中,使用 set key value [NX] [EX] 命令
     *
     * @param key
     * @param value
     * @param timeout
     * @return
     */
    public boolean lock(Jedis jedis,String key, String value, int timeout, TimeUnit timeUnit) {
        long seconds = timeUnit.toSeconds(timeout);
        return "OK".equals(jedis.set(key, value, "NX", "EX", seconds));
    }

    /**
     * 自定义获取锁的超时时间
     *
     * @param jedis
     * @param key
     * @param value
     * @param timeout
     * @param waitTime
     * @param timeUnit
     * @return
     * @throws InterruptedException
     */
    public boolean lock_with_waitTime(Jedis jedis,String key, String value, int timeout, long waitTime,TimeUnit timeUnit) throws InterruptedException {
        long seconds = timeUnit.toSeconds(timeout);
        while (waitTime >= 0) {
            String result = jedis.set(key, value, "nx", "ex", seconds);
            if ("OK".equals(result)) {
                return true;
            }
            waitTime -= sleepTime;
            Thread.sleep(sleepTime);
        }
        return false;
    }
    /**
     * 错误的解锁方法—直接删除key
     *
     * @param key
     */
    public void unlock_with_del(Jedis jedis,String key) {
        jedis.del(key);
    }

    /**
     * 使用Lua脚本进行解锁操纵,解锁的时候验证value值
     *
     * @param jedis
     * @param key
     * @param value
     * @return
     */
    public boolean unlock(Jedis jedis,String key,String value) {
        String luaScript = "if redis.call('get',KEYS[1]) == ARGV[1] then " +
                "return redis.call('del',KEYS[1]) else return 0 end";
        return jedis.eval(luaScript, Collections.singletonList(key), Collections.singletonList(value)).equals(1L);
    }
}

小结

  1. 定义切面,来承载通知和切点。
  2. 定义切点,什么情况下织入增强的代码。
  3. 定义通知/增强代码。
  4. 如果使用注解定义的切点,就给需要增强的连接点加上注解。如果需要增强某一个类的连接点,直接在切点中配置就行了。

代理模式

说到这里就需要说下代理模式以及spring使用的代理模式。

先说结论:

Java中有两种代理,一种是Proxy,另一种是cglib代理。proxy需要接口,cglib代理不需要。因为proxy使用了反射机制,而cglib直接通过ASM操作字节码文件。

JVM层面看代理模式

  • cglib代理

cglib代理通过操作字节码文件把增强代码加入到原来目标类中,从而生成一个新的类,然后载入到内存中,这就是代理类

  • 通过反射的代理:
  1. 定义接口
  2. 实现接口方法
  3. 使用proxy包裹接口,定义钩子函数handler实现增强代码,返回被代理类。
  4. 其中的handler一般会调用被代理类的方法。

而这个调用方法,是使用反射生成的一个被代理对象。

  • 反射的原理:

类加载之后,会在内存中存入Class列表,也就是类定义列表在内存是一种hash结构,全类名到类定义方法区的映射。所以通过全类名可以得到对应的类定义,然后生成对象。

你可能感兴趣的:(后台,spring,java,后端)