Spring AOP面向方面编程原理：AOP概念

AOP(Aspect Oriented Programming) 也就是面向方面编程的技术 AOP基于IoC基础 是对OOP的有益补充

AOP将应用系统分为两部分 核心业务逻辑（Core business concerns）及横向的通用逻辑 也就是所谓的方面Crosscutting enterprise concerns 例如 所有大中型应用都要涉及到的持久化管理（Persistent） 事务管理（Transaction Management） 安全管理（Security） 日志管理（Logging）和调试管理（Debugging）等

AOP正在成为软件开发的下一个光环 使用AOP 你可以将处理aspect的代码注入主程序 通常主程序的主要目的并不在于处理这些aspect AOP可以防止代码混乱

Spring framework是很有前途的AOP技术 作为一种非侵略性的 轻型的AOP framework 你无需使用预编译器或其他的元标签 便可以在Java程序中使用它 这意味着开发团队里只需一人要对付AOP framework 其他人还是像往常一样编程

AOP概念

让我们从定义一些重要的AOP概念开始

— 方面（Aspect） 一个关注点的模块化 这个关注点实现可能另外横切多个对象 事务管理是J EE应用中一个很好的横切关注点例子 方面用Spring的Advisor或拦截器实现

— 连接点（Joinpoint） 程序执行过程中明确的点 如方法的调用或特定的异常被抛出

— 通知（Advice） 在特定的连接点 AOP框架执行的动作 各种类型的通知包括 around before 和 throws 通知 通知类型将在下面讨论 许多AOP框架包括Spring都是以拦截器做通知模型 维护一个 围绕 连接点的拦截器链

— 切入点（Pointcut） 指定一个通知将被引发的一系列连接点的集合 AOP框架必须允许开发者指定切入点 例如 使用正则表达式

— 引入（Introduction） 添加方法或字段到被通知的类 Spring允许引入新的接口到任何被通知的对象 例如 你可以使用一个引入使任何对象实现IsModified接口 来简化缓存

— 目标对象（Target Object） 包含连接点的对象 也被称作被通知或被代理对象

— AOP代理（AOP Proxy） AOP框架创建的对象 包含通知 在Spring中 AOP代理可以是JDK动态代理或CGLIB代理

— 编织（Weaving） 组装方面来创建一个被通知对象 这可以在编译时完成（例如使用AspectJ编译器） 也可以在运行时完成 Spring和其他纯Java AOP框架一样 在运行时完成织入

各种通知类型包括

—  Around通知 包围一个连接点的通知 如方法调用 这是最强大的通知 Aroud通知在方法调用前后完成自定义的行为 它们负责选择继续执行连接点或通过返回它们自己的返回值或抛出异常来短路执行

—  Before通知 在一个连接点之前执行的通知 但这个通知不能阻止连接点前的执行（除非它抛出一个异常）

—  Throws通知 在方法抛出异常时执行的通知 Spring提供强制类型的Throws通知 因此你可以书写代码捕获感兴趣的异常（和它的子类） 不需要从Throwable或Exception强制类型转换

—  After returning通知 在连接点正常完成后执行的通知 例如 一个方法正常返回 没有抛出异常

Around通知是最通用的通知类型 大部分基于拦截的AOP框架（如Nanning和Jboss ）只提供Around通知

如同AspectJ Spring提供所有类型的通知 我们推荐你使用最为合适的通知类型来实现需要的行为 例如 如果只是需要用一个方法的返回值来更新缓存 你最好实现一个after returning通知 而不是around通知 虽然around通知也能完成同样的事情 使用最合适的通知类型使编程模型变得简单 并能减少潜在错误 例如 你不需要调用在around通知中所需使用的MethodInvocation的proceed()方法 因此就调用失败

切入点的概念是AOP的关键 它使AOP区别于其他使用拦截的技术 切入点使通知独立于OO的层次选定目标 例如 提供声明式事务管理的around通知可以被应用到跨越多个对象的一组方法上 因此切入点构成了AOP的结构要素

下面让我们实现一个Spring AOP的例子 在这个例子中 我们将实现一个before advice 这意味着advice的代码在被调用的public方法开始前被执行 以下是这个before advice的实现代码

package ascenttech springaop test;

import java lang reflect Method;

import springframework aop MethodBeforeAdvice;

public class TestBeforeAdvice implements MethodBeforeAdvice {

public void before(Method m Object[] args Object target)

throws Throwable {

System out println( Hello world! (by

+ this getClass() getName()

+ ) );

}

}

