Spring -- AOP入门基础&基于Aspect的AOP通知用法

最新推荐文章于 2024-01-26 18:00:53 发布

GP0071

最新推荐文章于 2024-01-26 18:00:53 发布

阅读量7.3k

点赞数

分类专栏：框架技术框架技术文章标签： Aspectj

本文为博主原创文章，未经博主允许不得转载。个人博客：http://www.gaopeng0071.cn/

本文链接：https://blog.csdn.net/gaopeng0071/article/details/47106039

版权

框架技术同时被 2 个专栏收录

59 篇文章 1 订阅

订阅专栏

框架技术

55 篇文章 1 订阅

订阅专栏

动态代理

我们在日常开发过程中是否会遇到下图中的这种状况
这里写图片描述
红框中的是我们要输出的日志，你是否发现，日志中大部分信息都是相同的，并且如果我们要修改一个地方，所有的地方都需要改，而且代码看起来还比较冗余

下面我们就可以通过动态代理的方式解决这个问题
看下代码

public interface Calculation {

    public int add(int x, int y);

    public int sub(int x, int y);

    public int mul(int x, int y);

    public int dev(int x, int y);
}

定义接口，加减乘除方法。

public class CalculationImpl implements Calculation {

    @Override
    public int add(int x, int y) {
        int result = x + y;
        return result;
    }

    @Override
    public int sub(int x, int y) {
        int result = x - y;
        return result;
    }

    @Override
    public int mul(int x, int y) {
        int result = x * y;
        return result;
    }

    @Override
    public int dev(int x, int y) {
        int result = x / y;
        return result;
    }

}

具体实现类，这里我们看到，没有植入日志。

public class CalculationProxy {

    private Calculation calculation = null;

    CalculationProxy(Calculation calculation) {
        this.calculation = calculation;
    }

    public Calculation getCalculationLog() {
        Calculation proxy = null;

        ClassLoader loader = calculation.getClass().getClassLoader();
        Class[] interfaces = new Class[] { Calculation.class };

        InvocationHandler h = new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                System.out
                        .println("GP-->invoke begin , execute method is "
                                + method.getName() + ", args is "
                                + Arrays.asList(args));
                Object obj = method.invoke(calculation, args);

                return obj;
            }
        };

        proxy = (Calculation) Proxy.newProxyInstance(loader, interfaces, h);

        return proxy;

    }
}

动态代理类的实现，在实现invoke方法的时候，我们输出日志在调用目标方法之前。

测试

public class Main {
    public static void main(String[] args) {
        Calculation calculation = new CalculationImpl();
        CalculationProxy calculationProxy = new CalculationProxy(calculation);
        Calculation cal = calculationProxy.getCalculationLog();

        System.out.println(cal.add(1, 3));
        System.out.println(cal.mul(1, 5));
    }
}

输出结果

GP–>invoke begin , execute method is add, args is [1, 3]
4
GP–>invoke begin , execute method is mul, args is [1, 5]
5

看起来是不是要清晰多了，我们将日志单独提取到动态代理的方法中，对核心的业务方法没有侵入，而且还便于我们的维护。

AOP简介

AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充.
AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点.
在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里.
AOP 的好处:

每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级
业务模块更简洁, 只包含核心业务代码.

AOP术语

切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象
通知(Advice): 切面必须要完成的工作
目标(Target): 被通知的对象
代理(Proxy): 向目标对象应用通知之后创建的对象
连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。例如 ArithmethicCalculator#add() 方法执行前的连接点，执行点为 ArithmethicCalculator#add()；方位为该方法执行前的位置
切点（pointcut）：每个类都拥有多个连接点：例如 ArithmethicCalculator 的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

基于Aspect的AOP – 前置通知

更多内容，参考：http://jinnianshilongnian.iteye.com/blog/1420689

涉及JAR包
com.springsource.net.sf.cglib-2.2.0.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
commons-logging-1.1.1.jar
spring-aop-4.1.7.RELEASE.jar
spring-aspects-4.1.7.RELEASE.jar
spring-beans-4.1.7.RELEASE.jar
spring-context-4.1.7.RELEASE.jar
spring-core-4.1.7.RELEASE.jar
spring-expression-4.1.7.RELEASE.jar

看下代码

public interface Calculation {

    public int add(int x, int y);

    public int sub(int x, int y);

    public int mul(int x, int y);

    public int dev(int x, int y);
}

@Component
public class CalculationImpl implements Calculation {

    @Override
    public int add(int x, int y) {
        int result = x + y;
        return result;
    }

    @Override
    public int sub(int x, int y) {
        int result = x - y;
        return result;
    }

    @Override
    public int mul(int x, int y) {
        int result = x * y;
        return result;
    }

    @Override
    public int dev(int x, int y) {
        int result = x / y;
        return result;
    }

}

