Spring框架中AOP的第三部分具体内容是什么？

本文共计4038个文字，预计阅读时间需要17分钟。

1. Spring AOP 简介

2.基于XML的AOP配置

3.基于注解的AOP开发

4.Spring AOP 简介 1.1

5.AOP：面向切面编程（Aspect-Oriented Programming）

6.AOP是一种基于动态代理的编程，对原有代码无侵入

1、Spring的AOP简介 2、基于xml的AOP开发 3、基于注解的AOP开发 1、Spring的AOP简介 1.1 什么是AOP

AOP为Aspect Oriented Programming的缩写，是一种面向切面的编程，是基于动态代理的，对原有代码毫无入侵性，把和主业务无关的事情放到代码外面去做。所以当你下次发现某一行代码经常在你的Controller例出现时，就要考虑用AOP来精简代码了。

简而言之：在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想，就是面向切面的编程。

AOP是OOP的延续，是软件开发中的热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。

1.2 AOP 的作用及优势

AOP的作用：

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发的效率。

AOP的优势：

减少重复代码，提高开发效率，维护方便

1.3 AOP 的底层实现

AOP的底层原理是通过Spring 提供的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时增进功能的介入，再去调用目标对象的方法，从而增强功能。

1.4 AOP 的动态代理技术

Spring的AOP的底层实现用到了两种代理机制：

JDK的动态代理：基于接口的动态代理技术

cglib的动态代理：基于父类的动态代理技术

什么是动态代理：

代理是一种设计模式，提供了目标对目标对象的访问方式，即是通过代理对象访问目标对象，可以在目标对象的基础上，增加额外的功能，拓展目标对象的功能。

1.4.1 JDK 的动态代理

1、目标类接口及目标类

public interface TargetInterface { public void save(); }

public class Target implements TargetInterface{ @Override public void save() { System.out.println("Save Running....."); } }

2、对象增强代码

public class Enhance { public void before(){ System.out.println("前置增强...."); } ​ public void after(){ System.out.println("后置增强...."); } }

3、动态代理代码

当调用接口的任何方法时，代理对象的代码都不需要修改

