SpringAOP基础以及四种实现方式

首先。AOP 面向切面编程。

就是说通过配置将业务逻辑和系统的服务分离。目的是让业务逻辑之关系业务的处理而不再去处理其他事情。其中切面一般都是哪些可以为多个类提供服务的模块，将其封装起来称为切面。减少系统的重复代码和低模块之间的耦合度。一般用于权限验证、日志、事务等。

拦截器也是应用了AOP的思想，将拦截（请求）Action以进行一些预处理或者结果处理。Spring的AOP可以拦截Spring管理的bean。

AOP主要是通过动态代理和反射机制实现的。

Spring代理实际上是对JDK代理和CGLIB代理做了一层封装，并且引入了AOP概念:Aspect、advice、joinpoint等等，同时引入了AspectJ中的一些注解@pointCut,@after,@before等等.Spring Aop严格的来说都是动态代理，所以实际上Spring代理和Aspectj的关系并不大.

基础概念

通知（Advice）
定义了切入点代码执行时间点附近需要做的工作。

切入点：
@Before org.apringframework.aop.MethodBeforeAdvice
@After-returning(返回后) org.springframework.aop.AfterReturningAdvice
@After-throwing(抛出后) org.springframework.aop.ThrowsAdvice
@Arround周围 org.aopaliance.intercept.MethodInterceptor
@Introduction引入 org.springframework.aop.IntroductionInterceptor
2. 连接点（Joinpoint）
程序能够应用通知的一个时机。这些时机就是连接点。比如方法调用时、异常抛出时、方法返回后等。
3. 切入点（Pointcut）
通知定义了切面要发生的故事，连接点定义了故事要发生的时机，而切入点定义了故事发生的地点，例如某个类or方法的名称。Spring中允许我们用正则表达式来指定。

切面（Aspect）
Advice Joinpoint Pointcut共同组成了切面：要发生的故事、时间、地点
引入（Introduction）
引入允许我们向现有的类添加新的方法和属性。
Spring中的方法注入的功能。
目标（Target）
就是被通知的对象。
如果没有AOP，通知的逻辑就要写在目标对象中。有了AOP之后他可以只关注自己要做的事情，解耦。
代理（Proxy）
应用通知的对象。
织入（Weaving）
把切面应用到目标对象来创建新的代理对象的过程。
织入一般发生在以下几个时机：
一 编译时：AspectJ的织入编译器
二 类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码。
三 运行时 ：切面在运行的某一个时刻被织入，SpringAOP就是运行时织入切面的。（JDK的动态代理技术）

使用AOP的几种方式：

经典的基于代理的AOP
@AspectJ注解驱动的切面
纯POJO切面
注入式AspectJ切面

举一个例子：
Me类是实现了Sleepable的接口，重写了其中的sleep方法。

基于代理的AOP

由于Me完成了sleep的逻辑，但是其他睡觉需要的功能，例如起床穿衣服，睡前脱衣服都可以由AOP代替“Me”执行。实现解耦。
那么我们就可以通过SleepHelper类

public class SleepHelper implements MethodBeforeAdvice, AfterReturningAdvice {  public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {  System.out.println("睡觉前要脱衣服！");  }  public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {  System.out.println("起床后要穿衣服！");  }  }

Spring配置文件 application.xml配置AOP

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
<span style="white-space:pre">    </span>xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<span style="white-space:pre">    </span>xmlns:aop="http://www.springframework.org/schema/aop"
<span style="white-space:pre">    </span>xsi:schemaLocation="http://www.springframework.org/schema/beans
<span style="white-space:pre">    </span>http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
<span style="white-space:pre">    </span>http://www.springframework.org/schema/aop
<span style="white-space:pre">    </span>http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">  <!-- 定义被代理者 -->  <bean id="me" class="com.springAOP.bean.Me"></bean>  <!-- 定义通知内容，也就是切入点执行前后需要做的事情 -->  <bean id="sleepHelper" class="com.springAOP.bean.SleepHelper"></bean>  <!-- 定义切入点位置 -->  <bean id="sleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">  <property name="pattern" value=".*sleep"></property>  </bean>  <!-- 使切入点与通知相关联，完成切面配置 -->  <bean id="sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">  <property name="advice" ref="sleepHelper"></property>         <property name="pointcut" ref="sleepPointcut"></property>  </bean>  <!-- 设置代理 -->  <bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">  <!-- 代理的对象，有睡觉能力 -->  <property name="target" ref="me"></property>  <!-- 使用切面 -->  <property name="interceptorNames" value="sleepHelperAdvisor"></property>  <!-- 代理接口，睡觉接口 -->  <property name="proxyInterfaces" value="com.springAOP.bean.Sleepable"></property>   </bean>  </beans>

其中配置标签中的几个重要属性