实现接口，并且使用@Component标记为IOC容器中的组件。

    <context:component-scan base-package="com.gp.spring.aop.impl"></context:component-scan>

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

加入扫描注解的包路径。
Spring默认不支持@AspectJ风格的切面声明，增加aspectj-autoproxy，这样Spring就能发现@AspectJ风格的切面并且将切面应用到目标对象。

@Aspect
@Component
public class CalculationAspect {

    @Before("execution(public int com.gp.spring.aop.impl.Calculation.add(int, int))")
    public void beforeMethod(JoinPoint joinPoint) {
        String name = joinPoint.getSignature().getName();
        List<Object> list = Arrays.asList(joinPoint.getArgs());
        System.out.println("Method begin ... ,method=" + name + ", args = "
                + list);
    }

}

CalculationAspect 标记为Component组件，注册到IOC容器中
@Aspect标记，spring对其进行AOP相关的配置，生成相应的代理类
@Before，为前置通知，方法执行前的通知
“execution(public int com.gp.spring.aop.impl.Calculation.add(int,
int))”表达式，表示此通知要执行的包路径、方法的相关信息。此表达式可进行模糊匹配，比如”execution(public int
com.gp.spring.aop.impl.Calculation.*(..))”，表示Calculation类下的所有方法。
方法中的参数JoinPoint joinPoint，表示连接点，通过此参数可以获取到执行方法的相关信息，比如方法名、方法参数。

执行测试方法

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Calculation calculation = (Calculation)context.getBean("calculationImpl");
        int result = calculation.add(3, 4);
        System.out.println(result);
    }

输出结果

Method begin … ,method=add, args = [3, 4]
7

基于Aspect的AOP – 后置通知

后置通知与前置通知用法类似，区别就是在执行方法之后执行后置通知方法。

代码如下

    @After("execution(public int com.gp.spring.aop.impl.Calculation.add(int, int))")
    public void afterMethod(JoinPoint joinPoint) {
        String name = joinPoint.getSignature().getName();
        List<Object> list = Arrays.asList(joinPoint.getArgs());
        System.out.println("Method end ... ,method=" + name + ", args = "
                + list);
    }

这里用的@After注解，其他都没变化。

测试输出结果如下

Method begin … ,method=add, args = [3, 4]
executeing …
Method end … ,method=add, args = [3, 4]
7

我在对add方法增加了一个输出，便于区分前置通知、后置通知

    public int add(int x, int y) {
        int result = x + y;
        System.out.println("executeing ...");
        return result;
    }

基于Aspect的AOP – 返回通知

方法执行成功后，调用返回通知，如果方法在运行过程中抛出异常，则不会调用。

代码

    @AfterReturning(value = "execution(public int com.gp.spring.aop.impl.Calculation.add(int, int))", returning = "ret")
    public void afterReturnMethod(JoinPoint joinPoint, Object ret) {
        String name = joinPoint.getSignature().getName();
        List<Object> list = Arrays.asList(joinPoint.getArgs());
        System.out.println("@AfterReturning ... ,method=" + name + ", args = "
                + list + ", return = " + ret);
    }

与后置通知不同的是，后置通知在方法抛出异常，仍会被调用，这里我们可以使用try … catch … 进行类比。

输出结果

@Before … ,method=add, args = [3, 4]
executeing …
@After … ,method=add, args = [3, 4]
@AfterReturning … ,method=add, args = [1, 3], return = 4
7

基于Aspect的AOP – 异常通知

方法在运行过程中，如果抛出异常，则调用异常通知

代码

    @AfterThrowing(value = "execution(public int com.gp.spring.aop.impl.Calculation.*(int, int))", throwing = "ex")
    public void afterThrowMethod(JoinPoint joinPoint, Exception ex) {
        System.out.println("@AfterThrowing ... ,ex = " + ex);
    }

此处与之前的用法有些却别，在注解的参数中增加了throwing，然后在方法中增加了要捕获的异常，此处类似于try…catch…的catch中代码块

输出结果

Exception in thread “main” @AfterThrowing … ,ex = java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero
at com.gp.spring.aop.impl.CalculationImpl.dev(CalculationImpl.java:29)

基于Aspect的AOP – 环绕通知

环绕通知，类似与我们最开始讲解的动态代理，在此通知中你可以去调用目标方法，并在目标方法的上下做各种通知（前置、返回、后置、异常等处理）