1 public class proxyTest { 2 public static void main(String[] args) { 3 ​ 4 final Target target = new Target(); //创建目标对象 5 final Enhance enhance = new Enhance(); // 获得增强对象 6 ​ 7 //返回值就是动态生成的代理对象 8 TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance( 9 //目标对象加载器 10 target.getClass().getClassLoader(), 11 target.getClass().getInterfaces(), 12 new InvocationHandler() { 13 //调用代理对象的任何方法，实际上执行的都是invoke方法 14 @Override 15 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 16 enhance.before(); //前置增强 17 //执行目标方法 18 Object invoke = method.invoke(target, args); 19 enhance.after(); // 后置增强 20 return invoke; 21 } 22 } 23 ​ 24 ); 25 ​ 26 //调用代理对象方法 27 proxy.save(); 28 ​ 29 } 30 }

1.4.2 cglib 的动态代理

1、目标类

public class Target{ ​ public void save() { System.out.println("Save Running....."); } }

2、对象增强代码

public class Enhance { public void before(){ System.out.println("前置增强...."); } ​ public void after(){ System.out.println("后置增强...."); } }

3、动态代理代码

1 public class proxyTest { 2 public static void main(String[] args) { 3 ​ 4 final Target target = new Target(); //创建目标对象 5 final Enhance enhance = new Enhance(); // 获得增强对象 6 ​ 7 //返回值就是动态生成的代理对象 基于cglib 8 /* 9 * 1. 创建增强器 10 * 2。设置目标类（父类） 11 * 3. 设置回调 12 * 4. 创建代理对象 13 * */ 14 ​ 15 Enhancer enhancer = new Enhancer(); 16 enhancer.setSuperclass(Target.class); 17 //设置回调 18 enhancer.setCallback(new MethodInterceptor() { 19 @Override 20 public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 21 //执行前置 22 enhance.before(); 23 Object invoke = method.invoke(target, args); //执行目标对象 24 //执行后置 25 enhance.after(); 26 return invoke; 27 } 28 }); 29 // 创建代理对象 30 Target proxy = (Target) enhancer.create(); 31 ​ 32 proxy.save(); 33 } 34 }

1.5 AOP相关术语

Spring的AOP实现底层就是对上面的动态代理的代码进行了封装，封装之后只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定的目标方法增强。

我们必须理解的常用的AOP相关术语：

Target（目标对象）代理的目标对象 Proxy（代理） 一个类被AOP织入增强后，就产生一个结果代理类 Joinpoint（连接点） 所谓连接点就是指那些被拦截的点。在Spring中，这些点指的是方法 因为Spring只支持方法类型的连接点 Pointcut（切入点） 所谓切入点是指我们对那些Joinpoint进行拦截的定义 Advice（通知/增强） 通知是指拦截到Joinpoint 之后所要做的事情 Aspect（切面） 是切入点和通知的结合 Weaving（织入） 是指把增强应用到目标对象来创建的代理对象的过程。 Spring采用动态代理织入，而Aspect采用编译期织入和类装载期织入

1.6 AOP开发明确的事项

1、需要编写的内容

• 编写核心业务代码（目标类的目标方法）

• 编写切面类，切面类中有通知（增强功能方法）

• 在配置文件中，配置织入关系，即将那些通知与连接点进行结合

2、AOP技术实现的内容

Spring框架监控切入点方法的执行。一旦监控到切入点方法被执行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑。

3、AOP底层使用哪种代理方式

在Spring中，框架会根据目标类是否实现接口来决定采用哪种动态代理方式。

1.7 知识要点总结

• AOP：面向切面编程

• AOP底层实现：基于JDK的动态代理和基于Cglib的动态代理

• AOP的重要概念：

　　　　Pointcut（切入点）: 被增强方法

　　　　Advice（通知/增强）：封装增强业务逻辑的方法

　　　　Aspect（切面）：切点+通知

　　　　Weaving（织入）：将切点与通知结合的过程

• 开发明确事项：

　　　　谁是切点（切点表达式配置）

　　　　谁是通知（切面类中的增强方法）

　　　　将切点和通知进行织入配置

2. 基于xml的AOP开发 2.1 快速入门

1、导入AOP相关坐标

<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.16</version> </dependency> <!-- aspectj的织入--> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.8.13</version> </dependency>

2、创建目标接口和目标类（内部有切点）

public interface TargetInterface { public void save(); }

public class Target implements TargetInterface{ ​ @Override public void save() { System.out.println("Save Running....."); } }

3、创建切面类（内部有增强方法）

public class MyAspect { ​ public void before(){ System.out.println("前置增强...."); } }

4、将目标类和切面类的对象创建权交给Spring

<!-- 目标对象--> <bean id="target" class="com.ntect.aop.Target"></bean> ​ <!-- 切面--> <bean id="myAspect" class="com.ntect.aop.MyAspect"></bean>

5、在applicationContext.xml中配置织入关系

先导入aop命名空间

配置织入通知

<!-- 配置织入:告诉Spring哪些方法（切点）需要进行增强（前置、后置...)--> <aop:config> <!-- 声明切面--> <aop:aspect ref="myAspect"> <!-- 切面：切点+通知 --> <aop:before method="before" pointcut="execution(public void com.ntect.aop.Target.save())"/> </aop:aspect> </aop:config>

6、测试代码

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class AopTest { @Autowired private TargetInterface target; ​ @Test public void testAop(){ target.save(); } ​ ​ }

7、测试结果

2.2 XML配置AOP详解

1、切点表达式的写法

表达式语法：

execution[修饰符]返回值类型 包名.类名.方法名(参数) /* *1. 访问修饰符可以省略 *2. 返回值类型、包名、类名、方法名可以使用 * 代表任意 *3. 包名与类名之间一个点. 代表当前包下的类，两个点 .. 表示当前包及其子包下的类 *4. 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表 */

例如：

execution(public void com.ntect.aop.Target.method()) execution(public void com.ntect.aop.Target.*(..)) execution(public void com.ntect.aop.*.*(..)) //常用形式 execution(public void com.ntect.aop..*.*(..)) execution(* *..*.*(..))

2、通知的类型

通知的配置语法：

<aop:通知类型 method="切面类中方法名" pointcut="切点表达式"></aop:通知类型> 名称标签说明 前置通知 <aop:before> 用于配置前置通知，指定增强方法在切入点方法之前执行 后置通知 <aop:after-returnning> 用于配置后置通知，指定增强的方法在切入点方法之后执行 环绕通知 <aop:around> 用于配置环绕通知，指定增强的方法在切入点 方法之之后都执行 异常抛出通知 <aop:throwing> 用于配置异常抛出通知，指定增强的方法在出现异常时执行 最终通知 <aop:after> 用于配置最终通知，无论增强方式执行是否异常都会执行

1 public class MyAspect { 2 ​ 3 public void before(){ 4 System.out.println("前置增强...."); 5 } 6 ​ 7 public void afterReturning(){ 8 System.out.println("后置增强....."); 9 } 10 ​ 11 //Proceeding JoinPoint : 正在执行的连接点====切点 12 public Object around(ProceedingJoinPoint pjp) throws Throwable { 13 System.out.println("环绕前增强...."); 14 Object proceeding = pjp.proceed(); // 切点方法 15 System.out.println("环绕后增强...."); 16 return proceeding; 17 } 18 ​ 19 public void afterThrowing(){ 20 System.out.println("异常抛出增强...."); 21 } 22 ​ 23 public void after(){ 24 System.out.println("最终增强...."); 25 } 26 }

<aop:config> <!-- 声明切面--> <aop:aspect ref="myAspect"> <!-- 切面：切点+通知 --> <aop:before method="before" pointcut="execution(public void com.ntect.aop.Target.save())"/> <aop:after-returning method="afterReturning" pointcut="execution(* com.ntect.aop.*.*(..))"/> <aop:around method="around" pointcut="execution(* com.ntect.aop.*.*(..))"/> <aop:after-throwing method="afterThrowing" pointcut="execution(* com.ntect.aop.*.*(..))"/> <aop:after method="after" pointcut="execution(* com.ntect.aop.*.*(..))"/> </aop:aspect> </aop:config>

3、切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用pointcut-ref属性代替pointcut属性来引用抽取后的切点表达式。

<!-- 抽取切点表达式--> <aop:config> <!-- 引用MyAspect的Bean为切面对象--> <aop:aspect ref="myAspect"> <aop:pointcut id="myPointcut" expression="execution(* com.ntect.aop.*.*(..))"/> <aop:before method="before" pointcut-ref="myPointcut"/> <aop:around method="around" pointcut-ref="myPointcut"/> <aop:after method="after" pointcut-ref="myPointcut"/> </aop:aspect> </aop:config>

2.3 知识要点

• aop织入的配置

<aop:config> <aop:aspect ref="切面类"> <aop:after method="通知方法名称" pointcut="切点表达式"/> </aop:aspect> </aop:config>

• 通知的类型：前置通知、后置通知、环绕通知、异常抛出通知、最终通知

• 切点表达式的写法：

execution([修饰符] 返回值类型 包名.类名.方法名(参数))

3. 基于注解的AOP开发 3.1 快速入门

开发步骤：

1、创建目标接口和目标类（内部有切点）

2、创建切面类（内部有增强方法）

3、将目标类和切面类的对象创建权交给Spring

@Component("target") public class Target implements TargetInterface { ​ public void save() { System.out.println("Save Running....."); } }

@Component("myAspect") public class MyAspect { public void before(){ System.out.println("前置增强...."); }

4、在切面类中使用注解配置织入关系

@Component("myAspect") @Aspect //标注当前MyAspeect是一个切面类 public class MyAspect { ​ //配置前置增强 @Before("execution(* com.ntect.anno.*.*(..))") public void before(){ System.out.println("前置增强...."); }

5、在配置文件中开启组件扫描和AOP的自动代理

<!-- 开启组件扫描--> <context:component-scan base-package="com.ntect.anno"/> ​ <!-- aop自动代理--> <aop:aspectj-autoproxy/>

6、测试代码

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext-anno.xml") public class annoTest { @Autowired private TargetInterface target; ​ @Test public void testAop(){ target.save(); } ​ }

7、测试结果

3.2 注解配置AOP

1、注解通知的类型

通知的配置语法：@通知注解（“切点表达式”）

名称 注解 说明 前置通知 @Before 用于配置前置通知。指定增强的方法在切入点方法之前执行 后置通知 @AfterReturning 用于配置后置通知。指定增强的方法在切入点方法之后执行 环绕通知 @Around 用于配置环绕通知。指定的增强方法在切入点方法之前和之后执行 异常抛出通知 @AfterThrowing 用于配置异常抛出通知。指定增强的方法在出现异常时执行 最终通知 @After 用于配置最终通知。无论增强方式执行是否有异常都会执行

1 @Component("myAspect") 2 @Aspect //标注当前MyAspeect是一个切面类 3 public class MyAspect { 4 ​ 5 //配置前置增强 6 @Before("execution(* com.ntect.anno.*.*(..))") 7 public void before(){ 8 System.out.println("前置增强...."); 9 } 10 ​ 11 @AfterReturning("execution(* com.ntect.anno.*.*(..))") 12 public void afterReturning(){ 13 System.out.println("后置增强....."); 14 } 15 ​ 16 @Around("execution(* com.ntect.anno.*.*(..))") 17 //Proceeding JoinPoint : 正在执行的连接点====切点 18 public Object around(ProceedingJoinPoint pjp) throws Throwable { 19 System.out.println("环绕前增强...."); 20 Object proceeding = pjp.proceed(); // 切点方法 21 System.out.println("环绕后增强...."); 22 return proceeding; 23 } 24 ​ 25 @AfterThrowing("execution(* com.ntect.anno.*.*(..))") 26 public void afterThrowing(){ 27 System.out.println("异常抛出增强...."); 28 } 29 ​ 30 @After("execution(* com.ntect.anno.*.*(..))") 31 public void after(){ 32 System.out.println("最终增强...."); 33 } 34 }

2、切点表达式的抽取

同 xml配置aop一样时，我们可以将切点表达式抽取，具体如下：

1 @Component("myAspect") 2 @Aspect //标注当前MyAspeect是一个切面类 3 public class MyAspect { 4 ​ 5 //定义切点表达式 6 @Pointcut("execution(* com.ntect.anno.*.*(..))") 7 public void pointCut(){} 8 //配置前置增强 9 @Before("MyAspect.pointCut()") 10 public void before(){ 11 System.out.println("前置增强...."); 12 } 13 ​ 14 @AfterReturning("MyAspect.pointCut()") 15 public void afterReturning(){ 16 System.out.println("后置增强....."); 17 } 18 ​ 19 @Around("MyAspect.pointCut()") 20 //Proceeding JoinPoint : 正在执行的连接点====切点 21 public Object around(ProceedingJoinPoint pjp) throws Throwable { 22 System.out.println("环绕前增强...."); 23 Object proceeding = pjp.proceed(); // 切点方法 24 System.out.println("环绕后增强...."); 25 return proceeding; 26 } 27 ​ 28 @AfterThrowing("MyAspect.pointCut()") 29 public void afterThrowing(){ 30 System.out.println("异常抛出增强...."); 31 } 32 ​ 33 @After("MyAspect.pointCut()") 34 public void after(){ 35 System.out.println("最终增强...."); 36 } 37 }

测试结果：

3、总结

• 注解开发步骤：

　　　　1、使用@Aspect标注切面

　　　　2、使用@通知注解标注通知方法

　　　　3、在配置文件中配置AOP自动代理<aop:aspectj-autoproxy/>