关于Spring——AOP（二）

关于Spring——AOP（二）
基于Schema的AOP

基于Schema的AOP从Spring2.0之后通过“aop”命名空间来定义切面、切入点及声明通知。

在Spring配置文件中，所以AOP相关定义必须放在<aop:config>标签下，该标签下可以有<aop:pointcut>、<aop:advisor>、<aop:aspect>标签，配置顺序不可变。

1.<aop:pointcut>：用来定义切入点，该切入点可以重用；

2.<aop:advisor>：用来定义只有一个通知和一个切入点的切面；

3.<aop:aspect>：用来定义切面，该切面可以包含多个切入点和通知，而且标签内部的通知和切入点定义是无序的；和advisor的区别就在此，advisor只包含一个通知和一个切入点。
```
<aop:config>                  
　　<aop:pointcut/>
　　<aop:advisor/>
　　<aop:aspect>
　　<aop:pointcut/>
　　　　<aop:before"/>
　　　　<aop:after-returning/>
　　　　<aop:after-throwing/>
　　<aop:after/>
　　<aop:around/>
　　<aop:declare-parents/>
   </aop:aspect>
</aop:config>
```
```
AOP定义开始（有序）
　　切入点定义（零个或多个）
　　Advisor定义（零个或多个）
　　切面定义开始（零个或多个，无序）
　　　　切入点定义（零个或多个）
　　　　前置通知（零个或多个）
　　　　后置返回通知（零个或多个）
　　　　后置异常通知（零个或多个）
　　　　后置最终通知（零个或多个）
　　　　环绕通知（零个或多个）
       引入定义（零个或多个）
　　切面定义开始（零个或多个）
AOP定义结束
```
一.声明切面

切面就是包含切入点和通知的对象，在Spring容器中将被定义为一个Bean，Schema方式的切面需要一个切面支持Bean，

该支持Bean的字段和方法提供了切面的状态和行为信息，并通过配置方式来指定切入点和通知实现。

切面使用<aop:aspect>标签指定，ref属性用来引用切面支持Bean。
```
<bean id="aspectSupportBean" class="……"/>
<aop:config>
<aop:aspect id="aspectId" ref="aspectSupportBean">
      ……
</aop:aspect>
</aop:config>
```
切面支持Bean“aspectSupportBean”跟普通Bean完全一样使用，切面使用“ref”属性引用它。

二.声明切入点

切入点在Spring中也是一个Bean，Bean定义方式可以有很三种方式：

1）在<aop:config>标签下使用<aop:pointcut>声明一个切入点Bean，该切入点可以被多个切面使用，对于需要共享使用的切入点最好使用该方式，

该切入点使用id属性指定Bean名字，在通知定义时使用pointcut-ref属性通过该id引用切入点，expression属性指定切入点表达式：
```
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* cn.javass..*.*(..))"/>
<aop:aspect ref="aspectSupportBean">
  <aop:before pointcut-ref="pointcut" method="before"/>
    </aop:aspect>
</aop:config>
```
2）在<aop:aspect>标签下使用<aop:pointcut>声明一个切入点Bean，该切入点可以被多个切面使用，但一般该切入点只被该切面使用，当然也可以被其他切面使用，

但最好不要那样使用，该切入点使用id属性指定Bean名字，在通知定义时使用pointcut-ref属性通过该id引用切入点，expression属性指定切入点表达式：
```
<aop:config>
<aop:aspect ref="aspectSupportBean">
    <aop:pointcut id=" pointcut" expression="execution(* cn.javass..*.*(..))"/>
    　　<aop:before pointcut-ref="pointcut" method="before"/>
    </aop:aspect>
</aop:config>
```
3）匿名切入点Bean，可以在声明通知时通过pointcut属性指定切入点表达式，该切入点是匿名切入点，只被该通知使用：
```
<aop:config>
<aop:aspect ref="aspectSupportBean">
<aop:after pointcut="execution(* cn.javass..*.*(..))" method="afterFinallyAdvice"/>
    </aop:aspect>
</aop:config>
```
三.声明通知

基于Schema方式支持前边介绍的5中通知类型：

