基于Schema配置切面

    使用基于Schema的切面定义后，切点、增强类型的注解信息从切面类中剥离出来，原来的切面类也就蜕变为真正意义上的POJO了。

1、一个简单切面的配置

基于Schema配置的切面示例：

<?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">
    <aop:config proxy-target-class="true">
        <aop:aspect ref="adviceMethods">
            <aop:before pointcut="target(com.yyq.schema.NaiveWaiter) and execution(* greetTo(..))"
                        method="preGreeting"/>
        </aop:aspect>
    </aop:config>
    <bean id="adviceMethods" class="com.yyq.schema.AdviceMethods"/>
    <bean id="naiveWaiter" class="com.yyq.schema.NaiveWaiter"/>
    <bean id="naughtyWaiter" class="com.yyq.schema.NaughtyWaiter"/>
</beans>

　　使用一个<aop:aspect>元素标签定义切面，其内部可以定义多个增强。在<aop:config>元素中可以定义多个切面。通过<aop:before>声明了一个前置增强，并通过pointcut属性定义切点表达式，切点表达式的语法和@AspectJ中所用的语法完全相同，由于&&在XML中使用不便，所以一般用and操作符代替。通过method属性指定增强的方法，该方法应该是adviceMethods Bean中的方法。

 

增强方法所在的类：

package com.baobaotao.schema;
import org.aspectj.lang.ProceedingJoinPoint;

public class AdviceMethods {
    public void preGreeting(String name) {
        System.out.println("--how are you!--");
        System.out.println(name);
    }
    //后置增强对应方法
    public void afterReturning(int retVal){
       System.out.println("----afterReturning()----");
       System.out.println("returnValue:"+retVal);
       System.out.println("----afterReturning()----");
    }
    //环绕增强对应方法
    public void aroundMethod(ProceedingJoinPoint pjp){
       System.out.println("----aroundMethod()----");
       System.out.println("args[0]:"+pjp.getArgs()[0]);
       System.out.println("----aroundMethod()----");
    }
    //抛出异常增强
    public void afterThrowingMethod(IllegalArgumentException iae){
       System.out.println("----afterThrowingMethod()----");
       System.out.println("exception msg:"+iae.getMessage());
       System.out.println("----afterThrowingMethod()----");
    }
    //final增强
    public void afterMethod(){
       System.out.println("----afterMethod()----");
    }
        
      //------------绑定连接点参数----------//
    public void bindParams(int num,String name){
       System.out.println("----bindParams()----");
       System.out.println("name:"+name);
       System.out.println("num:"+num);
       System.out.println("----bindParams()----");
    }
}

NaiveWaiter类：

package com.yyq.schema;
public class NaiveWaiter implements Waiter {
    @Override
    public void greetTo(String name) {
        System.out.println("NaiveWaiter：greet to " + name + "...");
    }
    @Override
    public void serveTo(String name) {
        System.out.println("NaiveWaiter：serving to " + name + "...");
    }
    public void smile(String clientName,int times){
        System.out.println("NaiveWaiter:smile to  "+clientName+ times+"times...");
    }
}

NaughtyWaiter类：

package com.yyq.schema;
public class NaughtyWaiter implements Waiter {
    public void greetTo(String clientName) {
        System.out.println("NaughtyWaiter:greet to " + clientName + "...");
    }
    public void serveTo(String clientName) {
        System.out.println("NaughtyWaiter:serving " + clientName + "...");
    }
    public void joke(String clientName, int times) {
        System.out.println("NaughtyWaiter:play " + times + " jokes to " + clientName + "...");
    }
}

测试方法：

package com.yyq;
import com.yyq.schema.Waiter;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SchemaTest {
    @Test
    public void schemaTest(){
        String configPath = "com\yyq\schema\beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        Waiter naiveWaiter = (Waiter)ctx.getBean("naiveWaiter");
        Waiter naughtyWaiter = (Waiter)ctx.getBean("naughtyWaiter");
        naiveWaiter.greetTo("John");
        naughtyWaiter.greetTo("Tom");
    }
}

输出结果：

---How are you !---

John

NaiveWaiter：greet to John...

NaughtyWaiter:greet to Tom...

 

2、配置命名切点

    通过pointcut属性声明的切点时匿名切点，它不能被其他增强或其他切面引用。Spring提供了命名切点的配置方式。

命名切点配置：

  <aop:config proxy-target-class="true">
        <aop:aspect ref="adviceMethods">
            <aop:pointcut id="greetToPointcut" expression="target(com.yyq.schema.NaiveWaiter) and execution(* greetTo(..))"/>
            <aop:before method="preGreeting" pointcut-ref="greetToPointcut"/>
        </aop:aspect>
    </aop:config>

