Spring基础篇之AOP [ Mi1k7ea ]

0x00 参考

本笔记直接参考或引自如下链接文章：

https://www.w3cschool.cn/wkspring/

http://c.biancheng.net/spring/

0x01 Spring AOP

AOP的全称是“Aspect Oriented Programming”，即面向切面编程，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。

AOP采取横向抽取机制，取代了传统纵向继承体系的重复性代码，其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。

目前最流行的AOP框架有两个：

Spring AOP:使用纯Java实现，不需要专门的编译过程和类加载器，在运行期间通过代理方式向目标类植入增强的代码；
AspectJ:是一个基于Java语言的AOP框架，从Spring 2.0开始，Spring AOP引入了对AspectJ的支持。AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的植入；

0x02 AOP术语

AOP相关术语如下：

名称	说明
Joinpoint（连接点）	指那些被拦截到的点，在Spring中，可以被动态代理拦截目标类的方法。
Pointcut（切入点）	指要对哪些Joinpoint进行拦截，即被拦截的连接点。
Advice（通知）	指拦截到Joinpoint之后要做的事情，即对切入点增强的内容。
Target（目标）	指代理的目标对象。
Weaving（植入）	指把增强代码应用到目标上，生成代理对象的过程。
Proxy（代理）	指生成的代理对象。
Aspect（切面）	切入点和通知的结合。

0x03 JDK动态代理

在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。在程序运行过程中产生的这个对象，其实就是通过反射机制来生成的一个代理。

注意，JDK提供的代理只能针对接口做代理。

具体更多的可参考之前的文章：Java动态代理机制

Demo

除了前面的参考文章中的例子外，再看个模拟使用JDK动态代理实现AOP的例子。

CustomerDao.java，接口类：

package com.mi1k7ea;

public interface CustomerDao {
    public void add(); // 添加
    public void update(); // 修改
    public void delete(); // 删除
    public void find(); // 查询
}

CustomerDaoImpl.java，实现CustomerDao接口类：

package com.mi1k7ea;

public class CustomerDaoImpl implements CustomerDao {
    @Override
    public void add() {
        System.out.println("CustomerDaoImpl.add()");
    }
    @Override
    public void update() {
        System.out.println("CustomerDaoImpl.update()");
    }
    @Override
    public void delete() {
        System.out.println("CustomerDaoImpl.delete()");
    }
    @Override
    public void find() {
        System.out.println("CustomerDaoImpl.find()");
    }
}

MyAspect.java，切面类，定义了两个增强的方法，分别为myBefore()和myAfter()方法，用于对目标类CustomerDaoImpl进行增强：

package com.mi1k7ea;

public class MyAspect {
    public void myBefore() {
        System.out.println("方法执行之前");
    }
    
    public void myAfter() {
        System.out.println("方法执行之后");
    }
}

MyBeanFactory.java，代理类，使用java.lang.reflect.Proxy实现JDK动态代理，定义了一个静态的getBean()方法，这里模拟Spring框架的IoC思想，通过调用getBean()方法创建CustomerDao实例，其中Proxy.newProxyInstance()方法的第一个参数是当前类的类加载器，第二参数是所创建实例的实现类的接口，第三个参数就是需要增强的方法；在目标类方法执行的前后，分别执行切面类中的myBefore()方法和myAfter()方法：

package com.mi1k7ea;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyBeanFactory {
    public static CustomerDao getBean() {
        // 准备目标类
        final CustomerDao customerDao = new CustomerDaoImpl();
        // 创建切面类实例
        final MyAspect myAspect = new MyAspect();
        // 使用代理类，进行增强
        return (CustomerDao) Proxy.newProxyInstance(
                MyBeanFactory.class.getClassLoader(),
                new Class[] { CustomerDao.class }, new InvocationHandler() {
                    public Object invoke(Object proxy, Method method,
                                         Object[] args) throws Throwable {
                        myAspect.myBefore(); // 前增强
                        Object obj = method.invoke(customerDao, args);
                        myAspect.myAfter(); // 后增强
                        return obj;
                    }
                });
    }
}

MainApp.java，在调用代理类的getBean()方法时，获取的是CustomerDao类的代理对象，然后调用了该对象中的方法：