1、前置通知：在切入点选择的方法之前执行，通过<aop:aspect>标签下的<aop:before>标签声明：
```
<aop:before pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"
　　method="前置通知实现方法名" 
　　arg-names="前置通知实现方法参数列表参数名字"/>
```
pointcut和pointcut-ref：二者选一，指定切入点；

method：指定前置通知实现方法名，如果是多态需要加上参数类型，多个用“，”隔开，如beforeAdvice(java.lang.String)；

arg-names：指定通知实现方法的参数名字，多个用“，”分隔，可选，类似于【3.1.2 构造器注入】中的参数名注入限制：

在class文件中没生成变量调试信息是获取不到方法参数名字的，因此只有在类没生成变量调试信息时才需要使用arg-names属性来指定参数名，

如arg-names="param"表示通知实现方法的参数列表的第一个参数名字为“param”。

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：
```
public void sayBefore(String param);
```
其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现
```
@Override
public void sayBefore(String param) {
　　System.out.println("============say " + param);
}
```
第三在cn.javass.spring.chapter6.aop. HelloWorldAspect定义通知实现：
```
public void beforeAdvice(String param) {
　　System.out.println("===========before advice param:" + param);
}
```
最后在chapter6/advice.xml配置文件中进行如下配置：
```
<bean id="helloWorldService" class="cn.javass.spring.chapter6.service.impl.HelloWorldService"/>
<bean id="aspect" class="cn.javass.spring.chapter6.aop.HelloWorldAspect"/>
<aop:config>
　　<aop:aspect ref="aspect">
　　　　<aop:before pointcut="execution(* cn.javass..*.sayBefore(..)) and args(param)" method="beforeAdvice(java.lang.String)" arg-names="param"/>
</aop:aspect>
</aop:config>
```
测试代码cn.javass.spring.chapter6.AopTest:
```
@Test
public void testSchemaBeforeAdvice(){
　　　System.out.println("======================================");
     ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
     IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);
　　　helloworldService.sayBefore("before");
     System.out.println("======================================");
}
```
将输入：
```
==========================================
===========before advice param:before
============say before
==========================================
```
分析一下：

1）切入点匹配：在配置中使用“execution(* cn.javass..*.sayBefore(..)) ”匹配目标方法sayBefore，且使用“args(param)”匹配目标方法只有一个参数且传入的参数类型为通知实现方法中同名的参数类型；

2）目标方法定义：使用method=" beforeAdvice(java.lang.String) "指定前置通知实现方法，且该通知有一个参数类型为java.lang.String参数；

3）目标方法参数命名：其中使用arg-names=" param "指定通知实现方法参数名为“param”，切入点中使用“args(param)”匹配的目标方法参数将自动传递给通知实现方法同名参数。

2、后置返回通知：在切入点选择的方法正常返回时执行，通过<aop:aspect>标签下的<aop:after-returning>标签声明：
```
<aop:after-returning pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"
　　method="后置返回通知实现方法名" 
　　arg-names="后置返回通知实现方法参数列表参数名字"
　　returning="返回值对应的后置返回通知实现方法参数名"
/>
```
pointcut和pointcut-ref：同前置通知同义；

method：同前置通知同义；

arg-names：同前置通知同义；

returning：定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法执行正常返回后，将把目标方法返回值传给通知方法；

returning限定了只有目标方法返回值匹配与通知方法相应参数类型时才能执行后置返回通知，否则不执行，对于returning对应的通知方法参数为Object类型将匹配任何目标返回值。

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：
```
public boolean sayAfterReturning();
```
其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现
```
@Override
public boolean sayAfterReturning() {
    System.out.println("============after returning");
    return true;
}
```
第三在cn.javass.spring.chapter6.aop. HelloWorldAspect定义通知实现：
```
public void afterReturningAdvice(Object retVal) {
    System.out.println("===========after returning advice retVal:" + retVal);
}
```
最后在chapter6/advice.xml配置文件中接着前置通知配置的例子添加如下配置：
```
<aop:after-returning pointcut="execution(* cn.javass..*.sayAfterReturning(..))" method="afterReturningAdvice" arg-names="retVal" returning="retVal"/>
```
测试代码cn.javass.spring.chapter6.AopTest:
```
@Test
public void testSchemaAfterReturningAdvice() {
　　 System.out.println("======================================");
　　 ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
　　 IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);
    helloworldService.sayAfterReturning();    System.out.println("======================================");
}
```
将输入：
```
======================================
============after returning
===========after returning advice retVal:true
======================================
```
分析一下：

