spring实战笔记_第4章

一、面向切面编程（AOP）

1.1问题：

图展现了一个被划分为模块的典型应用。每个模块的核心功能都是为特定业务领域提供服务，但是这些模块都需要类似的辅助功能，例如安全和事务管理。

如果要重用通用功能的话，最常见的面向对象技术是继承（inheritance）或委托（delegation）。但是，如果在整个应用中都使用相同的基类，继承往往会导致一个脆弱的对象体系；而使用委托可能需要对委托对象进行复杂的调用。

1.2横切关注点

在软件开发中，散布于应用中多处的功能被称为横切关注点（crosscuttingconcern），如日志，安全和缓存等。通常来讲，这些横切关注点从概念上是与应用的业务逻辑相分离的（但是往往会直接嵌入到应用的业务逻辑之中）。把这些横切关注点与业务逻辑相分离正是面向切面编程（AOP）所要解决的问题。横切关注点可以被描述为影响应用多处的功能。

 

1.3切面

切面提供了取代继承和委托的另一种可选方案，在使用面向切面编程时，我们仍然在一个地方定义通用功能，但是可以通过声明的方式定义这个功能要以何种方式在何处应用，而无需修改受影响的类。横切关注点可以被模块化为特殊的类，这些类被称为切面（aspect）。

这样做有两个好处：首先，现在每个关注点都集中于一个地方，而不是分散到多处代码中；其次，服务模块更简洁，因为它们只包含主要关注点（或核心功能）的代码，而次要关注点的代码被转移到切面中了。

切面有以下的成形术语：

（1）通知：

切面的工作被称为通知。通知定义了切面是什么以及何时使用。除了描述切面要完成的工作，通知还解决了何时执行这个工作的问题。它应该应用在某个方法被调用之前？之后？之前和之后都调用？还是只在方法抛出异常时调用？

 

Spring切面可以应用5种类型的通知：

l  前置通知（Before）：在目标方法被调用之前调用通知功能；

l  后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么；

l  返回通知（After-returning）：在目标方法成功执行之后调用通知；

l  异常通知（After-throwing）：在目标方法抛出异常后调用通知；

l  环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。

（2）连接点：

连接点是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。

（3）切点（多个连接点）

切点的定义会匹配通知所要织入的一个或多个连接点。我们通常使用明确的类和方法名称，或是利用正则表达式定义所匹配的类和方法名称来指定这些切点。

（4）切面

切面是通知和切点的结合。通知和切点共同定义了切面的全部内容——它是什么，在何时和何处完成其功能。

（5）引入

引入允许我们向现有的类添加新方法或属性可以在无需修改这些现有的类的情况下，让它们具有新的行为和状态。

（6）织入

织入是把切面应用到目标对象并创建新的代理对象的过程。切面在指定的连接点被织入到目标对象中。在目标对象的生命周期里有多个点可以进行织入：

l  编译期：切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的。

l  类加载期：切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器（ClassLoader），它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ 5的加载时织入（load-timeweaving，LTW）就支持以这种方式织入切面。

l  运行期：切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。Spring AOP就是以这种方式织入切面的。（springAOP的织入方式）

 

二、spring中的aop

2.1 spring对aop的支持

AOP框架有很多种，各有不同，目前只介绍spring中的AOP支持Spring提供了4种类型的AOP支持：

（1）基于代理的经典Spring AOP；

较为繁琐，略去不讲。

（2）纯POJO切面；

借助Spring的aop命名空间，我们可以将纯POJO转换为切面。实际上，这些POJO只是提供了满足切点条件时所要调用的方法。遗憾的是，这种技术需要XML配置，但这的确是声明式地将对象转换为切面的简便方式。

（3）@AspectJ注解驱动的切面；

Spring借鉴了AspectJ的切面，以提供注解驱动的AOP。本质上，它依然是Spring基于代理的AOP，但是编程模型几乎与编写成熟的AspectJ注解切面完全一致。这种AOP风格的好处在于能够不使用XML来完成功能。