package com.mi1k7ea;

public class MainApp {
    public static void main(String[] args) {
        // 从工厂获得指定的内容（相当于spring获得，但此内容时代理对象）
        CustomerDao customerDao = MyBeanFactory.getBean();
        // 执行方法
        customerDao.add();
        customerDao.update();
        customerDao.delete();
        customerDao.find();
    }
}

输出如下，说明成功通过JDK动态代理实现AOP：

0x04 CGLIB动态代理

JDK动态代理使用起来非常简单，但是存在一定的局限性，即只能对接口进行代理、不能对普通的类进行代理，如果不希望实现接口，则可以使用CGLIB代理。

CGLIB（Code Generation Library）是一个高性能开源的代码生成包，它被许多AOP框架所使用，其底层是通过使用一个小而快的字节码处理框架ASM（Java字节码操控框架）转换字节码并生成新的类。因此CGLIB要依赖于ASM的包，解压Spring的核心包spring-core的jar包，其中包含asm和cglib目录，也就是说Spring的核心包已经集成了CGLIB所需要的包，所以在开发中不需要另外导入ASM的JAR包了：

网上找的两者的区别如下：

Java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

如何强制使用CGLIB实现AOP？
（1）添加CGLIB库，SPRING_HOME/cglib/*.jar
（2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class=”true”/>

JDK动态代理和CGLIB字节码生成的区别？
（1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类
（2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法

Demo

GoodsDao.java，被代理的非接口类：

package com.mi1k7ea;

public class GoodsDao {
    public void add() {
        System.out.println("添加商品...");
    }
    public void update() {
        System.out.println("修改商品...");
    }
    public void delete() {
        System.out.println("删除商品...");
    }
    public void find() {
        System.out.println("修改商品...");
    }
}

MyBeanFactory.java，CGLIB代理类，应用了CGLIB的核心类Enhancer，调用了Enhancer.setSuperclass()方法确定被代理的类GoodsDao；然后调用setCallback()方法添加回调函数，其中intercept()方法相当于JDK动态代理方式中创建的invoke()方法，该方法会在目标方法执行的前后，对切面类中的方法进行增强；最后调用Enhancer.create()方法创建代理类并返回：

package com.mi1k7ea;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class MyBeanFactory {
    public static GoodsDao getBean() {
        // 准备目标类
        final GoodsDao goodsDao = new GoodsDao();
        // 创建切面类实例
        final MyAspect myAspect = new MyAspect();
        // 生成代理类，CGLIB在运行时，生成指定对象的子类，增强
        Enhancer enhancer = new Enhancer();
        // 确定需要增强的类
        enhancer.setSuperclass(goodsDao.getClass());
        // 添加回调函数
        enhancer.setCallback(new MethodInterceptor() {
            // intercept 相当于 jdk invoke，前三个参数与 jdk invoke—致
            @Override
            public Object intercept(Object proxy, Method method, Object[] args,
                                    MethodProxy methodProxy) throws Throwable {
                myAspect.myBefore(); // 前增强
                Object obj = method.invoke(goodsDao, args); // 目标方法执行
                myAspect.myAfter(); // 后增强
                return obj;
            }
        });
        // 创建代理类
        GoodsDao goodsDaoProxy = (GoodsDao) enhancer.create();
        return goodsDaoProxy;
    }
}

MainApp.java，调用CGLIB代理类的getBean()方法，实际获取的是GoodsDao的代理对象并调用其方法：

package com.mi1k7ea;

public class MainApp {
    public static void main(String[] args) {
        // 从工厂获得指定的内容（相当于spring获得，但此内容时代理对象）
        GoodsDao goodsDao = MyBeanFactory.getBean();
        // 执行方法
        goodsDao.add();
        goodsDao.update();
        goodsDao.delete();
        goodsDao.find();
    }
}

运行输出：

0x05 Spring通知类型

通知（Advice）其实就是对目标切入点进行增强的内容，Spring AOP为通知（Advice）提供了org.aopalliance.aop.Advice接口。

Spring通知按照在目标类方法的连接点位置，可以分为以下五种类型：

名称	说明
org.springframework.aop.MethodBeforeAdvice（前置通知）	在方法之前自动执行的通知称为前置通知，可以应用于权限管理等功能。
org.springframework.aop.AfterReturningAdvice（后置通知）	在方法之后自动执行的通知称为后置通知，可以应用于关闭流、上传文件、删除临时文件等功能。
org.aopalliance.intercept.MethodInterceptor（环绕通知）	在方法前后自动执行的通知称为环绕通知，可以应用于日志、事务管理等功能。
org.springframework.aop.ThrowsAdvice（异常通知）	在方法抛出异常时自动执行的通知称为异常通知，可以应用于处理异常记录日志等功能。
org.springframework.aop.IntroductionInterceptor（引介通知）	在目标类中添加一些新的方法和属性，可以应用于修改旧版本程序（增强类）。

0x06 创建AOP代理

Spring创建一个AOP代理的基本方法是使用org.springframework.aop.framework.ProxyFactoryBean，这个类对应的切入点和通知提供了完整的控制能力，并可以生成指定的内容。

ProxyFactoryBean类中的常用可配置属性如下：

属性名称	描述
target	代理的目标对象
proxyInterfaces	代理要实现的接口，如果有多个接口，则可以使用以下格式赋值： `<list> <value ></value> ... </list>`
proxyTargetClass	是否对类代理而不是接口，设置为 true 时，使用 CGLIB 代理
interceptorNames	需要植入目标的 Advice
singleton	返回的代理是否为单例，默认为 true（返回单实例）
optimize	当设置为 true 时，强制使用 CGLIB

Demo

在Spring通知中，环绕通知是一个非常典型的应用。下面通过环绕通知的案例演示Spring创建AOP代理的过程。

除了SpringFramework的jar包外，还需要com.springsource.org.aopalliance-1.0.0.jar。

CustomerDao.java和CustomerDaoImpl.java不变。

MyAspect.java，实现了MethodInterceptor接口，并实现了接口的invoke()方法；MethodInterceptor接口是Spring AOP的JAR包提供的，而invoke()方法用于确定目标方法mi，并告诉Spring要在目标方法前后执行哪些方法：

package com.mi1k7ea;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

//需要实现接口，确定哪个通知，及告诉Spring应该执行哪个方法
public class MyAspect implements MethodInterceptor {
    public Object invoke(MethodInvocation mi) throws Throwable {
        System.out.println("方法执行之前");
        // 执行目标方法
        Object obj = mi.proceed();
        System.out.println("方法执行之后");
        return obj;
    }
}

MainApp.java：

package com.mi1k7ea;

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

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("Beans.xml");
        CustomerDao customerDao = (CustomerDao) applicationContext.getBean("customerDaoProxy");
        customerDao.add();
        customerDao.update();
        customerDao.delete();
        customerDao.find();
    }
}

Beans.xml，首先配置目标类和通知，然后使用ProxyFactoryBean类生成代理对象；其中配置代理实现的接口、代理的目标对象以及需要植入目标的通知；最后设置value属性值为true时，表示使用CGLIB代理，属性值为false时，表示使用JDK动态代理：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <!--目标类 -->
    <bean id="customerDao" class="com.mi1k7ea.CustomerDaoImpl" />
    
    <!-- 通知 advice -->
    <bean id="myAspect" class="com.mi1k7ea.MyAspect" />
    
    <!--生成代理对象 -->
    <bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--代理实现的接口 -->
        <property name="proxyInterfaces" value="com.mi1k7ea.CustomerDao" />
        <!--代理的目标对象 -->
        <property name="target" ref="customerDao" />
        <!--用通知增强目标 -->
        <property name="interceptorNames" value="myAspect" />
        <!-- 如何生成代理，true:使用cglib; false :使用jdk动态代理 -->
        <property name="proxyTargetClass" value="true" />
    </bean>

</beans>

运行输出：

0x07 使用AspectJ开发AOP

AspectJ是一个基于Java语言的AOP框架，它扩展了Java语言。Spring 2.0以后，新增了对AspectJ方式的支持，新版本的Spring框架，建议使用AspectJ方式开发AOP。

使用AspectJ开发AOP通常有两种方式：

基于XML的声明式
基于Annotation的声明式

基于XML的声明式

基于XML的声明式是指通过Spring配置文件的方式定义切面、切入点及声明通知，而所有的切面和通知都必须定义在<aop:config>元素中。

通过XML架构来实现的AOP，为了能使用aop命名空间标签，你需要导入spring-aop j架构，如下：

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

   <!-- bean definition & AOP specific configuration -->

</beans>

此外，还需要在ClassPath中使用以下AspectJ库文件：aspectjrt.jar、aspectjweaver.jar、aspectj.jar、aopalliance.jar。

声明aspect

一个aspect是使用aop元素声明的，支持的bean是使用ref属性引用的，如下所示：

<aop:config>
   <aop:aspect id="myAspect" ref="aBean">
   ...
   </aop:aspect>
</aop:config>
<bean id="aBean" class="...">
...
</bean>

这里，“aBean” 将被配置和依赖注入，就像前面的章节中你看到的其他的Spring Bean一样。

声明切入点

一个切入点有助于确定使用不同建议执行的感兴趣的连接点（即方法）。在处理基于配置的XML架构时，切入点将会按照如下所示定义：

<aop:config>
   <aop:aspect id="myAspect" ref="aBean">
   <aop:pointcut id="businessService"
      expression="execution(* com.xyz.myapp.service.*.*(..))"/>
   ...
   </aop:aspect>
</aop:config>
<bean id="aBean" class="...">
...
</bean>

下面的示例定义了一个名为“businessService”的切入点，该切入点将与com.mi1k7ea包下的Student类中的getName()方法相匹配：

<aop:config>
   <aop:aspect id="myAspect" ref="aBean">
   <aop:pointcut id="businessService"
      expression="execution(* com.mi1k7ea.Student.getName(..))"/>
   ...
   </aop:aspect>
</aop:config>
<bean id="aBean" class="...">
...
</bean>

声明建议

你可以使用<aop:{ADVICE NAME}>元素在一个aspect中声明五个建议中的任何一个，如下所示：

<aop:config>
   <aop:aspect id="myAspect" ref="aBean">
      <aop:pointcut id="businessService"
         expression="execution(* com.xyz.myapp.service.*.*(..))"/>
      <!-- a before advice definition -->
      <aop:before pointcut-ref="businessService" 
         method="doRequiredTask"/>
      <!-- an after advice definition -->
      <aop:after pointcut-ref="businessService" 
         method="doRequiredTask"/>
      <!-- an after-returning advice definition -->
      <!--The doRequiredTask method must have parameter named retVal -->
      <aop:after-returning pointcut-ref="businessService"
         returning="retVal"
         method="doRequiredTask"/>
      <!-- an after-throwing advice definition -->
      <!--The doRequiredTask method must have parameter named ex -->
      <aop:after-throwing pointcut-ref="businessService"
         throwing="ex"
         method="doRequiredTask"/>
      <!-- an around advice definition -->
      <aop:around pointcut-ref="businessService" 
         method="doRequiredTask"/>
   ...
   </aop:aspect>
</aop:config>
<bean id="aBean" class="...">
...
</bean>

你可以对不同的建议使用相同的doRequiredTask或者不同的方法。这些方法将会作为aspect模块的一部分来定义。

Demo

除了当前环境已有的jar包外，还需要添加com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar。

Student.java，拥有name和age属性及其getter和setter方法，同时还定义了一个打印并抛出错误信息的函数：

package com.mi1k7ea;

public class Student {
    private Integer age;
    private String name;
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getAge() {
        System.out.println("Age : " + age );
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        System.out.println("Name : " + name );
        return name;
    }
    public void printThrowException(){
        System.out.println("Exception raised");
        throw new IllegalArgumentException();
    }
}

Logging.java，实际上是aspect模块的一个示例，定义了在各个点调用的方法：

package com.mi1k7ea;

public class Logging {
    /**
     * This is the method which I would like to execute
     * before a selected method execution.
     */
    public void beforeAdvice(){
        System.out.println("Going to setup student profile.");
    }
    /**
     * This is the method which I would like to execute
     * after a selected method execution.
     */
    public void afterAdvice(){
        System.out.println("Student profile has been setup.");
    }
    /**
     * This is the method which I would like to execute
     * when any method returns.
     */
    public void afterReturningAdvice(Object retVal){
        System.out.println("Returning:" + retVal.toString() );
    }
    /**
     * This is the method which I would like to execute
     * if there is an exception raised.
     */
    public void AfterThrowingAdvice(IllegalArgumentException ex){
        System.out.println("There has been an exception: " + ex.toString());
    }
}