接口MethodBeforeAdvice只有一个方法before需要实现 它定义了advice的实现 before方法共用 个参数 它们提供了相当丰富的信息 参数Method m是advice开始后执行的方法 方法名称可以用作判断是否执行代码的条件 Object[] args是传给被调用的public方法的参数数组 当需要记日志时 参数args和被执行方法的名称都是非常有用的信息 你也可以改变传给m的参数 但要小心使用这个功能 编写最初主程序的程序员并不知道主程序可能会和传入参数的发生冲突 Object target是执行方法m对象的引用

在下面的BeanImpl类中 每个public方法调用前 都会执行advice 代码如下

package ascenttech springaop test;

public class BeanImpl implements Bean {

public void theMethod() {

System out println(this getClass() getName()

+ + new Exception() getStackTrace()[ ] getMethodName()

+ ()

+ says HELLO! );

}

}

类BeanImpl实现了下面的接口Bean 代码如下

package ascenttech springaop test;

public interface Bean {

public void theMethod();

}

虽然不是必须使用接口 但面向接口而不是面向实现编程是良好的编程实践 Spring也鼓励这样做

pointcut和advice通过配置文件来实现 因此 接下来你只需编写主方法的Java代码 代码如下

package ascenttech springaop test;

import ntext ApplicationContext;

import ntext support FileSystemXmlApplicationContext;

public class Main {

public static void main(String[] args) {

//Read the configuration file

ApplicationContext ctx

= new FileSystemXmlApplicationContext( springconfig xml );

//Instantiate an object

Bean x = (Bean) ctx getBean( bean );

//Execute the public method of the bean (the test)

x theMethod();

}

}

我们从读入和处理配置文件开始 接下来马上要创建它 这个配置文件将作为粘合程序不同部分的 胶水 读入和处理配置文件后 我们会得到一个创建工厂ctx 任何一个Spring管理的对象都必须通过这个工厂来创建 对象通过工厂创建后便可正常使用

仅仅用配置文件便可把程序的每一部分组装起来 代码如下

<xml version= encoding= UTF >

<!DOCTYPE beans PUBLIC //SPRING//DTD BEAN//EN /dtd/spring beans dtd >

<beans>

<! CONFIG >

<bean id= bean class= springframework aop framework ProxyFactoryBean >

<property name= proxyInterfaces >

<value> ascenttech springaop test Bean</value>

</property>

<property name= target >

<ref local= beanTarget />

</property>

<property name= interceptorNames >

<list>

<value>theAdvisor</value>

</list>

</property>

</bean>

<! CLASS >

<bean id= beanTarget class= ascenttech springaop test BeanImpl />

<! ADVISOR >

<! Note: An advisor assembles pointcut and advice >

<bean id= theAdvisor class= springframework aop support RegexpMethod PointcutAdvisor >

<property name= advice >

<ref local= theBeforeAdvice />

</property>

<property name= pattern >

<value>\ ascenttech\ springaop\ test\ Bean\ theMethod</value>

</property>

</bean>

<! ADVICE >

<bean id= theBeforeAdvice class= ascenttech springaop test TestBefore Advice />

</beans>

个bean定义的次序并不重要 我们现在有了一个advice 一个包含了正则表达式pointcut的advisor 一个主程序类和一个配置好的接口 通过工厂ctx 这个接口返回自己本身实现的一个引用

BeanImpl和TestBeforeAdvice都是直接配置 我们用一个惟一的ID创建一个bean元素 并指定了一个实现类 这就是全部的工作

advisor通过Spring framework提供的一个RegexMethodPointcutAdvisor类来实现 我们用advisor的第一个属性来指定它所需的advice bean 第二个属性则用正则表达式定义了pointcut 确保良好的性能和易读性

最后配置的是bean 它可以通过一个工厂来创建 bean的定义看起来比实际上要复杂 bean是ProxyFactoryBean的一个实现 它是Spring framework的一部分 这个bean的行为通过以下的 个属性来定义

— 属性proxyInterface定义了接口类

— 属性target指向本地配置的一个bean 这个bean返回一个接口的实现

— 属性interceptorNames是惟一允许定义一个值列表的属性 这个列表包含所有需要在beanTarget上执行的advisor 注意 advisor列表的次序是非常重要的

lishixinzhi/Article/program/Java/hx/201311/26338

原理：sping aop是可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP 可以说也是这种目标的一种实现。