xmlns：是默认的xml文档解析格式，即spring的beans。地址是http://www.springframework.org/schema/beans；通过设置这个属性，所有在beans里面声明的属性，可以直接通过<>来使用，比如<bean>等等。一个XML文件，只能声明一个默认的语义解析的规范。例如上面的xml中就只有beans一个是默认的，其他的都需要通过特定的标签来使用，比如aop，它自己有很多的属性，如果要使用，前面就必须加上aop:xxx才可以。类似的，如果默认的xmlns配置的是aop相关的语义解析规范，那么在xml中就可以直接写config这种标签了。xmlns:xsi：是xml需要遵守的规范，通过URL可以看到，是w3的统一规范，后面通过xsi:schemaLocation来定位所有的解析文件。xmlns:aop：这个是重点，是我们这里需要使用到的一些语义规范，与面向切面AOP相关。xmlns:tx:Spring中与事务相关的配置内容。

测试：通过AOP代理的方式执行Me的sleep()方法，会把执行前、执行后的操作执行，实现了AOP的效果！

public class Test {  public static void main(String[] args){  @SuppressWarnings("resource")  //如果是web项目，则使用注释的代码加载配置文件，这里是一般的Java项目，所以使用下面的方式  //ApplicationContext appCtx = new ClassPathXmlApplicationContext("application.xml");  ApplicationContext appCtx = new FileSystemXmlApplicationContext("application.xml");  Sleepable me = (Sleepable)appCtx.getBean("proxy");  me.sleep();  }
}

然后我们其实可以通org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator简化配置。

<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>

在Test中就可以直接获取me对象，执行sleep方法。自动匹配，切面会自动匹配符合切入点的bean，会被自动代理，实现功能。

AspectJ提供的注解实现AOP

AspactJ框架常用注解：
@PonitCut // 声明切入点的注解
@Before // 声明前置通知注解
@After // 声明后置通知注解(原始方法执行正常或者非正常执行都会进入)
@AfterReturing //声明后置通知注解(原始方法必须正常执行)
@AfterThrowing // 声明异常通知
@Around // 环绕通知注解

修改SleepHelper类

@Aspect
public class SleepHelper{  public SleepHelper(){  }  @Pointcut("execution(* *.sleep())")  public void sleeppoint(){}  @Before("sleeppoint()")  public void beforeSleep(){  System.out.println("睡觉前要脱衣服!");  }  @AfterReturning("sleeppoint()")  public void afterSleep(){  System.out.println("睡醒了要穿衣服！");  }  }

在方法中，可以加上JoinPoint参数以进行相关操作，如：

//当抛出异常时被调用
public void doThrowing(JoinPoint point, Throwable ex)
{
System.out.println(“doThrowing::method "
+ point.getTarget().getClass().getName() + “.”
+ point.getSignature().getName() + " throw exception”);
System.out.println(ex.getMessage());
}
然后修改配置为：

<aop:aspectj-autoproxy />
<!-- 定义通知内容，也就是切入点执行前后需要做的事情 -->
<bean id="sleepHelper" class="com.springAOP.bean.SleepHelper"></bean>
<!-- 定义被代理者 -->
<bean id="me" class="com.springAOP.bean.Me"></bean>

测试

public class Test {
public static void main(String[] args){
@SuppressWarnings(“resource”)
//如果是web项目，则使用注释的代码加载配置文件，这里是一般的Java项目，所以使用下面的方式
//ApplicationContext appCtx = new ClassPathXmlApplicationContext(“application.xml”);
ApplicationContext appCtx = new FileSystemXmlApplicationContext(“application.xml”);
Sleepable me = (Sleepable)appCtx.getBean(“me”);
me.sleep();
}
}

Pojo切面

使用Spring来定义纯粹的POJO切面
（名字很绕口，其实就是纯粹通过aop:fonfig标签配置，也是一种比较简单的方式）。

修改SleepHelper类，所以这种方式的优点就是在代码中不体现任何AOP相关配置，纯粹使用xml配置。

public class SleepHelper{

 public void beforeSleep(){  System.out.println("睡觉前要脱衣服!");  }  public void afterSleep(){  System.out.println("睡醒了要穿衣服！");  }

}

配置文件

<?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 id="sleepHelper" class="com.springAOP.bean.SleepHelper"></bean>  <!-- 定义被代理者 -->  <bean id="me" class="com.springAOP.bean.Me"></bean>  <aop:config>  <aop:aspect ref="sleepHelper">  <aop:before method="beforeSleep" pointcut="execution(* *.sleep(..))" />  <aop:after method="afterSleep" pointcut="execution(* *.sleep(..))" />  </aop:aspect>  </aop:config>  </beans>

另一种配置写法

<aop:config>  <aop:aspect ref="sleepHelper">  <aop:pointcut id="sleepHelpers" expression="execution(* *.sleep(..))" />  <aop:before pointcut-ref="sleepHelpers" method="beforeSleep" />  <aop:after pointcut-ref="sleepHelpers" method="afterSleep" />            </aop:aspect>
</aop:config>

转自：https://blog.csdn.net/summer_yuxia/article/details/75104949