MainApp.java：

package com.mi1k7ea;

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

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        Student student = (Student) context.getBean("student");
        student.getName();
        student.getAge();
        student.printThrowException();
    }
}

Beans.xml，注意这里aop:pointcut配置了切入点，通知需要增强哪些方法，：

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

    <aop:config>
        <aop:aspect id="log" ref="logging">
            <aop:pointcut id="selectAll" expression="execution(* com.mi1k7ea.*.*(..))"/>
            <aop:before pointcut-ref="selectAll" method="beforeAdvice"/>
            <aop:after pointcut-ref="selectAll" method="afterAdvice"/>
            <aop:after-returning pointcut-ref="selectAll" returning="retVal" method="afterReturningAdvice"/>
            <aop:after-throwing pointcut-ref="selectAll" throwing="ex" method="AfterThrowingAdvice"/>
        </aop:aspect>
    </aop:config>

    <!-- Definition for student bean -->
    <bean id="student" class="com.mi1k7ea.Student">
        <property name="name"  value="mi1k7ea" />
        <property name="age"  value="6"/>
    </bean>

    <!-- Definition for logging aspect -->
    <bean id="logging" class="com.mi1k7ea.Logging"/>

</beans>

运行输出如下：

如果只是想声明某个特定的方法为切入点，则可修改*为具体的类方法，如：

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

    <aop:config>
        <aop:aspect id="log" ref="logging">
            <aop:pointcut id="selectAll" expression="execution(* com.mi1k7ea.Student.getName(..))"/>
            <aop:before pointcut-ref="selectAll" method="beforeAdvice"/>
            <aop:after pointcut-ref="selectAll" method="afterAdvice"/>
            <aop:after-returning pointcut-ref="selectAll" returning="retVal" method="afterReturningAdvice"/>
            <aop:after-throwing pointcut-ref="selectAll" throwing="ex" method="AfterThrowingAdvice"/>
        </aop:aspect>
    </aop:config>

    <!-- Definition for student bean -->
    <bean id="student" class="com.mi1k7ea.Student">
        <property name="name"  value="mi1k7ea" />
        <property name="age"  value="6"/>
    </bean>

    <!-- Definition for logging aspect -->
    <bean id="logging" class="com.mi1k7ea.Logging"/>