1）切入点匹配：在配置中使用“execution(* cn.javass..*.sayAfterReturning(..)) ”匹配目标方法sayAfterReturning，该方法返回true；

2）目标方法定义：使用method="afterReturningAdvice"指定后置返回通知实现方法；

3）目标方法参数命名：其中使用arg-names="retVal"指定通知实现方法参数名为“retVal”；

4）返回值命名：returning="retVal"用于将目标返回值赋值给通知实现方法参数名为“retVal”的参数上。

3、后置异常通知：在切入点选择的方法抛出异常时执行，通过<aop:aspect>标签下的<aop:after-throwing>标签声明：
```
<aop:after-throwing pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"
　　method="后置异常通知实现方法名" 
　　arg-names="后置异常通知实现方法参数列表参数名字"
　　throwing="将抛出的异常赋值给的通知实现方法参数名"/>
```
pointcut和pointcut-ref：同前置通知同义；

method：同前置通知同义；

arg-names：同前置通知同义；

throwing：定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法抛出异常返回后，将把目标方法抛出的异常传给通知方法；

throwing限定了只有目标方法抛出的异常匹配与通知方法相应参数异常类型时才能执行后置异常通知，否则不执行，对于throwing对应的通知方法参数为Throwable类型将匹配任何异常。

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：
```
public void sayAfterThrowing();
```
其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现
```
@Override
public void sayAfterThrowing() {
    System.out.println("============before throwing");
    throw new RuntimeException();
}
```
第三在cn.javass.spring.chapter6.aop. HelloWorldAspect定义通知实现：
```
public void afterThrowingAdvice(Exception exception) {
  System.out.println("===========after throwing advice exception:" + exception);
}
```
最后在chapter6/advice.xml配置文件中接着前置通知配置的例子添加如下配置：
```
<aop:after-throwing pointcut="execution(* cn.javass..*.sayAfterThrowing(..))" method="afterThrowingAdvice" arg-names="exception" throwing="exception"/>
```
测试代码cn.javass.spring.chapter6.AopTest:
```
@Test(expected = RuntimeException.class)
public void testSchemaAfterThrowingAdvice() {
    System.out.println("======================================");
　　 ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
　　 IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);
    helloworldService.sayAfterThrowing();    System.out.println("======================================");
}
```
将输入：
```
======================================
============before throwing
===========after throwing advice exception:java.lang.RuntimeException
======================================
```
分析一下吧：

1）切入点匹配：在配置中使用“execution(* cn.javass..*.sayAfterThrowing(..))”匹配目标方法sayAfterThrowing，该方法将抛出RuntimeException异常；

2）目标方法定义：使用method="afterThrowingAdvice"指定后置异常通知实现方法；

3）目标方法参数命名：其中使用arg-names="exception"指定通知实现方法参数名为“exception”；

4）异常命名：returning="exception"用于将目标方法抛出的异常赋值给通知实现方法参数名为“exception”的参数上。

4、后置最终通知：在切入点选择的方法返回时执行，不管是正常返回还是抛出异常都执行，通过<aop:aspect>标签下的<aop:after >标签声明：
```
<aop:after pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"
　　method="后置最终通知实现方法名" 
　　arg-names="后置最终通知实现方法参数列表参数名字"/>
```
pointcut和pointcut-ref：同前置通知同义；

method：同前置通知同义；

arg-names：同前置通知同义；

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：
```
public boolean sayAfterFinally();
```
其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现
```
　　 @Override
    public boolean sayAfterFinally() {
        System.out.println("============before finally");
        throw new RuntimeException();
}
```
第三在cn.javass.spring.chapter6.aop. HelloWorldAspect定义通知实现：
```
public void afterFinallyAdvice() {
        System.out.println("===========after finally advice");
}
```
最后在chapter6/advice.xml配置文件中接着前置通知配置的例子添加如下配置：
```
<aop:after pointcut="execution(* cn.javass..*.sayAfterFinally(..))" method="afterFinallyAdvice"/>
```
测试代码cn.javass.spring.chapter6.AopTest:
```
@Test(expected = RuntimeException.class)
public void testSchemaAfterFinallyAdvice() {
    System.out.println("======================================");
    ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
    IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);
    helloworldService.sayAfterFinally();
    System.out.println("======================================");
}
```
将输入：
```
======================================
============before finally
===========after finally advice
======================================
```
分析一下：

