AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。
AOP是软件开发思想阶段性的产物，我们比较熟悉面向过程OPP和面向对象OOP，AOP是OOP的延续，但不是OOP的替代，而是作为OOP的有益补充。
参考《Spring 实战 (第4版)》和《精通Spring4.x 企业应用开发实战》两本书的AOP章节和其他资料将其知识点整理起来。
部分代码实例摘自《精通Spring4.x 企业应用开发实战》，文末我会给出两本书的PDF下载地址！
AOP概述
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程。那么什么又是面向切面呢？
我知道面向对象的特性：封装、继承、多态。通过抽象出代码*有特性来优化编程，但是这种方式又往往不能完全适用任何场景，无法避免的造成代码之间的耦合。
如下面的代码，运用的OOP思想将共有操作抽象了出来，抽象出了两个处理类：性能监视 PerformanceMonitor 和事务管理 TransactionManager
package com.smart.concept;
public class ForumService {
private TransactionManager transManager;
private PerformanceMonitor pmonitor;
private TopicDao topicDao;
private ForumDao forumDao;
public void removeTopic(int topicId) {
pmonitor.start();
transManager.beginTransaction();
topicDao.removeTopic(topicId); // ①
transManager.commit();
pmonitor.end();
}
public void createForum(Forum forum) {
pmonitor.start();
transManager.beginTransaction();
forumDao.create(forum); // ②
transManager.commit();
pmonitor.end();
}
}
①、②处是两个方法 removeTopic 和 createForum 独有的业务逻辑，但它们淹没在了重复化非业务性代码之中。这种抽象为纵向抽取。
将removeTopic和createForum进行横切重新审视：
我们无法通过纵向抽取的方式来消除代码的重复性。然而切面能帮助我们模块化横切关注点，横切关注点可以被描述为影响应用多处的功能。例如，性能监视和事务管理分别就是一个横切关注点。
AOP提供了取代继承和委托的另一种可选方案，那就是横向抽取，可以在很多场景下更清晰简洁。在使用面向切面编程时，我们仍然在一个地方定义通用功能，但是可以通过声明的方式定义这个功能要以何种方式在何处应用，而无需修改受影响的类。横切关注点可以被模块化为特殊的类，这些类被称为切面（aspect）。这样做有两个好处：首先，现在每个关注点都集中于一个地方，而不是分散到多处代码中；其次，服务模块更简洁，因为它们只包含主要关注点（或核心功能）的代码，而次要关注点的代码被转移到切面中了。
AOP术语
AOP不容易理解的一方面原因就是概念太多，并且由英语直译过来的名称也不统一，这里我选择使用较多的译名并给出英文供大家参考。
连接点（Joinpoint）
程序执行的某个时间点，如类初始化前/后，某个方法执行前/后，抛出异常前/后。
Spring仅支持方法的连接点，即仅能在方法调用前、方法调用后、方法抛出异常时这些程序执行点织入增强。
切点（Poincut）
一个程序类可以有多个连接点，但是如果某一部分连接点需要用什么来定位呢？那就是切点，这么说可能有点抽象。借助数据库查询的概念来理解切点和连接点的关系再适合不过了：连接点相当于数据库中的记录，而切点相当于查询条件。切点和连接点不是一对一的关系，一个切点可以匹配多个连接点。
在 Spring 中, 所有的方法都可以认为是 joinpoint, 但是我们并不希望在所有的方法上都添加 Advice, 而 Pointcut 的作用就是提供一组规则(使用 AspectJ pointcut expression language 来描述) 来匹配joinpoint, 给满足规则的 joinpoint 添加 Advice.
增强/通知（Advice）
将一段执行逻辑添加到切点，并结合切点信息定位到具体的连接点，通过拦截来执行逻辑。
Spring切面可以应用5种类型的通知：
- 前置通知（Before）：在目标方法被调用之前调用通知功能；
- 后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么；
- 返回通知（After-returning）：在目标方法成功执行之后调用通知；
- 异常通知（After-throwing）：在目标方法抛出异常后调用通知；
- 环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。
目标对象（Target）
增强逻辑的织入目标对象。目标对象也被称为 advised object
因为 Spring AOP 使用运行时代理的方式来实现 aspect, 因此 adviced object 总是一个代理对象(proxied object)
注意, adviced object 指的不是原来的类, 而是织入 advice 后所产生的代理类.
织入（Weaving）
将增强添加到目标类的具体连接点上的过程。在目标对象的生命周期里有多个点可以进行织入：
- 编译期：切面在目标类编译时被织入。这种方式需要特殊的编译器。
- 类加载期：切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器（ClassLoader），它可以在目标类被引入应用之前增强该目标类的字节码。
- 运行期：切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。Spring AOP就是以这种方式织入切面的。
引介/引入（Introduction）
向现有的类添加新的方法或属性。
Spring AOP 允许我们为 目标对象 引入新的接口(和对应的实现). 例如我们可以使用 introduction 来为一个 bean 实现 IsModified 接口, 并以此来简化 caching 的实现。
代理（Proxy）
一个类被AOP织入增强后，就产生了一个结果类，它是融合了原类和增强逻辑的代理类。根据不同的代理方式，代理类既可能是和原类具有相同接口的类，也可能就是原类的子类，所以可以采用与调用原类相同的方式调用代理类。
在 Spring AOP 中, 一个 AOP 代理是一个 JDK 动态代理对象或 CGLIB 代理对象.
切面（Aspect）
切面由切点和增强/通知组成，它既包括了横切逻辑的定义、也包括了连接点的定义。
Spring AOP就是负责实施切面的框架，它将切面所定义的横切逻辑织入切面所指定的连接点中。
Spring对AOP的支持
Spring提供了4种类型的AOP支持：
- 基于代理的经典Spring AOP；
- 纯POJO切面；
- @AspectJ注解驱动的切面；
- 注入式AspectJ切面（适用于Spring各版本）。
Spring AOP原理
Spring AOP的底层原理就是动态代理。
Java实现动态代理的方式有两种：
- 基于JDK的动态代理。
- 基于CGLib的动态代理。
JDK动态代理是需要实现某个接口了，而我们类未必全部会有接口，于是CGLib代理就有了。
- CGLib代理其生成的动态代理对象是目标类的子类。
- Spring AOP默认是使用JDK动态代理，如果代理的类没有接口则会使用CGLib代理。
那么JDK代理和CGLib代理我们该用哪个呢？？在《精通Spring4.x 企业应用开发实战》给出了建议：
- 如果是单例的我们最好使用CGLib代理，如果是多例的我们最好使用JDK代理
原因：
- JDK在创建代理对象时的性能要高于CGLib代理，而生成代理对象的运行性能却比CGLib的低。
- 如果是单例的代理，推荐使用CGLib
看到这里我们就应该知道什么是Spring AOP(面向切面编程)了：将相同逻辑的重复代码横向抽取出来，使用动态代理技术将这些重复代码织入到目标对象方法中，实现和原来一样的功能。
- 这样一来，我们就在写业务时只关心业务代码，而不用关心与业务无关的代码
代码实例
带有横切逻辑的实例
ForumService.java
package com.spring05;
interface ForumService {
public void removeTopic(int topicId);
public void removeForum(int forumId);
}
ForumServiceImpl.java
package com.spring05;
public class ForumServiceImpl implements ForumService{
@Override
public void removeTopic(int topicId) {
// 开始对该方法进行性能监视
PerformanceMonitor.begin("com.spring05.ForumServiceImpl.removeTopic");
System.out.println("模拟删除Topic记录："+topicId);
try {
Thread.currentThread().sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 结束对该方法的性能监视
PerformanceMonitor.end();
}
@Override
public void removeForum(int forumId) {
// 开始对该方法进行性能监视
PerformanceMonitor.begin("com.spring05.ForumServiceImpl.removeForum");
System.out.println("模拟删除Forum记录："+forumId);
try {
Thread.currentThread().sleep(40);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 结束对该方法的性能监视
PerformanceMonitor.end();
}
}
MethodPerformance.java
package com.spring05;
public class MethodPerformance {
private long begin;
private long end;
private String serviceMethod;
public MethodPerformance(String serviceMethod) {
this.serviceMethod = serviceMethod;
this.begin = System.currentTimeMillis(); // 记录目标类方法开始执行点的系统时间
}
public void printPerformance() {
this.end = System.currentTimeMillis(); // 获取目标类方式执行完成后的系统时间，进而计算出目标类方法的执行时间
long elapse = end - begin;
System.out.println(serviceMethod + "花费" + elapse + "毫秒");
}
}
PerformanceMonitor.java
package com.spring05;
public class PerformanceMonitor {
// 通过一个ThreadLocal保存与调用线程相关的性能监视信息
private static ThreadLocal<MethodPerformance> performanceRecord = new ThreadLocal<MethodPerformance>();
// 启动对某一目标方法的性能监视
public static void begin(String method) {
System.out.println("begin monitor...");
MethodPerformance mp = new MethodPerformance(method);
performanceRecord.set(mp);
}
public static void end() {
System.out.println("end monitor...");
MethodPerformance mp = performanceRecord.get();
// 打印出方法性能监视的结果信息
mp.printPerformance();
}
}
TestForumService.java
package com.spring05;
public class TestForumService {
public static void main(String[] args) {
ForumService forumService = new ForumServiceImpl();
forumService.removeForum(10);
forumService.removeTopic(1012);
}
}
执行 TestForumService.main 输出结果：
begin monitor...
模拟删除Forum记录：10
end monitor...
com.spring05.ForumServiceImpl.removeForum花费42毫秒
begin monitor...
模拟删除Topic记录：1012
end monitor...
com.spring05.ForumServiceImpl.removeTopic花费28毫秒
在 ForumServiceImpl 中的方法中仍然有非业务逻辑的性能监视代码（每个业务方法都有性能监视的开启和关闭代码），这破坏了方法的纯粹性。下面通过JDK动态代理和CGLib动态代理使非业务逻辑的性能监视代码动态的织入目标方法，以优化代码结构。
PS:上面代码可以拷贝出一份，下面举例大多都是以上面代码为基础改进的。
JDK动态代理
先注释掉 ForumServiceImpl 中非业务逻辑的代码：
package com.spring06;
public class ForumServiceImpl implements ForumService{
@Override
public void removeTopic(int topicId) {
// 开始对该方法进行性能监视
// PerformanceMonitor.begin("com.smart.proxy.ForumServiceImpl.removeTopic");
System.out.println("模拟删除Topic记录："+topicId);
try {
Thread.currentThread().sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 结束对该方法的性能监视
// PerformanceMonitor.end();
}
@Override
public void removeForum(int forumId) {
// 开始对该方法进行性能监视
// PerformanceMonitor.begin("com.smart.proxy.ForumServiceImpl.removeForum");
System.out.println("模拟删除Forum记录："+forumId);
try {
Thread.currentThread().sleep(40);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 结束对该方法的性能监视
// PerformanceMonitor.end();
}
}
创建横切代码处理类：
PerformanceHandler.java
package com.spring06; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method; /**
* 横切代码处理类，实现InvocationHandler接口
*/
public class PerformanceHandler implements InvocationHandler {
private Object target; public PerformanceHandler(Object target) {
// 设置目标业务类
this.target = target;
} @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 开始性能监视
PerformanceMonitor.begin(target.getClass().getName() + "." + method.getName());
// 通过反射机制调用目标对象方法
Object obj = method.invoke(target, args);
// 结束性能监视
PerformanceMonitor.end();
return obj;
}
}
修改 TestForumService 调用流程：
package com.spring06;
import java.lang.reflect.Proxy;
public class TestForumService {
public static void main(String[] args) {
// 希望被代理的目标业务类
ForumService target = new ForumServiceImpl();
// 将目标业务类和横切代码编织到一起
PerformanceHandler handler = new PerformanceHandler(target);
// 根据编织了目标业务逻辑和性能监视横切逻辑的InvocationHandler实例创建代理实例
ForumService proxy = (ForumService) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
handler);
// 调用代理实例
proxy.removeForum(10);
proxy.removeTopic(1012);
}
}
运行 TestForumService.main() 输出结果：
begin monitor...
模拟删除Forum记录：10
end monitor...
com.spring06.ForumServiceImpl.removeForum花费41毫秒
begin monitor...
模拟删除Topic记录：1012
end monitor...
com.spring06.ForumServiceImpl.removeTopic花费21毫秒
运行效果是一致的，横切逻辑代码抽取到了 PerformanceHandler 中。当其他业务类的业务方法需要性能监视时候，只需要为他们创建代理类就行了。
CGLib动态代理
使用JDK创建代理有一个限制，即它只能为接口创建代理实例，CGLib作为一个替代者，填补了这项空缺。
使用CGLib之前，需要先导入CGLib的jar包：
GitHub：https://github.com/cglib/cglib
Maven:
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.8</version>
</dependency>
CglibProxy.java
package com.spring07; import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.Method; public class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer(); public Object getProxy(Class clazz) { // 设置需要创建子类的类
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
// 通过字节码技术动态创建子类实例
return enhancer.create();
} @Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
// 拦截父类所有的方法
// 开始性能监视
PerformanceMonitor.begin(o.getClass().getName() + "." + method.getName());
// 通过代理类调用父类中的方法
Object result = methodProxy.invokeSuper(o, objects);
// 结束性能监视
PerformanceMonitor.end();
return result;
}
}
修改 TestForumService 调用流程：
package com.spring07;
public class TestForumService {
public static void main(String[] args) {
CglibProxy proxy = new CglibProxy();
// 通过动态生成子类的方式创建代理类
ForumServiceImpl forumService = (ForumServiceImpl) proxy.getProxy(ForumServiceImpl.class);
forumService.removeForum(10);
forumService.removeTopic(1023);
}
}
运行 TestForumService.main() 输出结果：
begin monitor...
模拟删除Forum记录：10
end monitor...
com.spring07.ForumServiceImpl$$EnhancerByCGLIB$$3123332f.removeForum花费60毫秒
begin monitor...
模拟删除Topic记录：1023
end monitor...
com.spring07.ForumServiceImpl$$EnhancerByCGLIB$$3123332f.removeTopic花费21毫秒
这里可以看到类名变成了com.spring07.ForumServiceImpl$$EnhancerByCGLIB$$3123332f.removeTopic，这个就是CGLib动态创建的子类。
由于CGLib采用动态创建子类的方式生成代理对象，所以不能对目标类中的 final 或 private 方法进行代理。
基于注解和命名空的AOP编程
Spring在新版本中对AOP功能进行了增强，体现在这么几个方面：
- 在XML配置文件中为AOP提供了aop命名空间
- 增加了AspectJ切点表达式语言的支持
- 可以无缝地集成AspectJ
Spring借鉴了AspectJ的切面，以提供注解驱动的AOP。这种AOP风格的好处在于能够不使用XML来完成功能。
使用引介/引入功能实现为Bean引入新方法
为了更好的理解，这里我新举个例子：
手机接口： Phone
package com.spring09;
public interface Phone {
// 打电话
public void call(String str);
// 发短信
public void sendMsg(String str);
}
手机接口实现类： BndPhone
package com.spring09;
public class BndPhone implements Phone {
@Override
public void call(String str) {
System.out.println("打电话 - " + str);
}
@Override
public void sendMsg(String str) {
System.out.println("发短信 - " + str);
}
}
手机扩展功能接口： PhoneExtend
package com.spring09;
public interface PhoneExtend {
// 听音乐
public void listenMusic(String str);
// 看视频
public void watchVideo(String str);
}
手机扩展功能接口实现类： BndPhoneExtend
package com.spring09;
public class BndPhoneExtend implements PhoneExtend {
@Override
public void listenMusic(String str) {
System.out.println("听音乐 - " + str);
}
@Override
public void watchVideo(String str) {
System.out.println("看视频 - " + str);
}
}
注解类： EnablePhoneExtendAspect 这里面定义了切面。这里需要先引入aspectjrt和aspectjweaver的jar包，Maven的配置代码会在后面贴出。
package com.spring09; import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;
import org.springframework.stereotype.Component; @Component
@Aspect
public class EnablePhoneExtendAspect {
@DeclareParents(value = "com.spring09.BndPhone", // 指定手机具体的实现
defaultImpl = BndPhoneExtend.class) // 手机扩展具体的实现
public PhoneExtend phoneExtend; // 要实现的目标接口
}
Spring 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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 开启注解扫描 -->
<context:component-scan base-package="com.spring09"/> <!-- 开启aop注解方式,默认为false -->
<aop:aspectj-autoproxy/> <bean id="phone" class="com.spring09.BndPhone"/>
<bean id="phoneExtend" class="com.spring09.BndPhoneExtend"/>
<bean class="com.spring09.EnablePhoneExtendAspect"/>
</beans>
测试类： Test
package com.spring09; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; public class Test {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("META-INF/applicationContext.xml"); Phone phone = (Phone) ctx.getBean("phone"); // 调用手机原有的方法
phone.call("BNDong");
phone.sendMsg("BNDong"); // 通过引介/引入切面已经将phone实现了PhoneExtend接口，所以可以强制转换
PhoneExtend phoneExtend = (PhoneExtend) phone;
phoneExtend.listenMusic("BNDong");
phoneExtend.watchVideo("BNDong");
}
}
执行 Test,main() 输出结果：
打电话 - BNDong
发短信 - BNDong
听音乐 - BNDong
看视频 - BNDong
可以看到 BndPhone 并没有实现 PhoneExtend 接口，但是通过引介/引入切面 BndPhone 拥有了 PhoneExtend 的实现。
我是通过Maven构建的Spring，这里我附上我Maven的pom：
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion> <groupId>com.spring09</groupId>
<artifactId>spring09-demo</artifactId>
<version>1.0-SNAPSHOT</version> <name>spring09-demo</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url> <properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
<org.springframework.version>4.3.7.RELEASE</org.springframework.version>
</properties> <dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency> <!-- spring start -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-instrument</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-instrument-tomcat</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-messaging</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc-portlet</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-websocket</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<!-- spring end --> <dependency>
<groupId>aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.5.4</version>
</dependency> <dependency>
<groupId>aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.5.4</version>
</dependency> </dependencies> <build>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.0.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.20.1</version>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
当引入接口方法被调用时，代理对象会把此调用委托给实现了新接口的某个其他对象。实际上，一个Bean的实现被拆分到多个类中。
在XML中声明切面
基于注解的配置要优于基于Java的配置，基于Java的配置要优于基于XML的配置。
Spring的AOP配置元素能够以非侵入性的方式声明切面。
同样使用上面手机的实例代码，我们去掉注解类通过XML配置的方式实现切面。
首先删除注解类 EnablePhoneExtendAspect ，这时再运行 Test.main() 就会抛出异常：
打电话 - BNDong
发短信 - BNDong
Exception in thread "main" java.lang.ClassCastException: com.spring10.BndPhone cannot be cast to com.spring10.PhoneExtend
at com.spring10.Test.main(Test.java:17)
修改Spring 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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 开启注解扫描 -->
<context:component-scan base-package="com.spring10"/> <!-- 开启aop注解方式,默认为false -->
<aop:aspectj-autoproxy/> <aop:config> <!-- 顶层aop配置元素 -->
<aop:aspect> <!-- 定义一个切面 -->
<aop:declare-parents
types-matching="com.spring10.BndPhone"
implement-interface="com.spring10.PhoneExtend"
delegate-ref="phoneExtend"/>
</aop:aspect>
</aop:config> <bean id="phone" class="com.spring10.BndPhone"/>
<bean id="phoneExtend" class="com.spring10.BndPhoneExtend"/>
</beans>
- <aop:config> ：顶层aop配置元素。
- <aop:aspect> ：定义一个切面。
- <aop:declare-parents> ：声明切面所通知的bean要在它的对象层次结构中拥有新的父类型。
- types-matching ：类型匹配的接口实现。
- implement-interface ：要实现的接口。
- delegate-ref ：引用一个Spring bean作为引入的委托。
- default-impl ：用全限定类名来显示指定实现。
这时运行 Test.main() 发现切面配置成功：
打电话 - BNDong
发短信 - BNDong
听音乐 - BNDong
看视频 - BNDong
切面类型总结图：
总结
- Spring采用JDK动态代理和CGLib动态代理技术在运行期织入增强。
- JDK动态代理需要目标类实现接口，而CGLib不对目标类作任何限制。
- JDK在创建代理对象时的性能高于CGLib，而生成的代理对象的运行性能却比CGLib的低。
- Spring只能在方法级别上织入增强。
- Spring的AOP配置元素能够以非侵入性的方式声明。
- 当Spring AOP不能满足需求时，我们必须转向更为强大的AspectJ。
参考资料
《Spring实战（第4版）》Craig Walls 著 / 张卫滨 译 下载（密码：8ts2）
《精通Spring 4.x 企业应用开发实战》陈雄华 林开雄 文建国 编著 下载（密码：my25）
https://baike.baidu.com/item/AOP/1332219?fr=aladdin
https://juejin.im/post/5b06bf2df265da0de2574ee1
https://segmentfault.com/a/1190000007469968