</beans>

运行输出，此时只针对特定的类方法实现AOP增强：

基于Annotation的声明式

在Spring中，尽管使用XML配置文件可以实现AOP开发，但是如果所有的相关的配置都集中在配置文件中，势必会导致XML配置文件过于臃肿，从而给维护和升级带来一定的困难。

为此，AspectJ框架为AOP开发提供了另一种开发方式——基于Annotation的声明式。AspectJ允许使用注解定义切面、切入点和增强处理，而Spring框架则可以识别并根据这些注解生成AOP代理。

Annotation注解的介绍如下：

名称	说明
@Aspect	用于定义一个切面。
@Before	用于定义前置通知，相当于 BeforeAdvice。
@AfterReturning	用于定义后置通知，相当于 AfterReturningAdvice。
@Around	用于定义环绕通知，相当于MethodInterceptor。
@AfterThrowing	用于定义抛出通知，相当于ThrowAdvice。
@After	用于定义最终final通知，不管是否异常，该通知都会执行。
@DeclareParents	用于定义引介通知，相当于IntroductionInterceptor（不要求掌握）。

通过在基于架构的XML配置文件中包含以下元素来支持@AspectJ的使用：

1	<aop:aspectj-autoproxy/>

此外，还需要在CLASSPATH中使用以下AspectJ库文件：aspectjrt.jar、aspectjweaver.jar、aspectj.jar、aopalliance.jar。

