Spring AOP详解

Spring AOP详解

AOP概念

　　AOP是面向切面（方面）编程，扩展功能不修改源代码实现，其采取横向抽取机制，取代了传统纵向继承体系重复性代码。在其底层，使用动态代理来实现，对于有接口情况，使用动态代理创建接口实现类代理对象；对于没有接口情况，使用动态代理创建类的子类代理对象。

AOP操作术语　　

　　Joinpoint（连接点）：类里面可以被增强的方法，这些方法称为连接点。

　　Pointcut（切入点）：所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。

　　Advice（通知/增强）：所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。通知分为前置通知（在方法之前执行）、后置通知（在方法之后执行）、异常通知（方法出现异常）、最终通知（在后置之后执行）、环绕通知（在方法之前和之后执行）。想要计算方法的执行时间：在方法之前执行，在方法之后执行，两个相减即可得到执行的时间。运用的就是环绕通知。

 　　Aspect（切面）：是切入点和通知（引介）的结合。

　　Introduction（引介）：引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field。

　　Target（目标对象）：代理的目标对象（要增强的类）

　　Weaving（织入）：是把增强应用到目标的过程。把advice 应用到 target的过程

　　Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类

　　总结：

　　切面和织入的区别：切面是将增强应用到具体方法上的过程，织入是将增强应用到具体的类上的过程。

 

AOP原理图解

对于有接口的情况：

对于没有接口的情况：

Spring中的AOP

　　AOP并不是Spring框架特有的，Spring只是支持AOP编程的框架之一，SpringAOP是一种基于方法拦截的AOP，在Spring中有四种方式去实现AOP的拦截功能。

　　1）使用 ProxyFactoryBean 和对应的接口实现AOP

　　2）使用 XML 配置 AOP

　　3）使用@AspectJ 注解驱动切面

　　4）使用AspectJ 注入切面

　　在Spring AOP的拦截方式中，真正常用的是用 @AspectJ 注解的方式实现的切面。

使用表达式配置切入点

　　1 切入点：实际增强的方法

　　2 常用的表达式

　　　　execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

　　　　（1）execution(* cn.itcast.aop.Book.add(..))           这个类中的这个方法

　　　　（2）execution(* cn.itcast.aop.Book.*(..))               这个类中的所有方法

　　　　（3）execution(* *.*(..))                                            所有类中的所有方法

　　（4） 匹配所有save开头的方法 execution(* save*(..))

 

　　3.指定切面的优先级

• 在同一个连接点上应用不止一个切面时, 除非明确指定, 否则它们的优先级是不确定的.
• 切面的优先级可以通过实现 Ordered 接口或利用 @Order 注解指定.
• 实现 Ordered 接口, getOrder() 方法的返回值越小, 优先级越高.
• 若使用 @Order 注解, 序号出现在注解中

　　4.重用切入点定义

• 在编写 AspectJ 切面时, 可以直接在通知注解中书写切入点表达式. 但同一个切点表达式可能会在多个通知中重复出现.
• 在 AspectJ 切面中, 可以通过 @Pointcut 注解将一个切入点声明成简单的方法. 切入点的方法体通常是空的, 因为将切入点定义与应用程序逻辑混在一起是不合理的.
• 切入点方法的访问控制符同时也控制着这个切入点的可见性. 如果切入点要在多个切面中共用, 最好将它们集中在一个公共的类中. 在这种情况下, 它们必须被声明为 public. 在引入这个切入点时, 必须将类名也包括在内. 如果类没有与这个切面放在同一个包中, 还必须包含包名.
• 其他通知可以通过方法名称引入该切入点.

使用@AspectJ 注解开发Spring AOP

package com.cnblogs.demrystv.aop.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.DeclareParents;
import org.aspectj.lang.annotation.Pointcut;

import com.cnblogs.demrystv.aop.verifier.RoleVerifier;
import com.cnblogs.demrystv.aop.verifier.impl.RoleVerifierImpl;
import com.cnblogs.demrystv.game.pojo.Role;

@Aspect
public class RoleAspect {
    
    @DeclareParents(value= "com.cnblogs.demrystv.aop.service.impl.RoleServiceImpl+", defaultImpl=RoleVerifierImpl.class)
    public RoleVerifier roleVerifier;

    @Pointcut("execution(* com.cnblogs.demrystv.aop.service.impl.RoleServiceImpl.printRole(..))")
    public void print() {
    }

    @Before("print()")
    // @Before("execution(*
    // com.cnblogs.demrystv.aop.service.impl.RoleServiceImpl.printRole(..))")
    public void before() {
        System.out.println("before ....");
    }

    @After("print()")
    // @After("execution(*
    // com.cnblogs.demrystv.aop.service.impl.RoleServiceImpl.printRole(..))")
    public void after() {
        System.out.println("after ....");
    }

    @AfterReturning("print()")
    // @AfterReturning("execution(*
    // com.cnblogs.demrystv.aop.service.impl.RoleServiceImpl.printRole(..))")
    public void afterReturning() {
        System.out.println("afterReturning ....");
    }

    @AfterThrowing("print()")
    // @AfterThrowing("execution(*
    // com.cnblogs.demrystv.aop.service.impl.RoleServiceImpl.printRole(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing ....");
    }

    @Around("print()")
    public void around(ProceedingJoinPoint jp) {
        System.out.println("around before ....");
        try {
            jp.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("around after ....");
    }

    @Before("execution(* com.cnblogs.demrystv.aop.service.impl.RoleServiceImpl.printRole(..)) " + "&& args(role, sort)")
    public void before(Role role, int sort) {
        System.out.println("before ....");
    }
}