有了schema的支持，切面就和常规的Java对象一样被定义成application context中的一个bean。 　 对象的字段和方法提供了状态和行为信息，XML文件则提供了切入点和通知信息。

切面使用<aop:aspect>来声明，backing bean（支持bean）通过 ref 属性来引用：

<aop:config>
  <aop:aspect id="myAspect" ref="aBean">
    ...
  </aop:aspect>
</aop:config>

<bean id="aBean" class="...">
  ...
</bean>

切面的支持bean（上例中的"aBean"）可以象其他Spring bean一样被容器管理配置以及依赖注入。

一个命名切入点可以在<aop:config>元素中定义，这样多个切面和通知就可以共享该切入点。

一个描述service层中所有service执行的切入点可以定义如下：

<aop:config>

  <aop:pointcut id="businessService" 
        expression="execution（* com.xyz.myapp.service.*.*（..））"/>

</aop:config>

注意切入点表达式本身使用了与第 6.2 节 “@AspectJ支持”中描述的相同的AspectJ切入点表达式语言。 　 如果你在Java 5环境下使用基于schema的声明风格，可参考切入点表达式类型（@Aspects）中定义的命名切入点， 　 不过这个特性在JDK1.4及以下版本中是不可用的（因为依赖于Java 5中的AspectJ反射API）。所以在JDK 1.5中， 　 上面的切入点的另外一种定义形式如下： 　

<aop:config>

  <aop:pointcut id="businessService" 
        expression="com.xyz.myapp.SystemArchitecture.businessService（）"/>

</aop:config>

假定你有一个在第 6.2.3.3 节 “共享通用切入点定义”中 描述的SystemArchitecture切面。

在切面里面声明一个切入点和声明一个顶级的切入点非常类似：

<aop:config>

  <aop:aspect id="myAspect" ref="aBean">

    <aop:pointcut id="businessService" 
          expression="execution（* com.xyz.myapp.service.*.*（..））"/>
          
    ...
    
  </aop:aspect>

</aop:config>

几乎和@AspectJ切面中的一样，使用基于schema定义风格声明的切入点可以收集(collect) 连接点上下文。例如，下面的切入点收集'this'对象作为连接点上下文并传递它给通知：

<aop:config>

  <aop:aspect id="myAspect" ref="aBean">

    <aop:pointcut id="businessService" 
          expression="execution（* com.xyz.myapp.service.*.*（..）） &amp;&amp; this（service）"/>
    <aop:before pointcut-ref="businessService" method="monitor"/>
    ...
    
  </aop:aspect>

</aop:config>

通过包含匹配名字的参数，通知被声明来接收收集的连接点上下文：

public void monitor（Object service） {
    ...
}

当需要连接子表达式的时候，'&&'在XML中用起来非常不方便，所以关键字'and', 'or' 和 'not'可以分别用来代替'&&', '||' 和 '!'。例如，上面切入点更好的写法如下：

<aop:config>

  <aop:aspect id="myAspect" ref="aBean">

    <aop:pointcut id="businessService" 
          expression="execution（* com.xyz.myapp.service.*.*（..）） and this（service）"/>
    <aop:before pointcut-ref="businessService" method="monitor"/>
    ...
    
  </aop:aspect>

</aop:config>

注意这种方式定义的切入点通过XML id来查找，并且不能定义切入点参数。在基于schema的定义风格中 命名切入点支持较之@AspectJ风格受到了很多的限制。

和@AspectJ风格一样，基于schema的风格也支持5种通知类型并且两者具有同样的语义。

<aop:aspect id="beforeExample" ref="aBean">

    <aop:before 
      pointcut-ref="dataAccessOperation" 
      method="doAccessCheck"/>
          
    ...
    
</aop:aspect>

<aop:aspect id="beforeExample" ref="aBean">

    <aop:before 
      pointcut="execution（* com.xyz.myapp.dao.*.*（..））" 
      method="doAccessCheck"/>
          
    ...
    
</aop:aspect>

<aop:aspect id="afterReturningExample" ref="aBean">

    <aop:after-returning 
      pointcut-ref="dataAccessOperation" 
      method="doAccessCheck"/>
          
    ...
    
</aop:aspect>

<aop:aspect id="afterReturningExample" ref="aBean">

    <aop:after-returning 
      pointcut-ref="dataAccessOperation"
      returning="retVal" 
      method="doAccessCheck"/>
          
    ...
    
</aop:aspect>