声明aspect

Aspects类和其他任何正常的bean一样，除了它们将会用@AspectJ注释之外，它和其他类一样可能有方法和字段，如下所示：

package org.xyz;
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class AspectModule {
}

它们将在XML中按照如下进行配置，就和其他任何bean一样：

1
2
3

<bean id="myAspect" class="org.xyz.AspectModule">
   <!-- configure properties of aspect here as normal -->
</bean>

声明切入点

一个切入点有助于确定使用不同建议执行的感兴趣的连接点（即方法）。在处理基于配置的XML架构时，切入点的声明有两个部分：

一个切入点表达式决定了我们感兴趣的哪个方法会真正被执行；
一个切入点标签包含一个名称和任意数量的参数。方法的真正内容是不相干的，并且实际上它应该是空的；

下面的示例中定义了一个名为‘businessService’的切入点，该切入点将与com.xyz.myapp.service包下的类中可用的每一个方法相匹配：

1
2
3

import org.aspectj.lang.annotation.Pointcut;
@Pointcut("execution(* com.xyz.myapp.service.*.*(..))") // expression 
private void businessService() {}  // signature

下面的示例中定义了一个名为‘getname’的切入点，该切入点将与com.mi1k7ea包下的Student类中的getName()方法相匹配：

1
2
3

