Spring | Srping AOP (AOP简介、动态代理、基于“代理类”的AOP实现)

- [1.Spring AOP简介](#1.Spring AOP简介)
- - [1.1 AOP简介](#1.1 AOP简介)
  - [1.2 AOP术语](#1.2 AOP术语)
- 2.动态代理
- - [2.1 JDK动态代理](#2.1 JDK动态代理)
  - [2.2 CGLIB代理](#2.2 CGLIB代理)
- 3.基于"代理类"的AOP实现
- - [3.1 Spring的通知类型](#3.1 Spring的通知类型)
  - [3.2 ProxyFactoryBean ( 可通知.xml配置文件完成aop功能 )](#3.2 ProxyFactoryBean ( 可通知.xml配置文件完成aop功能 ))

1.Spring AOP简介

1.1 AOP简介

Spring的AOP模块 ，是Spring框架体系结构中十分重要的内容，该模块中提供了面向切面编程实现。

AOP 的全称是 Aspect-Oriented Programming，即面向切面编程( 也称面向方面编程 )它是面向对象编程(OOP)的一种补充 ，目前已成为一种比较成熟的编程方式。

在传统的业务处理代码中，通常都会进行事务处理 、日志记录 等操作。虽然使用OOP 可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能(如日志记录 )，同样的代码 仍然会分散到各个方法 中。这样，如果想要关闭某个功能 ，或者对其进行修改 ，就必须要修改所有的相关方法。这不但增加了开发人员的工作量，而且提高了代码的出错率。

(要实现AOP功能 ，核心关键之一 是 : "代理 "，通过"代理"可以获得 "增强功能后的目标对象" ，从而实现AOP功能)

为了解决这一问题，AOP思想 随之产生。AOP 采取横向抽取机制，将分散在各个方法中的重复代码 提取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。这种采用横向抽取机制 的方式，采用传统的O0P思想显然是无法办到的，因为00P只能实现父子关系 的纵向的重用。虽然AOP是一种新的编程思想，但却不是O0P的替代品，它只是OOP的延伸和补充。

在AOP思想中，类与切面的关系图 如下所示：

从上图 (类与切面关系图 )可以看出，通过Aspect (切面 ) 分别在Class1 和Class2 的方法中加入了事务、日志、权限和异常等功能。

AOP的使用 ，使开发人员在编写业务逻辑时可以专心于核心业务 ，而不用过多地关注 于其他业务逻辑的实现，这不但提高了开发效率，而且增强了代码的可维护性。

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

1.2 AOP术语

AOP术语 包括 Aspect、Joinpoint、Pointcut、 Advice、 Target Object、Proxy 和 Weaving。具体讲解如下。

一、Aspect ( 切面 ) :
在实际应用中，切面通常是指封装的用于横向插入系统功能 (如事务、日志等) 的类。如 "类与切面关系图 " 的 Aspect。该类要被Spring容器 识别为切面，需要在配置文件<bean>元素指定 (哪个 类将作为切面)。

（切面可以理解为 "切面类"）

二、Joinpoint ( 连接点 ) :

在程序执行过程 中的某个阶段点 ，它实际上是对象的一个操作 。

例子如：方法的调用 或异常的抛出 。在Spring AOP 中，连接点 就是指方法的调用 ( 非切面类的那个类的方法的调用)。

三、Pointcut( 切入点 ) :

是指切面与程序流程 的 交叉点，即那些 需要处理 的连接点 ( 即待处理的" 方法的调用 " )。
通常在++程序++ 中，切入点 指的是类或者方法名。

例子如：某个通知 要应用到所有以add开头 的方法中，那么所有满足这一规则 的方法都是切入点。

"切面、连接点和切入点 " 关系图如下图所示" ：

四、Advice( 通知 / 增强处理 ) :
AOP框架 在特定的 切入点 ( 类 /方法名 )执行的增强处理 ，即在定义好的切入点 处所 要执行的程序代码。

可以将 ( Advice ) 理解为 切面中的方法，Advice 是切面的具体实现。

五、Target Object ( 目标对象 ) :

是指所有 被通知 的对象，也称为被 增强对象。如果AOP框架采用的是动态的AOP实现 ，那么该对象就是一个被代理对象。

六、Weaving ( 织入 ) :

将 切面类中代码 插入到目标对象 上，从而生成代理对象 的过程。

七、Proxy( 代理 ) :

将通知应用到目标对象 之后，被动态创建的对象，该对象称为"代理对象 " / 增强功能后 的目标对象 ，

该对象可直接当目标对象 使用。（Proxy (代理) 可理解为一个过程，一个将目标对象 进行增强，变为代理对象 / "增强功能 后的目标对象 的过程。） ( 代理就是AOP框架动态生成 的一个对象 )

八、 Proxy Class (代理类) :

实现"Proxy ( 代理 )功能 "的类。该类 (代理类) 中包含了 Proxy(代理) "所需的功能代码。

九、Proxy Object (代理对象) / 增强功能后 的目标对象:

Proxy Object (代理对象 ) 称为 / 可理解 为 "增强功能后 的目标对象" 。该对象可直接当 "目标对象" 使用。

代理对象 通常包含了目标对象的功能 ，同时在原目标对象的基础上添加一些额外的功能 或逻辑，例如日志记录、事务管理等，因此可以说，代理对象 可以被理解为"增强功能后的目标对象"。

2.动态代理

AOP 中的==代理就是由AOP框架动态生成 的一个对象 ==，该对象 可直接当目标对象 使用。

(此处的代理：就是上面提到过的生成 "增强功能后的目标对象 " 的代理)

Spring 中的AOP代理 ，有 ① JDK动态代理 ② CGLIB代理。(两者都是 "动态代理 ")。
ps :

① JDK动态代理 和 CGlib代理 都属于 "动态代理"。

② JDK动态代理 的目标对象 要实现一个或多个接口 ，如果要对没有实现接口 的目标类 / 目标对象 进行代理时，可用CGLIB代理。

2.1 JDK动态代理

JDK动态代理 是通过java.lang.reflect.Proxy 类来实现的，我们可以调用Proxy 类的 newProxyInstance() 方法来创建代理对象 。对于使用业务接口 的类，Sping 默认 会使用JDK代理 来实现AOP。

（JDK动态代理要实现接口，CGLIB代理不用实现接口。）

Spring 中JDK动态代理的例子如：

第一步、在DIEA中创建一个Java项目，添加web功能模块。

第二步、在项目WEB-INF目录中创建lib文件夹，存放Spring框架最基本核心的jar包，让jar包生效。

获取spring框架基本核心jar包

第三步、创建UserDao接口 ，在该接口中编写添加和删除的方法。

创建UserDao的实现类 UserDaoImpl ，分别实现接口中的方法，并在每个方法中添加一条输出语句。
UserDao.java
java 复制代码
public interface UserDao{

 public void addUser();

 public void deleteUser();
}
UserDaoImpl.java
java 复制代码
public class UserDaoImpl implements UserDao { // "目标类",该类创建的对象为"目标对象"

@Override
public void addUser() {  //这方法将要被"增强处理"
    System.out.println("添加用户");
}

@Override
public void deleteUser() { //这方法将要被"增强处理"
    System.out.println("删除用户");
}
}
实现类UserDaoImpl 作为 目标类 ，对其中的方法进行 增强处理。

第四步、创建切面类 ： MyAspect 。

在该类中定义一个模拟权限检查 的方法和一个模拟记录日志 的方法，这两个方法 就表示切面中的通知。
java 复制代码
public class MyAspect { //切面类 : 以下为两个通知,将用于为"目标对象"实现增强功能。

//通知 : 要执行的切面类"的方法"
//在特定的 "切入点" 进行增强处理 : 在"切入点"的前或后，执行切面类中的方法

public void check_Permissions() { //该方法即为"通知" : 切面类中的方法
    System.out.println("模拟检查权限...");
}

public void log() { //通知
    System.out.println("模拟记录日志...");
}

/*
   对某个方法(切入点)进制"增强处理" : 即在程序执行这个方法的"前或后"的时机执行"切面方法"(添加通知)
 */
}
第五步、创建 代理类 JdkProxy ，该类实现 InvocationHandler 接口 ，并编写代理方法 。在代理方法中，需要通过Proxy 类实现动态代理。
java 复制代码
/**
   *  JDK代理类 (JdkProxy) : 将通知应用到目标对象之后，被动态创建的对象。
   *  代理对象 : 经过"代理"这一过程，生成的类即为"代理对象"，也称为"增强功能后的目标对象"
   *  (可以理解为: "代理" / "代理类"的目的之一 : 生成"代理对象")
*/
public class JdkProxy implements InvocationHandler {

//声明目标类接口
private UserDao userDao;

//创建代理方法
public Object createProxy(UserDao userDao) {

    this.userDao = userDao;
    //1.类加载器 (JdkProxy的类加载器) ---获得JdkProxy对应的"类加载器"
    ClassLoader classLoader = JdkProxy.class.getClassLoader();
    //2.被代理对象实现的所有接口 (此处为: UserDao 的接口内容等。)
    Class[] clazz = userDao.getClass().getInterfaces();
    //3.使用代理类，进行增强，返回的是 "代理后的对象" / "增强功能后的目标对象"
    return Proxy.newProxyInstance(classLoader, clazz, this);
}

/**
       * @param proxy  被代理后的对象
       * @param method 将要执行的方法信息 (反射)
       * @param args   执行方法时需要的参数
       * @throws Throwable
 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    /**
      声明切面类 (其中有要用在特定"切入点"的"通知")
       切入点 : 要进行"增强处理"/被"通知" 的 方法名
       通知(也称"增强处理"): 切面类中的方法
       对切入点进行"增强处理" : 在某个方法被执行的前/后的时机执行切面中的"方法"
     */
    //创建切面类
    MyAspect myAspect = new MyAspect();

 /**
     *  目标方法执行的前后，会分别执行切面类中的 check_Permissions()方法 和 log()方法
     *  前增强 : 执行UserDao接口的方法之前先执行 切面类中的 check_Permissions()这个方法
     *  后增强 : 执行完接口的方法后执行log()这个方法
  */
    //前增强
    myAspect.check_Permissions();

    //在目标类上调用方法，并传入参数
    Object obj = method.invoke(userDao, args); //执行UserDao接口中的方法

    //后增强
    myAspect.log();

    return obj;
}
}
上述例子中，JdkProxy类 (代理类) 实现了 InvocationHandler 接口 ，并实现了接口中的 invoke方法 ，所有动态代理类 所调用的方法 都会交由该 ( invoke) 方法处理 。在创建的代理方法 createProxy()中使用了 Proxy 类的 newProxyInstance()方法 来创建 代理对象。newProxyInstance()方法中包含3个参数，其中第1个参数是当前类的类加载器，第2个参数表示的是被代理对象实现的所有接口，第3个参数this代表的就是代理类JdkProxy本身 。在invoke()方法中，目标类方法执行的前后 会分别执行切面类中的check _Permissions() 方法和 log() 方法。

第六步、创建测试类 JdkTest ，在该类中的main()方法中创建代理对象 和目标对象 ，然后从代理对象中获得对目标对象userDao增强功能后的对象，最后调用该对象的添加和删除方法。
java 复制代码
public class JdkTest {
public static void main(String[] args) {
    //实例化JdkProxy类(JDK代理类) : 该类能产生"代理对象"(增强功能的目标对象)
    JdkProxy jdkProxy = new JdkProxy();
    //创建目标对象
    UserDao userDao  = new UserDaoImpl();
    /*
      调用JdkProxy中的createProxy()方法获得"代理对象"
     */
    UserDao userDao1 = (UserDao)jdkProxy.createProxy(userDao);

    //指向UserDao中的两个方法，该UserDao已被进行AOP操作，其中方法执行的前后都会执行切面类中的方法
    userDao1.addUser();
    userDao1.deleteUser();
}
}
测试类运行结果 ：

UserDao实例 的++添加用户++ 和 ++删除用户++ 的方法被成功调用，并且在调用前后 分别添加了"权限检查"和"记录日志"的功能，这种实现了接口的代理方式 ，就是Spring中的JDK动态代理。

2.2 CGLIB代理

JDK动态代理 的使用简单，但它还有一定的局限性，使用 JDK动态代理 的对象必须实现一个或多个接口。

如果要对没有实现接口 的类进行代理，那么可以使用 CGLIB代理。即目标类 / 目标对象 ，没有实现任何接口时 ，可用CGLIB代理。

ps:
JDK动态代理 的目标对象 要实现一个或多个接口 ，如果要对没有实现接口 的目标类 / 目标对象 进行代理时，可用CGLIB代理。

CGLIB ( Code Generation Library )是一个高性能开源 的代码生成包 ，它采用非常底层 的字节码技术 ，对指定的目标类 生成一个子类， 并对子类 进行增强。在Spring的核心包 中已经集成了CGLIB所需要的包 ，所以开发中不需要 另外导入JAR包 。

（JDK动态代理 和 CGLIB代理 用核心包 就行，不需要额外的JAR包）
Spring 中JDK动态代理 的例子如：
第一步、在DIEA中创建一个Java项目，添加web功能模块。

第二步、在项目WEB-INF目录中创建lib文件夹，存放Spring框架最基本核心的jar包，让jar包生效。

获取spring框架基本核心jar包

第三步、创建目标类：UserDao ，UserDao不需要实现任何接口，只需定义一个添加用户的方法和一个删除用户的方法。
java 复制代码
public class UserDao { //目标类，没实现任何接口，可用CGLIB代理
     public void addUser() {
	        System.out.println("添加用户");
	    }
    public void deleteUser() {
        System.out.println("删除用户");
    }
}
第四步、创建切面类 ： MyAspect 。

在该类中定义一个模拟权限检查 的方法和一个模拟记录日志 的方法，这两个方法 就表示切面中的通知。
java 复制代码
public class MyAspect { //切面类 : 以下为两个通知,将用于为"目标对象"实现增强功能。

//通知 : 要执行的切面类"的方法"
//在特定的 "切入点" 进行增强处理 : 在"切入点"的前或后，执行切面类中的方法

public void check_Permissions() { //该方法即为"通知" : 切面类中的方法
    System.out.println("模拟检查权限...");
}

public void log() { //通知
    System.out.println("模拟记录日志...");
}

/*
   对某个方法(切入点)进制"增强处理" : 即在程序执行这个方法的"前或后"的时机执行"切面方法"(添加通知)
 */
}
第五步、创建代理类 ： CglibProxy ，该代理类需要实现 MethodInterceptor 接口，并实现接口中的 intercept( ) 方法。
java 复制代码
import com.myh.cglib.aspect.MyAspect;
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 CglibProxy implements MethodInterceptor { //CGLIB代理 : 目标类不需要实现接口

    //代理方法
    public Object createProxy(Object target) { //创建"代理对象/增强后的目标对象"的方法
        //创建一个动态类对象 (Enhancer : 增强器)
        Enhancer enhancer = new Enhancer();
        //确定要增强的类，为Enhancer设置"父类"
        enhancer.setSuperclass(target.getClass());
        //添加回调函数
        enhancer.setCallback(this);
        //返回创建的代理类
        return enhancer.create();
    }

    /**
     * @param proxy CGlib指定"父类"生成的"代理对象"
     * @param method 拦截的方法
     * @param args   拦截方法的参数数组
     * @param methodProxy 方法的代理对象，用于执行父类的方法
     * @throws Throwable
     */
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
         //创建切面类对象
        MyAspect myAspect = new MyAspect();
        //前增强
        myAspect.check_Permissions();
        //目标方法的执行
        Object obj = methodProxy.invokeSuper(proxy, args); //执行"代理对象"的 "父类的方法"
        //后增强
        myAspect.log();
        return obj;
    }
}
在 CglibProxy 类的代理方法 中，首先创建了一个动态类对象Enhancer ，它是CGLIB 的核心类；然后调用了Enhancer 类的 setSuperclass()方法来确定目标对象 (为动态类对象指定父类 )；接下来调用了setCallback()方法添加回调函数 ，其中的this 代表的就是代理类CglibProxy本身 ；最后通过return语句将创建的代理类对象返回 。 intercept()方法 会在程序执行目标方法时被调用，方法运行时将会执行切面类 中的增强方法。

第六步、

创建测试类 CglibTest 在该类的main()方法中首先创建代理对象 和目标对象 ，然后从代理对象中获得增强后的目标对象 ，最后调用对象 的添加和删除方法。
java 复制代码
public class CglibTest {
    public static void main(String[] args) {
        //创建代理对象
        CglibProxy cglibProxy = new CglibProxy();
        //创建目标对象
        UserDao userDao = new UserDao();
        UserDao userDao1 = (UserDao)cglibProxy.createProxy(userDao);
        //执行方法
        userDao1.addUser();
        userDao1.deleteUser();
    }
}
测试类运行结果 ：

从测试类结果可以看出，目标类UserDao中 的方法被成功调用 且增强了，这种 (目标类) 没有实现接口的代理方式 ，就是CGLIB代理。

3.基于"代理类"的AOP实现

动态代理 中的 JDK动态代理 和 CGLIB代理 都是基于"代理类"的AOP实现。

Spring 中的 AOP代理默认使用 的是 JDK动态代理。

在Spring 中使用 ProxyFactoryBean 是创建 AOP代理 的最基本的方式。

3.1 Spring的通知类型

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

org.aopalliance .intercept.MethodInterceptor (环绕通知) :
在目标方法 执行前后实施增强，可以应用于日志、事务管理等功能。

org.springframework. aop .MethodBeforeAdvice (前置通知) ：
在目标方法 执行前实施增强，可以应用于权限管理等功能。

org.springframework. aop .AfterReturningAdvice (后置通知) ：
在目标方法 执行后实施增强，可以应用于关闭流 、上传文件 、 删除临时文件等功能

org.springframework.aop .ThrowsAdvice (异常通知) :
在方法抛出异常后 实施增强，可以应用于处理异常记录日志等功能。

org.springframework.aop .IntroductionInterceptor (引介通知) ：
在目标类中 添加一些新 的方法和属性，可以应用于修改老版本程序 (增强类)。

3.2 ProxyFactoryBean ( 可通知.xml配置文件完成aop功能 )

ProxyFactoryBean 是 FactoryBean接口的实现类，FactoryBean 负责实例化一个Bean ，

而 ProxyFactoryBean 负责为其他Bean 创建代理实例。在Spring中，使用ProxyFactoryBean 是创建AOP代理 的基本方式。

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

属性名称描述

target 代理的目标对象

proxyInterfaces 代理要实现 的接口，如果是多个接口 ，可以使用**以下格式赋值 <list> <value></value> ... </list>

proxyTargetClass 是否对类代理 而不是接口 ，设置为true 时，使用CGLIB代理 . （设置为true 表示是对类代理 ，自然是用 CGLIB代理）

interceptorNames 需要织入目标 的Advice。

singleton 返回的代理是否为单实例 ，默认为true (即返回单实例)

optimize 当设置为true 时，强制使用CGLIB
对ProxyFactoryBean 类有了初步的了解后，接下来通过一个典型的环绕通知案例 ，来演示Spring使用ProxyFactoryBean 创建AOP代理 的过程，例子如下 ：
第一步、

在核心JAR包的基础上 ，项目的lib目录 中导入AOP的两个JAR包 ，①spring-aop.jar 和 ②aopalliance.jar ；
spring-aop.jar : 是Spring为实现AOP 功能提供的JAR包 。
aopalliance.jar : 是AOP联盟提供的规范包，是实现AOP功能 所需JAR包。

Spring核心jar + aop有关的jar

第二步、创建UserDao接口 ，在该接口中编写添加和删除的方法。

创建UserDao的实现类 UserDaoImpl ，分别实现接口中的方法，并在每个方法中添加一条输出语句。
UserDao.java
java 复制代码
public interface UserDao{

 public void addUser();

 public void deleteUser();
}
UserDaoImpl.java
java 复制代码
public class UserDaoImpl implements UserDao { // "目标类",该类创建的对象为"目标对象"

@Override
public void addUser() {  //这方法将要被"增强处理"
    System.out.println("添加用户");
}

@Override
public void deleteUser() { //这方法将要被"增强处理"
    System.out.println("删除用户");
}
}
实现类UserDaoImpl 作为 目标类 ，对其中的方法进行 增强处理。

第三步、

创建切面类MyAspect 。由于实现环绕通知 需要实现 org. aopalliance .intercept.MethodInterceptor接口，所以MyAspect 类需要实现该接口 ，并实现接口中的 invoke() 方法，来执行目标方法 。
MyAspect.java
java 复制代码
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
//切面类
public class MyAspect implements MethodInterceptor { //切面类,该切面类实现了aopalliance包下的 MethodInterceptor(环绕通知)接口

    public void check_Permission() { //切面方法 (通知)
        System.out.println("模拟权限检查...");
    }

    public void log() { //切面方法 (通知)
        System.out.println("模拟记录日志...");
    }

    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        /*
        在目标方法执行的前后，分別执行了"检查权限" 和 "记录日志"的方法，这两个方法也就是"增强的方法"，也就是通知。
        */ 
        check_Permission();
        //执行目标方法
        Object obj = mi.proceed();
        log();
        return obj;
    }
}
第四步、

创建配置文件applicationContext.xml ，并指定对象。
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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    
    <bean id="userDao" class="com.myh.factorybean.UserDaoImpl"/>

    
    <bean id="myAspect" class="com.myh.factorybean.MyAspect"/>

    
    <bean id="userDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        
        <property name="proxyInterfaces" value="com.myh.factorybean.UserDao"/>
        
        <property name="target" ref="userDao"/>
        
        <property name="interceptorNames" value="myAspect"/>
        
        <property name="proxyTargetClass" value="true"/>
    </bean>
</beans>
上述配置文件代码中，首先通过 <bean>元素 定义了目标类 和切面，然后使用 ProxyFactoryBean 类定义了代理对象 。在定义的代理对象中，分别通过 <property>子元素 指定了①代理实现的接口切代理 、②目标对象 、③需要织入目标类的通知 以及④代理方式。

第五步、

创建ProxyFactoryBeanTest 测试类 ，在类中通过Spring容器获取代理对象的实例 ，并执行目标方法。
java 复制代码
package com.myh.factorybean;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class ProxyFactoryBeanTest { //测试类
    public static void main(String[] args) {
        String xmlPath = "com/myh/factorybean/applicationContext.xml";
        //创建ApplicationContext (从其中获取IOC容器中的Bean)
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        //从IOC容器中获得"代理对象"
        UserDao userDao = (UserDao) applicationContext.getBean("userDaoProxy"); //获得"增强功能后的目标对象"
        //执行目标方法
        userDao.addUser();
        userDao.deleteUser();
    }
}
测试类运行结果如下 ：

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

Spring | Srping AOP (AOP简介、动态代理、基于“代理类”的AOP实现)

目录:

1.Spring AOP简介

1.1 AOP简介

1.2 AOP术语

2.动态代理

2.1 JDK动态代理

2.2 CGLIB代理

3.基于"代理类"的AOP实现

3.1 Spring的通知类型

3.2 ProxyFactoryBean ( 可通知.xml配置文件完成aop功能 )