其原理的相关技术：

AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向切面编程。AOP（这里的AOP指的是面向切面编程思想，而不是Spring AOP）主要的的实现技术主要有Spring AOP和AspectJ。

AspectJ的底层技术是静态代理，即用一种AspectJ支持的特定语言编写切面，通过一个命令来编译，生成一个新的代理类，该代理类增强了业务类，这是在编译时增强，相对于下面说的运行时增强，编译时增强的性能更好。

Spring AOP采用的是动态代理，在运行期间对业务方法进行增强，所以不会生成新类，对于动态代理技术，Spring AOP提供了对JDK动态代理的支持以及CGLib的支持。

JDK动态代理只能为接口创建动态代理实例，而不能对类创建动态代理。需要获得被目标类的接口信息（应用Java的反射技术），生成一个实现了代理接口的动态代理类（字节码），再通过反射机制获得动态代理类的构造函数，利用构造函数生成动态代理类的实例对象，在调用具体方法前调用invokeHandler方法来处理。

控制反转（IOC）

（理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”）

1、Ioc—Inversion of Control：即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

2、谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象即由Ioc容器来控制对象的创建。

   谁控制谁？当然是IoC 容器控制了对象。

   控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

3、为何是反转，哪些方面反转了： 有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象。

  为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象,所以是反转。

哪些方面反转了？依赖对象的获取被反转了。     

      还是不明白没事，下面搞个简单案例来说就懂啦 ！！！

      例子：当我们在任何一个有实际开发意义的程序项目中，我们会使用很多类来描述他们特有的功能，并且通过类与类之间的相互协作来完成特定的业务逻辑。这个时候，每个类都需要负责管理与自己有交互的类的引用和依赖，代码将会变的异常难以维护和极高的高耦合。而IOC的出现正是用来解决这个问题，我们通过IOC将这些依赖对象的创建、协调工作交给spring容器去处理，每个对象值需要关注其自身的业务逻辑关系就可以了。在这样的角度上来看，获得依赖的对象的方式，进行了反转，变成了由spring容器控制对象如何获取外部资源（包括其他对象和文件资料等）。

总的来说：IOC就是通过在Xml配置文件里依赖注入来解决代码问题。

IOC的注入类型有几种？主要可以划分为三种：构造函数注入、属性注入和接口注入。Spring支持构造函数注入和属性注入

       

面向切面（AOP）

（面向切面编程，AOP其实只是OOP的补充而已，AOP基本上是通过代理机制实现的。）

        我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。   

         我们都知道 Java 是 OOP-面向对象编程的，它有自己的优势，也有自己的不足。比如说：在我们开发中，都会有一条业务主线（即客户的需求）。而我们要做的就是实现这个主线上的需求。我们在实现这些功能的时候，经常要干一些额外的不可避免的事情，比如事务的管理，日志的记录等，就很繁杂且代码量增多，所以 Spring 提供了另一种角度来思考程序结构，也就是把这一些事情剥离出来，然后适时适地的把它们加入到我们的代码中，比如说 声明式事务管理的时候，我们在 service 层检测到save、update这些方法要被调用的时候，我们先进行开启事务什么的，这就是AOP，面向编程的思想。

      AOP的术语：

         1、通知（Advice）：就是你想要的功能，也就是上面说的 安全，事物，日志等。你给先定义好把，然后在想用的地方用一下

         2、连接点（JoinPoint）：这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点其他如aspectJ还可以让你在构造器或属性注入时都行，不过那不是咱关注的，只要记住，和方法有关的前前后后（抛出异常），都是连接点。

         3、切入点（Pointcut）：上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有几十个连接点了对把，但是你并不想在所有方法附近都使用通知（使用叫织入，以后再说），你只想让其中的几个，在调用这几个方法之前，之后或者抛出异常时干点什么，那么就用切点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。

         4、切面（Aspect）：切面是通知和切入点的结合。现在发现了吧，没连接点什么事情，连接点就是为了让你好理解切点，搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过方法名中的before,after，around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。

         5、引入（introduction）：允许我们向现有的类添加新方法属性。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗

         6、目标（target）：引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，他可以在毫不知情的情况下，被咱们织入切面。而自己专注于业务本身的逻辑。

         7、代理（proxy）：怎么实现整套aop机制的，都是通过代理，这个一会给细说。

         8、织入（weaving）：把切面应用到目标对象来创建新的代理对象的过程。有3种方式，spring采用的是运行时，为什么是运行时，后面解释。