　　使用<aop:pointcut>定义了一个切点，并通过id属性进行命名，通过pointcut-ref引用这个命名的切点。和<aop:before>一样，除了引介增强外，其他任意增强类型都拥有pointcut、pointcut-ref和method这3个属性。

    如果想要让一个切点为所有增强访问，定义如下：

 <aop:config proxy-target-class="true">
        <aop:pointcut id="greetToPointcut2" expression="target(com.yyq.schema.NaiveWaiter) and execution(* greetTo(..))"/>
        <aop:aspect ref="adviceMethods">
            <aop:before method="preGreeting" pointcut-ref="greetToPointcut2"/>
        </aop:aspect>
        <aop:aspect ref="adviceMethods">
            <aop:after method="postGreeting" pointcut-ref="greetToPointcut2"/>
        </aop:aspect>
    </aop:config>

3、各种增强类型的配置

1）后置增强

<aop:config proxy-target-class="true">
        <aop:aspect ref="adviceMethods">
            <aop:after-returning method="afterReturning"
                                 pointcut="target(com.baobaotao.SmartSeller)" returning="retVal" />
        </aop:aspect>
    </aop:config>

2）环绕增强

 <aop:config proxy-target-class="true">
        <aop:aspect ref="adviceMethods">
            <aop:around method="aroundMethod"
                        pointcut="execution(* serveTo(..)) and within(com.baobaotao.Waiter)" />
        </aop:aspect>
    </aop:config>

3）抛出异常增强

<aop:config proxy-target-class="true">
        <aop:aspect ref="adviceMethods">
            <aop:after-throwing method="afterThrowingMethod"
                                pointcut="target(com.baobaotao.SmartSeller) and execution(* checkBill(..))"
                                throwing="iae" />
        </aop:aspect>
    </aop:config>

4）Final增强

 <aop:config proxy-target-class="true">
        <aop:aspect ref="adviceMethods">
            <aop:after method="afterMethod"
                       pointcut="execution(* com..*.Waiter.greetTo(..))" />
        </aop:aspect>
    </aop:config>

5）引介增强

<aop:config proxy-target-class="true">
        <aop:aspect ref="adviceMethods">
            <aop:declare-parents
                    implement-interface="com.baobaotao.Seller"
                    default-impl="com.baobaotao.SmartSeller"
                    types-matching="com.baobaotao.Waiter+" />
        </aop:aspect>
    </aop:config>

 

4、绑定连接点信息

    基于Schema配置的增强方法绑定连接点信息和基于@AspectJ绑定连接点信息所使用的方式没有区别。

    1）所有增强类型对应的方法第一个入参都可以声明为JoinPoint（环绕增强可声明为ProceedingJoinPoint）访问连接点信息；

    2）<aop:after-returning>（后置增强）可以通过returning属性绑定连接点方法的返回值，<aop:after-throwing>（抛出异常增强）可以通过throwing属性绑定连接点方法所抛出的异常；

    3）所有增强类型都可以通过可绑定参数的切点函数绑定连接点方法的入参。

绑定连接点采纳数到增强方法：

 <aop:config proxy-target-class="true">
        <aop:aspect ref="adviceMethods">
            <aop:before method="bindParams"
                        pointcut="target(com.yyq.schema.NaiveWaiter) and args(name,num,..)"/>
        </aop:aspect>
    </aop:config>

AdviceMethods绑定参数的增强方法：

//------------绑定连接点参数----------//
    public void bindParams(int num,String name){
        System.out.println("----bindParams()----");
        System.out.println("name:"+name);
        System.out.println("num:"+num);
        System.out.println("----bindParams()----");
    }

 

5、Advisor配置

    Advisor是Spring中切面概念的对应物，是切点和增强的复合体，不过仅包含一个切点和一个增强。在AspectJ中没有对应的等价物，在aop Schema配置样式中，可以通过<aop:advisor>配置一个Advisor。通过advice-ref属性引用基于接口定义的增强，通过pointcut定义切点表达式，或者通过pointcut-ref引用一个命名的切点。

  <aop:config proxy-target-class="true">
        <aop:advisor advice-ref="testAdvice"  pointcut="execution(* com..*.Waiter.greetTo(..))"/>
    </aop:config>
    <bean id="testAdvice" class="com.yyq.schema.TestBeforeAdvice"/>

 增强类：

package com.yyq.schema;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class TestBeforeAdvice implements MethodBeforeAdvice {
    public void before(Method method, Object[] args, Object target)
            throws Throwable {
        System.out.println("------TestBeforeAdvice------");
        System.out.println("clientName:"+args[0]);
        System.out.println("------TestBeforeAdvice------");
    }
}