import org.aspectj.lang.annotation.Pointcut;
@Pointcut("execution(* com.mi1k7ea.Student.getName(..))") 
private void getname() {}

声明建议

你可以使用@{ADVICE-NAME}注释声明五个建议中的任意一个，如下所示。这假设你已经定义了一个切入点标签方法businessService()：

@Before("businessService()")
public void doBeforeTask(){
 ...
}
@After("businessService()")
public void doAfterTask(){
 ...
}
@AfterReturning(pointcut = "businessService()", returning="retVal")
public void doAfterReturnningTask(Object retVal){
  // you can intercept retVal here.
  ...
}
@AfterThrowing(pointcut = "businessService()", throwing="ex")
public void doAfterThrowingTask(Exception ex){
  // you can intercept thrown exception here.
  ...
}
@Around("businessService()")
public void doAroundTask(){
 ...
}

你可以为任意一个建议定义你的切入点内联。下面是在建议之前定义内联切入点的一个示例：

@Before("execution(* com.xyz.myapp.service.*.*(..))")
public doBeforeTask(){
 ...
}

Demo

在前面例子的基础上，MainApp.java和Student.java不变。

Logging.java：

package com.mi1k7ea;

import org.aspectj.lang.annotation.*;

@Aspect
public class Logging {
    /** Following is the definition for a pointcut to select
     *  all the methods available. So advice will be called
     *  for all the methods.
     */
    @Pointcut("execution(* com.mi1k7ea.*.*(..))")
    private void selectAll(){}
    /**
     * This is the method which I would like to execute
     * before a selected method execution.
     */
    @Before("selectAll()")
    public void beforeAdvice(){
        System.out.println("Going to setup student profile.");
    }
    /**
     * This is the method which I would like to execute
     * after a selected method execution.
     */
    @After("selectAll()")
    public void afterAdvice(){
        System.out.println("Student profile has been setup.");
    }
    /**
     * This is the method which I would like to execute
     * when any method returns.
     */
    @AfterReturning(pointcut = "selectAll()", returning="retVal")
    public void afterReturningAdvice(Object retVal){
        System.out.println("Returning:" + retVal.toString() );
    }
    /**
     * This is the method which I would like to execute
     * if there is an exception raised by any method.
     */
    @AfterThrowing(pointcut = "selectAll()", throwing = "ex")
    public void AfterThrowingAdvice(IllegalArgumentException ex){
        System.out.println("There has been an exception: " + ex.toString());
    }
}

Beans.xml：

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

    <aop:aspectj-autoproxy/>

    <!-- Definition for student bean -->
    <bean id="student" class="com.mi1k7ea.Student">
        <property name="name"  value="mi1k7ea" />
        <property name="age"  value="6"/>
    </bean>

    <!-- Definition for logging aspect -->
    <bean id="logging" class="com.mi1k7ea.Logging"/>

</beans>

输出如下：