代码：

    @Around("execution(public int com.gp.spring.aop.impl.Calculation.add(int, int))")
    public Object aroundMethod(ProceedingJoinPoint pjd) {
        String name = pjd.getSignature().getName();
        List<Object> list = Arrays.asList(pjd.getArgs());
        Object obj = null;

        System.out.println("前置通知 ... ,method=" + name + ", args = "
                + list);
        try {
            obj = pjd.proceed();
            System.out.println("返回通知 ... ,method=" + name + ", args = "
                    + list);
        } catch (Throwable e) {
            System.out.println("异常通知 ... , exception = " + e);
            e.printStackTrace();
        }
        System.out.println("后置通知 ... ,method=" + name + ", args = "
                + list);
        return obj;
    }

返回结果：

前置通知 … ,method=add, args = [1, 3]
executeing …
返回通知 … ,method=add, args = [1, 3]
后置通知 … ,method=add, args = [1, 3]
4

基于Aspect的AOP – 切入方法优先级

下面我们在来增加一个前置通知，创建一个新类

代码如下

@Aspect
@Component
public class ValidateAspect {

    @Before("execution(public int com.gp.spring.aop.impl.Calculation.add(int, int))")
    public void validate(){
        System.out.println("验证方法 com.gp.spring.aop.impl.ValidateAspect");
    }
}

此类我们做了一个验证。

然后运行测试方法（代码复用基于Aspect的AOP – 环绕通知）

前置通知 … ,method=add, args = [1, 3]
验证方法 com.gp.spring.aop.impl.ValidateAspect
executeing …
返回通知 … ,method=add, args = [1, 3]
后置通知 … ,method=add, args = [1, 3]
@AfterReturning … ,method=add, args = [1, 3], return = 4
4

验证方法 com.gp.spring.aop.impl.ValidateAspect，输出了我们新增加的切入方法，那么这里的先后顺序怎么制定呢，我们可以使用@order(1)

如下

@Order(1)
@Aspect
@Component
public class ValidateAspect {

}

@Order(1)表示优先执行此切入方法。数值越小，优先级越高。

基于Aspect的AOP – 重用切点表达式

这里写图片描述
我们之前学习过，定义一个切面方法，要在其注解中，增加切入的目标方法信息，那如果多个方法都切入同样的目标方法的时候，我们可不可以将相同的目标方法信息提取出来呢。

下面我们演示下代码（复用之前代码）

@Order(2)
@Aspect
@Component
public class CalculationAspect {

    @Pointcut("execution(public int com.gp.spring.aop.impl.Calculation.*(..))")
    public void aspectName(){

    }

    @AfterReturning(value = "aspectName()", returning = "ret")
    public void afterReturnMethod(JoinPoint joinPoint, Object ret) {
        String name = joinPoint.getSignature().getName();
        List<Object> list = Arrays.asList(joinPoint.getArgs());
        System.out.println("@AfterReturning ... ,method=" + name + ", args = "
                + list + ", return = " + ret);
    }

    @Around("aspectName()")
    public Object aroundMethod(ProceedingJoinPoint pjd) {
        String name = pjd.getSignature().getName();
        List<Object> list = Arrays.asList(pjd.getArgs());
        Object obj = null;

        System.out.println("前置通知 ... ,method=" + name + ", args = "
                + list);
        try {
            obj = pjd.proceed();
            System.out.println("返回通知 ... ,method=" + name + ", args = "
                    + list);
        } catch (Throwable e) {
            System.out.println("异常通知 ... , exception = " + e);
            e.printStackTrace();
        }
        System.out.println("后置通知 ... ,method=" + name + ", args = "
                + list);
        return obj;
    } 
}

我们定义了一个aspectName方法，然后增加@Pointcut(“execution(public int com.gp.spring.aop.impl.Calculation.*(..))”)注解。
然后后续，直接调用此方法名即可。

如果在其他类中呢，增么调用aspectName方法，代码如下

@Order(1)
@Aspect
@Component
public class ValidateAspect {

    @Before("com.gp.spring.aop.impl.CalculationAspect.aspectName()")
    public void validate(){
        System.out.println("验证方法 com.gp.spring.aop.impl.ValidateAspect");
    }
}

方法所在类的全路径名即可。

运行结果

验证方法 com.gp.spring.aop.impl.ValidateAspect
前置通知 … ,method=add, args = [1, 3]
executeing …
返回通知 … ,method=add, args = [1, 3]
后置通知 … ,method=add, args = [1, 3]
@AfterReturning … ,method=add, args = [1, 3], return = 4
4

GP0071

关注

0
点赞
踩
11

收藏

觉得还不错? 一键收藏
1
评论
Spring -- AOP入门基础&基于Aspect的AOP通知用法

动态代理我们在日常开发过程中是否会遇到下图中的这种状况红框中的是我们要输出的日志，你是否发现，日志中大部分信息都是相同的，并且如果我们要修改一个地方，所有的地方都需要改，而且代码看起来还比较冗余下面我们就可以通过动态代理的方式解决这个问题看下代码public interface Calculation { public int add(int x, int y); publi
复制链接

扫一扫