Spring学习--切面优先级及重用切点表达式

指定切面的优先级：

在同一个链接点上应用不止一个切面时 , 除非明确指定 , 否则它们的优先级是不确定的。

切面的优先级可以通过实现 Ordered 接口或利用 @Order 注解指定。

实现 Ordered 接口 , getOrder() 方法的返回值越小 , 优先级越高 , 若使用 @Order 注解 , 序号出现在注解中 , 数字越小优先级越高。

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- IOC 扫描包 -->
    <context:component-scan base-package="com.itdoc.spring.aop.circular"></context:component-scan>
    <!-- 使 AspectJ 注解起作用, 自动为匹配的类生成代理对象 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

package com.itdoc.spring.aop.circular;

import org.springframework.stereotype.Component;

/**
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-03 19:34
 */
public interface Arithmetic {

    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);

}

package com.itdoc.spring.aop.circular;

import org.springframework.stereotype.Component;

/**
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-03 19:35
 */
@Component("arithmetic")
public class ArithmeticImpl implements Arithmetic {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        return result;
    }
}

package com.itdoc.spring.aop.circular;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 通知
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-04 9:50
 */
@Aspect
@Component
public class AsjectLogging {

    /**
     * 环绕通知需携带 ProceedingJoinPoint 类型的参数。
     * 环绕通知类似于动态代理的全过程: ProceedingJoinPoint 类型参数可以决定是否执行目标方法。
     * 环绕通知必须有返回值, 返回值即目标方法的返回值。
     *
     * @param point
     * @return
     */
    @Around("execution(* com.itdoc.spring.aop.circular.*.*(..))")
    public Object around(ProceedingJoinPoint point) {
        Object methodName = point.getSignature().getName();
        Object[] args = point.getArgs();
        Object result = null;
        try {
            //前置通知
            System.out.println("The method " + methodName + " begins with" + Arrays.asList(args));
            //执行方法
            result = point.proceed();
            //返回通知
            System.out.println("The method " + methodName + " ends with " + result);
        } catch (Throwable e) {
            e.printStackTrace();
            //异常通知
            System.out.println("The method " + methodName + " exception with " + e);
        } finally {
            //后置通知
            System.out.println("The method " + methodName + " ends");
        }
        return result;
    }
}

package com.itdoc.spring.aop.circular;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-04 12:20
 */
@Order(2147483647)
@Aspect
@Component
public class Validate {

    @Before("execution(* com.itdoc.spring.aop.circular.*.*(..))")
    public void beforeValidate() {
        System.out.println("I am Validate's beforeValidate method...");
    }
}

package com.itdoc.spring.aop.circular;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-04 9:54
 */
public class Main {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Arithmetic arithmetic = (Arithmetic) ctx.getBean("arithmetic");
        System.out.println("result = " + arithmetic.div(1, 1));
    }
}

控制台输出：

The method div begins with[1, 1]
I am Validate's beforeValidate method...
The method div ends with 1
The method div ends
result = 1

重用切入点表达式：

package com.itdoc.spring.aop.circular;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-04 12:20
 */
@Order(2147483647)
@Aspect
@Component
public class Validate {

    @Pointcut("execution(* com.itdoc.spring.aop.circular.*.*(..))")
    public void declareJointPointExpression() {}

    /**
     * 同包引入可以不写包名, 若是不同包引用需要引入包名。
     */
    @Before("com.itdoc.spring.aop.circular.Validate.declareJointPointExpression()")
    public void beforeValidate() {
        System.out.println("I am Validate's beforeValidate method...");
    }
}