（4）注入式AspectJ切面（适用于Spring各版本）。

加强版AOP：如果你的AOP需求超过了简单的方法调用（如构造器或属性拦截），那么你需要考虑使用AspectJ来实现切面。在这种情况下，上文所示的第四种类型能够帮助你将值注入到AspectJ驱动的切面中。

 

前三种都是Spring AOP实现的变体，Spring AOP构建在动态代理基础之上，因此，Spring对AOP的支持局限于方法拦截。

 

2.2 spring中AOP的关键点

（1）Spring通知是Java编写的

Spring所创建的通知都是用标准的Java类编写的。这样的话，我们就可以使用与普通Java开发一样的集成开发环境（IDE）来开发切面。而且，定义通知所应用的切点通常会使用注解或在Spring配置文件里采用XML来编写，这两种语法对于Java开发者来说都是相当熟悉的。AspectJ与之相反，通过特有的AOP语言，我们可以获得更强大和细粒度的控制，以及更丰富的AOP工具集。

（2）Spring在运行时通知对象（代理类就是切面）

通过在代理类中包裹切面，Spring在运行期把切面织入到Spring管理的bean中。

代理类封装了目标类，并拦截被通知方法的调用，再把调用转发给真正的目标bean。当代理拦截到方法调用时，在调用目标bean方法之前，会执行切面逻辑。Spring的切面由包裹了目标对象的代理类实现。代理类处理方法的调用，执行额外的切面逻辑，并调用目标方法。因为Spring运行时才创建代理对象，所以我们不需要特殊的编译器来织入Spring AOP的切面。

（3） Spring只支持方法级别的连接点

因为Spring基于动态代理，所以Spring只支持方法连接点。方法拦截可以满足绝大部分的需求。如果需要方法拦截之外的连接点拦截功能，那么我们可以利用Aspect来补充Spring AOP的功能。

 

三、切点

3.1.AspecctJ的切点表达式

在Spring AOP中，要使用AspectJ的切点表达式语言来定义切点。只有execution指示器是实际执行匹配的，而其他的指示器都是用来限制匹配的。这说明execution指示器是我们在编写切点定义时最主要使用的指示器。在此基础上，我们使用其他指示器来限制所匹配的切点。

3.2编写切点：

方法表达式以“*”号开始，表明了我们不关心方法返回值的类型。然后，我们指定了全限定类名和方法名。对于方法参数列表，我们使用两个点号（..）表明切点要选择任意的perform()方法，无论该方法的入参是什么。

（1）匹配特定的包

现在假设我们需要配置的切点仅匹配concert包。在此场景下，可以使用within()指示器来限制匹配。

注意：

我们使用了“&&”操作符把execution()和within()指示器连接在一起形成与（and）关系（切点必须匹配所有的指示器）。类似地，我们可以使用“||”操作符来标识或（or）关系，而使用“!”操作符来标识非（not）操作。因为“&”在XML中有特殊含义，所以在Spring的XML配置里面描述切点时，我们可以使用and来代替“&&”。同样，or和not可以分别用来代替“||”和“!”。

（2）在切点中选择bean

我们希望在执行Performance的perform()方法时应用通知，但限定bean的ID为woodstock。

在此场景下，切面的通知会被编织到所有ID不为woodstock的bean中

代码示例：

publicinterface Performance{

      //切面的切点

      public void perform();

}

//切点表达式

execution(*concert.Performance.perform(..))

 

四、定义切面

4.1使用注解创建切面

AspectJ面向注解的模型可以非常简便地通过少量注解把任意类转变为切面。

（1）注解

spring使用AspectJ注解来声明通知方法

@After 通知方法会在目标方法返回或抛出异常后调用

@AfterReturning通知方法会在目标方法返回后调用

@AfterThrowing通知方法会在目标方法抛出异常后调用

@Around 通知方法会将目标方法封装起来

@Before 通知方法会在目标方法调用之前执行

代码示例：

//定义切面

//Audience类依然是一个POJO。我们能够像使用其他的Java类那样调用它的方法，它的方法也能够独立地进行单元测试