1）切入点匹配：在配置中使用“execution(* cn.javass..*.sayAfterFinally(..))”匹配目标方法sayAfterFinally，该方法将抛出RuntimeException异常；

2）目标方法定义：使用method=" afterFinallyAdvice "指定后置最终通知实现方法。

5、环绕通知：环绕着在切入点选择的连接点处的方法所执行的通知，环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，

执行时是否需要替换方法参数，执行完毕是否需要替换返回值，可通过<aop:aspect>标签下的<aop:around >标签声明：
```
<aop:around pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"
　　method="后置最终通知实现方法名" 
　　arg-names="后置最终通知实现方法参数列表参数名字"/>
```
pointcut和pointcut-ref：同前置通知同义；

method：同前置通知同义；

arg-names：同前置通知同义；

环绕通知第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型，在通知实现方法内部使用ProceedingJoinPoint的proceed()方法使目标方法执行，

proceed 方法可以传入可选的Object[]数组，该数组的值将被作为目标方法执行时的参数。

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：
```
public void sayAround(String param);
```
其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现
```
@Override
public void sayAround(String param) {
   System.out.println("============around param:" + param);
}
```
第三在cn.javass.spring.chapter6.aop. HelloWorldAspect定义通知实现：
```
public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("===========around before advice");
    Object retVal = pjp.proceed(new Object[] {"replace"});
　　 System.out.println("===========around after advice");
    return retVal;
}
```
最后在chapter6/advice.xml配置文件中接着前置通知配置的例子添加如下配置：
```
<aop:around pointcut="execution(* cn.javass..*.sayAround(..))" method="aroundAdvice"/>
```
测试代码cn.javass.spring.chapter6.AopTest:
```
@Test
public void testSchemaAroundAdvice() {
　　 System.out.println("======================================");
　　 ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
　　 IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);
    helloworldService.sayAround("haha");    
    System.out.println("======================================");
}
```
将输入：
```
======================================
===========around before advice
============around param:replace
===========around after advice
======================================
```
分析一下：

1）切入点匹配：在配置中使用“execution(* cn.javass..*.sayAround(..))”匹配目标方法sayAround；

2）目标方法定义：使用method="aroundAdvice"指定环绕通知实现方法，在该实现中，第一个方法参数为pjp，类型为ProceedingJoinPoint，

其中“Object retVal = pjp.proceed(new Object[] {"replace"});”，用于执行目标方法，且目标方法参数被“new Object[] {"replace"}”替换，最后返回“retVal ”返回值。

3）测试：我们使用“helloworldService.sayAround("haha");”传入参数为“haha”，但最终输出为“replace”，说明参数被替换了。

四.引入

Spring引入允许为目标对象引入新的接口，通过在< aop:aspect>标签内使用< aop:declare-parents>标签进行引入，定义方式如下：
```
<aop:declare-parents
 　　types-matching="AspectJ语法类型表达式"                 
    implement-interface=引入的接口"                              
    default-impl="引入接口的默认实现"
    delegate-ref="引入接口的默认实现Bean引用"/>
```
types-matching：匹配需要引入接口的目标对象的AspectJ语法类型表达式；

implement-interface：定义需要引入的接口；

default-impl和delegate-ref：定义引入接口的默认实现，二者选一，default-impl是接口的默认实现类全限定名，而delegate-ref是默认的实现的委托Bean名；

首先定义引入的接口及默认实现：
```
package cn.javass.spring.chapter6.service;
public interface IIntroductionService {
    public void induct();
}
```
```
package cn.javass.spring.chapter6.service.impl;
import cn.javass.spring.chapter6.service.IIntroductionService;

public class IntroductiondService implements IIntroductionService {
    @Override
    public void induct() {
        System.out.println("=========introduction");
    }
}
```
其次在chapter6/advice.xml配置文件中接着前置通知配置的例子添加如下配置：
```
<aop:declare-parents
 　　types-matching="cn.javass..*.IHelloWorldService+"                               
    implement-interface="cn.javass.spring.chapter6.service.IIntroductionService"                             
    default-impl="cn.javass.spring.chapter6.service.impl.IntroductiondService"/>
```
最后测试一下吧，测试代码cn.javass.spring.chapter6.AopTest：
```
@Test
public void testSchemaIntroduction() {
     System.out.println("======================================");
　　  ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
     IIntroductionService introductionService = ctx.getBean("helloWorldService", IIntroductionService.class);
     introductionService.induct();    System.out.println("======================================");
}
```
将输入：
```
======================================
=========introduction
======================================
```
分析一下：