public void doAccessCheck（Object retVal） {...

<aop:aspect id="afterThrowingExample" ref="aBean">

    <aop:after-throwing
      pointcut-ref="dataAccessOperation" 
      method="doRecoveryActions"/>
          
    ...
    
</aop:aspect>

<aop:aspect id="afterThrowingExample" ref="aBean">

    <aop:after-throwing 
      pointcut-ref="dataAccessOperation"
      throwing="dataAccessEx" 
      method="doRecoveryActions"/>
          
    ...
    
</aop:aspect>

public void doRecoveryActions（DataAccessException dataAccessEx） {...

<aop:aspect id="afterFinallyExample" ref="aBean">

    <aop:after
      pointcut-ref="dataAccessOperation" 
      method="doReleaseLock"/>
          
    ...
    
</aop:aspect>

<aop:aspect id="aroundExample" ref="aBean">

    <aop:around
      pointcut-ref="businessService" 
      method="doBasicProfiling"/>
          
    ...
    
</aop:aspect>

public Object doBasicProfiling（ProceedingJoinPoint pjp） throws Throwable {
    // start stopwatch
    Object retVal = pjp.proceed（）;
    // stop stopwatch
    return retVal;
}

<aop:before
  pointcut="com.xyz.lib.Pointcuts.anyPublicMethod（） and @annotation（auditable）"
  method="audit"
  arg-names="auditable"/>

package x.y.service;

public interface FooService {

   Foo getFoo（String fooName, int age）;
}

public class DefaultFooService implements FooService {

   public Foo getFoo（String name, int age） {
      return new Foo（name, age）;
   }
}

package x.y;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.util.StopWatch;

public class SimpleProfiler {

   public Object profile（ProceedingJoinPoint call, String name, int age） throws Throwable {
      StopWatch clock = new StopWatch（
            "Profiling for '" + name + "' and '" + age + "'"）;
      try {
         clock.start（call.toShortString（））;
         return call.proceed（）;
      } finally {
         clock.stop（）;
         System.out.println（clock.prettyPrint（））;
      }
   }
}

<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-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

   <!-- this is the object that will be proxied by Spring's AOP infrastructure -->
   <bean id="fooService" class="x.y.service.DefaultFooService"/>

   <!-- this is the actual advice itself -->
   <bean id="profiler" class="x.y.SimpleProfiler"/>

   <aop:config>
      <aop:aspect ref="profiler">

         <aop:pointcut id="theExecutionOfSomeFooServiceMethod"
                    expression="execution（* x.y.service.FooService.getFoo（String,int））
                    and args（name, age）"/>

         <aop:around pointcut-ref="theExecutionOfSomeFooServiceMethod"
                  method="profile"/>

      </aop:aspect>
   </aop:config>

</beans>

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import x.y.service.FooService;

public final class Boot {

   public static void main（final String[] args） throws Exception {
      BeanFactory ctx = new ClassPathXmlApplicationContext（"x/y/plain.xml"）;
      FooService foo = （FooService） ctx.getBean（"fooService"）;
      foo.getFoo（"Pengo", 12）;
   }
}

StopWatch 'Profiling for 'Pengo' and '12'': running time （millis） = 0
-----------------------------------------
ms     %     Task name
-----------------------------------------
00000  ?  execution（getFoo）

引入（在AspectJ中称为inter-type声明）允许一个切面声明一个通知对象实现指定接口， 并且提供了一个接口实现类来代表这些对象。

引入的定义使用aop:aspect中的aop:declare-parents元素。 该元素用于声明所匹配的类型有一个新的父类型（所以有了这个名字）。 例如，给定接口UsageTracked， 以及这个接口的一个实现类 DefaultUsageTracked， 下面的切面声明所有实现service接口的类同时实现 UsageTracked 接口。（比如为了通过JMX输出统计信息）

<aop:aspect id="usageTrackerAspect" ref="usageTracking">

  <aop:declare-parents
      types-matching="com.xzy.myapp.service.*+"
      implement-interface="com.xyz.myapp.service.tracking.UsageTracked"
      default-impl="com.xyz.myapp.service.tracking.DefaultUsageTracked"/>
  
  <aop:before
    pointcut="com.xyz.myapp.SystemArchitecture.businessService（）
              and this（usageTracked）"
    method="recordUsage"/>
  
</aop:aspect>

usageTracking bean的支持类可以包含下面的方法：

public void recordUsage（UsageTracked usageTracked） {
    usageTracked.incrementUseCount（）;
}

要实现的接口由implement-interface属性来指定。 　types-matching属性的值是一个AspectJ类型模式：任何匹配类型的bean都会实现 　UsageTracked 接口。注意在上面前置通知的例子中， serevice bean可以直接用作UsageTracked接口的实现。 如果以编程形式访问一个bean，你可以这样来写：

UsageTracked usageTracked = （UsageTracked） context.getBean（"myService"）;

采用Schema风格来定义切面仅支持一种实例化模型就是singlton模型。其他的实例化模型或许以后的版本会支持。

"advisor"这个概念来自Spring1.2对AOP的支持，而在AspectJ中没有等价的概念。 advisor就像一个小的自包含的切面，这个切面只有一个通知。切面自身通过一个bean表示， 并且必须实现一个在第 7.3.2 节 “Spring里的通知类型”中描述的通知接口。 Advisor可以很好的利用AspectJ的切入点表达式。 　

Spring 2.0通过<aop:advisor>元素来支持advisor概念。 你将会发现大多数情况下它会和transactional advice一起使用，在Spring 2.0中它有自己的命名空间。其格式如下： 　

<aop:config>

  <aop:pointcut id="businessService"
        expression="execution（* com.xyz.myapp.service.*.*（..））"/>

  <aop:advisor 
      pointcut-ref="businessService"
      advice-ref="tx-advice"/>
      
</aop:config>

<tx:advice id="tx-advice">
  <tx:attributes>
    <tx:method name="*" propagation="REQUIRED"/>
  </tx:attributes>
</tx:advice>

让我们看看第 6.2.7 节 “例子”中并发锁失败重试的例子， 当使用schema重写它时是什么样子。

因为并发的问题，有时候business services可能会失败（例如，死锁失败）。如果重试操作，下一次很可能就会成功。 　 对于business services来说，这种情况下重试是很正常的（Idempotent操作不需要用户参与，否则会得出矛盾的结论） 　　　我们可能需要透明的重试操作以避免客户看到一个OptimisticLockingFailureException 　 异常。很明显，在一个横切多层的情况下，这是非常有必要的，因此通过切面来实现是很理想的。 　

因为想要重试操作，我们需要使用环绕通知，这样就可以多次调用proceed()方法。 下面是简单的切面实现（只是一个schema支持的普通Java 类）：

public class ConcurrentOperationExecutor implements Ordered {
   
   private static final int DEFAULT_MAX_RETRIES = 2;

   private int maxRetries = DEFAULT_MAX_RETRIES;
   private int order = 1;

   public void setMaxRetries（int maxRetries） {
      this.maxRetries = maxRetries;
   }
   
   public int getOrder（） {
      return this.order;
   }
   
   public void setOrder（int order） {
      this.order = order;
   }
   
   public Object doConcurrentOperation（ProceedingJoinPoint pjp） throws Throwable { 
      int numAttempts = 0;
      PessimisticLockingFailureException lockFailureException;
      do {
         numAttempts++;
         try { 
            return pjp.proceed（）;
         }
         catch（PessimisticLockingFailureException ex） {
            lockFailureException = ex;
         }
      }
      while（numAttempts <= this.maxRetries）;
      throw lockFailureException;
   }

}

请注意切面实现了Ordered接口，这样我们就可以把切面的优先级设定为 高于事务通知（我们每次重试的时候都想要在一个全新的事务中进行）。 maxRetries 和 order 属性都可以在Spring中配置。 主要的动作在doConcurrentOperation 这个环绕通知方法中发生。 我们首先会尝试处理，如果得到一个OptimisticLockingFailureException 异常，我们仅仅重试直到耗尽所有预设的重试次数。

这个类跟我们在@AspectJ的例子中使用的是相同的，只是没有使用注解。

对应的Spring配置如下：

<aop:config>

  <aop:aspect id="concurrentOperationRetry" ref="concurrentOperationExecutor">

    <aop:pointcut id="idempotentOperation"
        expression="execution（* com.xyz.myapp.service.*.*（..））"/>
       
    <aop:around
       pointcut-ref="idempotentOperation"
       method="doConcurrentOperation"/>
  
  </aop:aspect>

</aop:config>

<bean id="concurrentOperationExecutor"
  class="com.xyz.myapp.service.impl.ConcurrentOperationExecutor">
     <property name="maxRetries" value="3"/>
     <property name="order" value="100"/>  
</bean>

请注意我们现在假设所有的bussiness services都是idempotent。如果不是这样，我们可以改写切面， 通过引入一个Idempotent注解，让它只调用idempotent：

@Retention（RetentionPolicy.RUNTIME）
public @interface Idempotent {
  // marker annotation
}

并且对service操作的实现进行注解。这时如果你只希望改变切面重试idempotent操作， 你只需要改写切入点表达式，让其只匹配@Idempotent操作：

  <aop:pointcut id="idempotentOperation"
        expression="execution（* com.xyz.myapp.service.*.*（..）） and
                    @annotation（com.xyz.myapp.service.Idempotent）"/>