@Aspect

//该注解表明Audience不仅仅是一个POJO，还是一个切面

//Spring的AspectJ自动代理仅仅使用@AspectJ作为创建切面的指导，切面依然是基于代理的。在本质上，它依然是Spring基于代理的切面。

public classAudience{

      //通过@Pointcut注解声明频繁使用的切点表达式

      @Pointcut("execution(**concert.Performance.perform(..))")

      //performance()方法的实际内容并不重要，在这里它实际上应该是空的。其实该方法本身只是一个标识，供@Pointcut注解依附。

      public void performance(){}

     

      @Before("performance()")

      public void silenceCellPhone(){

           System.out.println("Silencingcell phones");

      }

     

      @Before("execution(**concert.Performance.perform(..))")

      public void takeSeats(){

           System.out.println("Takingseats");

      }

     

      @AfterReturning("execution(**concert.Performance.perform(..))")

      public void applause(){

           System.out.println("CLAP CLAP....");

      }

     

      @AfterThrowing("execution(**concert.Performance.perform(..))")

      public void demandRefund(){

           System.out.println("Demanding arefund");

      }

}

（2）启用AspectJ注解的自动代理

//1.在JavaConfig中启用AspectJ注解的自动代理

@Configuration

@EnableAspectJAutoProxy//启动AspectJ自动代理

@ComponentScan

public classConcertConfig{

      //声明Audienc bean

      @Bean

      public Audience audience(){

           return new Audience();

      }

}

 

//2.使用XML来装配bean的话

<beans>

      <context:component-scanbase-package='concert'/>

      //启动AspectJ自动代理

      /*

      不管你是使用JavaConfig还是XML，AspectJ自动代理都会为使

      用@Aspect注解的bean创建一个代理，这个代理会围绕着所有该切面

      的切点所匹配的bean。

      */

      <aop:aspectj-autoproxy/>

      //声明Audienc bean

      <beanclass="concert.Audienc"/>

</beans>

（3）环绕通知

前置通知和后置通知有一些限制。具体来说，如果不使用成员变量存储信息的话，在前置通知和后置通知之间共享信息非常麻烦。

环绕通知是最为强大的通知类型。它能够让你所编写的逻辑将被通知的目标方法完全包装起来。实际上就像在一个通知方法中同时编写前置通知和后置通知。

代码示例：

@Aspect

public classAudience{

      //定义命名的切点

      @Pointcut("execution(**concert.Performance.perform(..))")

      public void performance(){}

     

      @Around("performance()")

      //接受ProceedingJoinPoint作为参数,在通知中通过它来调用被通知的方法.

      public voidwatchPerformance(ProceedingJoinPoint jp){

           try{

                 System.out.println("Silencingcell phones");

                 System.out.println("Takingseats");

                 jp.proceed();

                 //通知方法中可以做任何的事情，当要将控制权交给被通知的方法时，它需要调用ProceedingJoinPoint的proceed()方法。

                 //你可以不调用proceed()方法，从而阻塞对被通知方法的访问，与之类似，你也可以在通知中对它进行多次调用。

                 System.out.println("clapclap...");

           }catch(Throeable e){

                 System.out.println("demandinga refund");

           }
      }

}

（4）参数化通知：

代码示例：

//使用参数化的通知来记录磁道播放的次数

@Aspect

public classTrackCounter{

      private Map<Integer,Integer>trackCounts=

           newHashMap<Integer,Integer>>();

      //切点声明了要提供给通知方法的参数

      @Pointcut(

           "execution(*soundsystem.CompactDisc.playTrack(int))"+

           "&&args(trackNumber)")

           /*

           切点表达式中的args(trackNumber)限定符。

           它表明传递给playTrack()方法的int类型参数也会传递到通知中去。参数的名称trackNumber也与切点方法签名中的参数相匹配。

           */

      public void trackPlayed(int trackNumber){}

     

      @Before("trackPlayed(trackNumber)")

      //trackNumber代表磁道标号；trackCounts存储每个磁道的播放次数；

      public void countTrack(int trackNumber){

           intcurrentCount=getPlayCount(trackNumber);

           trackCounts.put(trackNumber,currentCount+1);

      }    

     

      public int getPlayCount(int trackNumber){

           returntrackCounts.containtsKey(trackNumber)?

                 trackCounts.get(TrackNumber):0;

      }

}

 