1）目标对象类型匹配：使用types-matching="cn.javass..*.IHelloWorldService+"匹配IHelloWorldService接口的子类型，如HelloWorldService实现；

2）引入接口定义：通过implement-interface属性表示引入的接口，如“cn.javass.spring.chapter6.service.IIntroductionService”。

3）引入接口的实现：通过default-impl属性指定，如“cn.javass.spring.chapter6.service.impl.IntroductiondService”，也可以使用“delegate-ref”来指定实现的Bean。

4）获取引入接口：如使用“ctx.getBean("helloWorldService", IIntroductionService.class);”可直接获取到引入的接口。

五.Advisor

Advisor表示只有一个通知和一个切入点的切面，由于Spring AOP都是基于AOP联盟的拦截器模型的环绕通知的，

所以引入Advisor来支持各种通知类型（如前置通知等5种），Advisor概念来自于Spring1.2对AOP的支持，在AspectJ中没有相应的概念对应。

Advisor可以使用<aop:config>标签下的<aop:advisor>标签定义：
```
<aop:advisor pointcut="切入点表达式" pointcut-ref="切入点Bean引用"
   advice-ref="通知API实现引用"/>
```
pointcut和pointcut-ref：二者选一，指定切入点表达式；

advice-ref：引用通知API实现Bean，如前置通知接口为MethodBeforeAdvice；

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：
```
public void sayAdvisorBefore(String param);
```
其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现
```
@Override
public void sayAdvisorBefore(String param) {
　　System.out.println("============say " + param);
}
```
第三定义前置通知API实现：
```
package cn.javass.spring.chapter6.aop;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class BeforeAdviceImpl implements MethodBeforeAdvice {
　　@Override
　　public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("===========before advice");
    }
}
```
在chapter6/advice.xml配置文件中先添加通知实现Bean定义：
```
<bean id="beforeAdvice" class="cn.javass.spring.chapter6.aop.BeforeAdviceImpl"/>
```
然后在<aop:config>标签下，添加Advisor定义，添加时注意顺序：
```
<aop:advisor pointcut="execution(* cn.javass..*.sayAdvisorBefore(..))" advice-ref="beforeAdvice"/>
```
测试代码cn.javass.spring.chapter6.AopTest:
```
@Test
public void testSchemaAdvisor() {
   System.out.println("======================================");
   ApplicationContext ctx =new ClassPathXmlApplicationContext("chapter6/advice.xml");
   IHelloWorldService helloworldService =ctx.getBean("helloWorldService", IHelloWorldService.class);
   helloworldService.sayAdvisorBefore("haha");        System.out.println("======================================");
}
```
将输入：
```
======================================
===========before advice
============say haha
======================================
```
不推荐使用Advisor，除了在进行事务控制的情况下，其他情况一般不推荐使用该方式，该方式属于侵入式设计，必须实现通知API。
相关阅读:
vivo手机上的系统级消息推送平台的架构设计实践
 基于Netty，从零开发IM(二)：编码实践篇（im单聊功能）
基于Netty，从零开发IM(三)：编码实践篇（群聊功能）
【前端】Windows升级nodejs到最新版本
 【Nginx】Linux上安装Nginx详细教程（保姆级教程）
【MySQL】在Win10上安装MySQL压缩包安装版
 【SQL】批量操作：批量插入、删除
 【SQL】查询存在于一个表而不存在于另外一个表的数据
 Java开发学习(十)基于注解开发定义bean
Java开发学习(十一)基于注解开发bean作用范围与生命周期管理
原文地址：https://www.cnblogs.com/ZJOE80/p/12849483.html

关于Spring——AOP（二）

基于Schema的AOP

一.声明切面

二.声明切入点

三.声明通知

四.引入

五.Advisor