Spring AOP三种实现方式与使用示例

AOP概述

AOP是OOP的延续，意思是面向切面编程，它可以在不修改源代码的情况下给程序动态地添加功能。Spring AOP是一种编程范式，主要目的是将非功能性需求从功能性需求中分离出来，达到解耦的目的。

AOP中必须明白的几个概念

1.切面
对于切面一词，官方的解释是：一个关注点的模块化，这个关注点可能会横切多个对象。它是通知与切入点的结合。切面由ApplicationContext中的<aop:aspect>来配置。
2.连接点
连接点是指程序执行过程中的某一行为。简单点说就是和方法前前后后有关的都属于连接点。
3.通知
通知是指切面对于某个连接点所产生的动作。一个切面可以包含多个通知。
4.切入点
在我们了解了连接点的基础上，来定义切入点，切入点通俗来说就是筛选连接点，留下你想织入通知的连接点。在AOP中通知和一个切入点表达式关联。切面中的所有通知所关注的连接点都是由切入点表达式决定。
5.目标对象
目标对象是指被一个或多个切面所通知的对象。
6.AOP代理
在Spring AOP中有两种代理方式：JDK动态代理和CGLib代理。默认情况下，目标对象实现了接口时，采用JDK动态代理。如果要强制使用CGLib代理，需要将<aop:config>的proxy-target-class属性设置为true。

实现方式一：实现相关Advice接口并配置xml文件

我们可以定义一个类去实现Advice的相关接口，以用来通知目标对象。
我们定义定义一个Before类实现MethodBeforeAdvice接口：

public class Before implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("before");
    }
}

再定义一个After类实现AfterReturningAdvice接口，来完成方法返回后的通知：

public class After implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("after");
    }
}

创建Service类：

public class Service {
    public void add(){
        System.out.println("add");
    }
}

做完以上工作后，我们需要在配置文件中声明bean和切面配置，xml文件：

	<bean id="service" class="com.jiawen.Service"/>
    <bean id="before" class="com.jiawen.Before"/>
    <bean id="after" class="com.jiawen.After"/>

    <aop:config>
        <aop:pointcut id="p" expression="execution(* com.jiawen.*.*(..))"/>
        <aop:advisor advice-ref="before" pointcut-ref="p"/>
        <aop:advisor advice-ref="after" pointcut-ref="p"/>
    </aop:config>

测试程序：

@Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Service service = (Service) context.getBean("service");
        service.add();
    }

运行结果：

before
add
after

这个方法以接口的实现为基础，如果我们需要大量的通知，那么就意味着我们要写多个接口的实现类，十分不利于管理与维护，那么接下来我们会介绍更好的方法。

实现方式二：自定义切面类并配置xml文件

同样以上面的Service为例，我们定义切面类AnnotationAspect：

public class AnnotationAspect {
    public void before(){
        System.out.println("before");
    }

    public void after(){
        System.out.println("after");
    }
}

配置xml文件：

	<bean id="service" class="com.jiawen.Service"/>
    <bean id="aspect" class="com.jiawen.AnnotationAspect"/>

    <aop:config>
        <!--声明一个切面，并且注入切面bean-->
        <aop:aspect ref="aspect">
            <!--配置一个切入点-->
            <aop:pointcut id="p" expression="execution(* com.jiawen.*.*(..))"/>
            <!--配置通知-->
            <aop:before method="before" pointcut-ref="p"/>
            <aop:after-returning method="after" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>

测试代码同上，这里不再重复。
运行结果：

before
add
after

方式三：自定义切面类并使用注解开发

定义切面类AnnotationAspect：

@Component
@Aspect
public class AnnotationAspect {
	//配置切入点，该方法无方法体，主要是为了方便同类中其它方法使用此处配置的切入点
    @Pointcut(value = "execution(* com.jiawen.*.*(..))")
    public void aspect(){};

    @Before("aspect()")
    public void before(){
        System.out.println("before");
    }


    @AfterReturning("aspect()")
    public void after(){
        System.out.println("after");
    }

    @Around("aspect()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("before around");
        joinPoint.proceed();
        System.out.println("after around");

    }
}

基于注解来声明切面类，我们必须要知道一些注解：

@Aspect：使用在类上面，用来声明这是一个切面类
@Before：前置通知
@After：后置通知
@AfterReturning：返回后通知
@AfterThrowing：抛出异常后通知
@Around：环绕通知

配置xml文件：

	<!--注解驱动-->
    <context:annotation-config></context:annotation-config>
    <!--组件扫描器-->
    <context:component-scan base-package="com.jiawen"/>
    <!--自动为spring容器中那些配置@Aspect切面的bean创建代理，织入切面。-->
    <aop:aspectj-autoproxy/>

测试程序同上，不再重复。
运行结果：

before around
before
add
after around
after

通过运行结果我们也看出不同通知的执行顺序。
首先执行的是@Around注解的方法在目标对象方法执行前的程序，然后执行@Before注解的方法，然后执行目标方法，再执行@Around注解的方法在目标对象方法执行后的程序，最后执行@AfterReturning注解的方法。