@Configuration

@EnableAspectJAutoProxy

public classTrackCounterConfig{

           @Bean

           public CompactDisc sgtPeppers(){

                 BlankDisc cd=new BlankDisc();

                 cd.setTitle("sgt……");

                 cd.setArtist("theBeeatles");

                 List<String> tracks=newArrayList<String>();

                 tracks.add("sgt");

                 tracks.add("with");

                 tracks.add("lucy");

                 tracks.add("getting");

                 cd.setTracks(tracks);

                 return cd;

           }

           @Bean

           public TrackCounter trackCounter(){

                 return new TrackCounter();

           }

}

单元测试：

（5）通过AOP引入新功能

开放类可以不用直接修改对象或类的定义就能够为对象或类增加新的方法。不过，Java并不是动态语言。一旦类编译完成了，我们就很难再为该类添加新的功能了。

利用被称为引入的AOP概念，切面可以为Spring bean添加新方法。

当引入接口的方法被调用时，代理会把此调用委托给实现了新接口的某个其他对象。实际上，一个bean的实现被拆分到了多个类中。

代码示例：

/将示例中的所有的Performance实现引入下面的Encoreable接口：

publicinterface Encoreable{

      //我们需要有一种方式将这个接口应用到Performance实现中

      void performEncore();

}

 

//借助于AOP的引入功能，我们可以不必在设计上妥协或者侵入性地改变现有的实现。

@Aspect

public classEncoreableIntroducer{

      //通过@DeclareParents注解，将Encoreable接口引入到Performance bean中。

      @DeclareParents(value="concert.Performance+",

                                                  defaultImpl=DefaultEncoreable.class)

      public static Encoreable encoreable;

      /*

      @DeclareParents注解由三部分组成：

      value属性指定了哪种类型的bean要引入该接口。在本例中，也

      就是所有实现Performance的类型。（标记符后面的加号表示

      是Performance的所有子类型，而不是Performance本身。）

      defaultImpl属性指定了为引入功能提供实现的类。在这里，

      我们指定的是DefaultEncoreable提供实现。

      @DeclareParents注解所标注的静态属性指明了要引入了接口。在这里，我们所引入的是Encoreable接口。

      */

}

4.2在XML中声明切面

（1）问题：

在Spring中，注解和自动代理提供了一种很便利的方式来创建切面。它非常简单，并且只涉及到最少的Spring配置。但是，面向注解的切面声明有一个明显的劣势：你必须能够为通知类添加注解。为了做到这一点，必须要有源码。

（2）AOP元素

在Spring的aop命名空间中，提供了多个元素用来在XML中声明切面，Spring的AOP配置元素能够以非侵入性的方式声明切面。

<aop:advisor>定义AOP通知器

<aop:after>定义AOP后置通知（不管被通知的方法是否执行成功）

<aop:afterreturning>定义AOP返回通知

<aop:afterthrowing>定义AOP异常通知

<aop:around>定义AOP环绕通知

<aop:aspect>定义一个切面

<aop:aspectjautoproxy>启用@AspectJ注解驱动的切面

<aop:before>定义一个AOP前置通知

<aop:config>顶层的AOP配置元素。大多数的<aop:*>元素必须包含在<aop:config>元素内

<aop:declareparents>以透明的方式为被通知的对象引入额外的接口

<aop:pointcut>定义一个切点

（3）xml配置aop

代码示例：

//使用xml配置AOP

//1.声明前置和后置通知

<aop:config>