在Spring的AOP模块，一个主要的部分是代理对象的生成，可以通过ProxyFactoryBean来完成，它封装了主要代理对象的生成过程。在这个生成过程中，可以使用JDK的Proxy和CGLIB两种生成情况。

Tip: 什么是匿名类

即没有名称的类，其名称由Java编译器给出，一般为：外部类名称+$+匿名类顺序，名称也就是其他地方不能引用，不能实例化，只用一次，当然也就不能有构造器。

在ProxyFactoryBean中，需要为target目标对象生成Proxy代理对象，从而为AOP横切面的编织做好准备。从FactoryBean中获取对象，是以getObject()方法作为入口完成的。在该方法中，首先对通知器链进行初始化，封装了一系列的拦截器，这些拦截器都要从配置中读取，然后为代理对象的生成做好准备。在生成代理对象时，因为Spring中有singleton类型和prototype类型这两种不同的Bean,所以要对代理对象的生成做一个区分。

首先为Proxy代理对象配置Advisor链，在initializeAdvisorChain()方法中执行。

在该方法中它会首先通过thisadvisorChainInitialized来判断通知器链是否已经初始化了，如果已经初始化了，就直接返回。其他情况下，通过 thisinterceptorNames 来要添加的通知器名，然后通过该名从IOC容器中取得的通知器加入到拦截器链中。

生成singleton的代理对象在getSingletonInstance()中完成

如果它还没有被创建，则lazily creating

在Spring代理目标target时，其实并不是直接创建一个目标target的对象实例的，而是通过一个TargetSource类型的对象对目标target进行封装，Spring Aop获取目标对象始终是通过 TargetSourcegetTarget() 方法进行的。

proxy（代理对象）代理的不是target,而是TargetSource

那么问题来了:为什么SpringAOP代理不直接代理target,而需要通过代理TargetSource(target的来源,其内部持有target),间接代理target呢

通常情况下,一个proxy(代理对象)只能代理一个target,每次方法调用的目标也是唯一固定的target。但是,如果让proxy代理TargetSource,可以使得每次方法调用的target实例都不同(当然也可以相同,这取决于TargetSource实现)。这种机制使得方法调用变得灵活,可以扩展出很多高级功能,如:target pool(目标对象池)、hot swap(运行时目标对象热替换),等等。

Spring内置了多种TargetSource

监听调用AdvisedSupportListener实现类的activated方法

具体的代理对象的生成，是在ProxyFactoryBean的基类AdvisedSupport的实现中借助AopProxyFactory完成的，这个代理对象要么从JDK中生成，要么借助CGLIB获得。

这个AopProxyFactory是在初始化函数中定义的，使用的是DefaultAopProxyFactor。

如果targetClass是接口类，使用JDK来生成Proxy

如果不是接口类要生成Proxy,那么使用CGLIB来生成。

接下来分别介绍两种不同的方式来产生AopProxy代理对象

首先从advised对象中取得代理对象的代理接口配置，然后调用Proxy的newProxyInstance方法，得到最终的Proxy代理对象。

在生成代理对象时，需要指明三个参数，类加载器，代理接口和Proxy回调方法所在的对象。

在回调方法所在对象中，需要实现InvocationHandler接口，它定义了invoke方法，

对于JdkDynamimcAopProxy，它本身实现了InvocationHandler接口和invoke方法，这个invoke方法是Proxy代理对象的回调方法。

在该篇文章中就不讲解了，感兴趣的可以百度搜索。

注：本文大多数是对《Spring技术内幕》的阅读整理。

访问目标方法最简单的做法是定义增强处理方法时，将第一个参数定义为JoinPoint类型，当该增强处理方法被调用时，该JoinPoint参数就代表了织入增强处理的连接点。JoinPoint里包含了如下几个常用的方法：Object[]getArgs：返回目标方法的参数SignaturegetSignature：返回目标方法的签名ObjectgetTarget：返回被织入增强处理的目标对象ObjectgetThis：返回AOP框架为目标对象生成的代理对象注意：当使用@Around处理时，我们需要将第一个参数定义为ProceedingJoinPoint类型，该类是JoinPoint的子类。

以上就是关于Spring AOP面向方面编程原理：AOP概念全部的内容，包括:Spring AOP面向方面编程原理：AOP概念、springaop原理、Java编程中的AOP和IOC分别是什么呢，什么时候用呢等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！