//声明切面，引用audienceBean，该Bean实现了切面的功能

      <aop:aspectref="audience">

      //调用相应的方法

           <aop:before

                      pointcut="execution(**concert.Performance.perform(..))"

                       method="silenceCellPhones"/>

           <aop:before

                      pointcut="execution(**concert.Performance.perform(..))"

                      method="takeSeats"/>

           <aop:after-returning

                      pointcut="execution(**concert.Performance.perform(..))"

                      method="applause"/>

           <aop:after-throwing

                      pointcut="execution(**concert.Performance.perform(..))"

                      method="demandRefund"/>

          

           //定义重复声明的切点       

           <aop:pointcut

                            id="performance"

                            expression="execution(**concert.Performance.perform(..))"/>

           <aop:before

                      //引入切点

                      pointcut-ref="performance"

                      method="silenceCellPhones"/>

      </aop:aspect>

</aop:config>

 

（4）声明环绕通知

代码示例：

 

//声明环绕通知

/*

使用环绕通知，我们可以完成前置通知和后置通知所实现的相同功能，而

且只需要在一个方法中 实现。因为整个通知逻辑是在一个方法内实

现的，所以不需要使用成员变量保存状态。

*/

 

public classAudience{

     

      public voidwatchPerformance(ProceedingJoinPoint jp){

           try{

                 System.out.println("Silencingcell phones");

                 System.out.println("Takingseats");

                 jp.proceed();s

                 System.out.println("clapclap...");

           }catch(Throeable e){

                 System.out.println("demandinga refund");

           }

          

      }

}

 

<aop:config>

                 <aop:pointcut

                            id="performance"

                            expression="execution(**concert.Performance.perform(..))"/>

                 <aop:around

                            pointcut-ref="performance"

                            method="watchPerformance"/>

</aop:config>

（5）为通知传参数

代码示例：

//为通知传参数,trackCounter类同前面

 

<beans>

      <bean id="trackCounter"

                 class="soundsystem.TrackCounter"/>

      <bean id="cd"

                 class="soundsystem.TrackCounter">

           <property name="title"

                                       value="sgt"/>

           <property name="tracks"value="the beatles"/>

           <property name="tracks">

                 <list>

                      <value>sgt</value>

                      <value>with</value>

                      <value>lucy</value>

                      <value>getting</value>

                     

                 </list>

           </property>

      </bean>

     

      <aop:config>

           <aop:aspectref="trackCounter">

                 <aop:pointcutid="trackPlayed" expression=

                      "execution(*soundsystem.CompactDisc.playTrack(int))

                            andargs(trackNumber)"/>

                 <aop:before

                      pointcut-ref="trackPlayed"

                      method="countTrack"/>

           </aop:aspect>

      </aop:config>

     

</beans>

（6）通过切面引入新功能

//通过切面引入新的功能

 

<aop:aspect>

//<aop:declare-parents>声明了此切面所通知的bean要在它的对象层次结构中拥有新的父类型。

      <aop:declare-parents

           types-matching="concert.Performance+"

           implement-interface="concert.Encoreable"

           /*

           delegate-ref="encoreableDelegate"

           //delegate-ref属性引用了一个Springbean作为引入的委托。这需要在Spring上下文中存在一个ID为encoreableDelegate的bean。

           <beanid="encoreableDelegate"

                            class="concert.DefaultEncoreable"/>

           */

           default-impl="concert.DefaultEncoreable"/>

          

</aop:aspect>

 

4.3注入AspectJ切面【不常接触，暂略】

虽然SpringAOP能够满足许多应用的切面需求，但是与AspectJ相比，SpringAOP 是一个功能比较弱的AOP解决方案。AspectJ提供了SpringAOP所不能支持的许多类型的切点。

 

五、小结

AOP是面向对象编程的一个强大补充。通过AspectJ，我们现在可以把之前分散在应用各处的行为放入可重用的模块中。我们显示地声明在何处如何应用该行为。这有效减少了代码冗余，并让我们的类关注自身的主要功能。

Spring提供了一个AOP框架，让我们把切面插入到方法执行的周围。现在我们已经学会如何把通知织入前置、后置和环绕方法的调用中，以及为处理异常增加自定义的行为。