基于@AspectJ注解配置切面与基于XML配置切面

　1. Waiter目标类

 package com.smart.aop.advice.pointcut;

 public class Waiter {

     public void greetTo(String name) {
         System.out.println("Waiter greet to " + name + " ...");
     }

     public void serverTo(String name) {
         System.out.println("waiter server to " + name + " ...");
     }
 }

2. 使用AspectJ注解定义切面

 package com.smart.aop.advice.aspectj;

 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Before;

 @Aspect
 public class PreGreetingAspect {

     @Before ("execution(* greetTo(..))") //定义连接点（连接点方位信息--前置增强, 切点--所有目标类的greetTo方法--可带任意的入参和返回值）
     public void beforeGreeting() {
         System.out.println("How are you!"); //方法体为增强逻辑
     }
 }

3. 通过编程的方式织入切面，为Waiter生成织入了xxx切面的代理

 package com.smart.aop.advice.aspectj;

 import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;
 import org.testng.annotations.Test;
 import com.smart.aop.advice.pointcut.Waiter;

 public class AspectJProxyTest {

     @Test
     public void beforeTest() {

         Waiter waiter = new Waiter();
         AspectJProxyFactory pFactory = new AspectJProxyFactory();

         pFactory.setTarget(waiter); //设置目标实例
         pFactory.addAspect(PreGreetingAspect.class); //添加切面类

         Waiter proxyWaiter = pFactory.getProxy(); //生成织入代理的代理对象

         /**
          * 由切面类中的切点信息execution(* greetTo(..))
          * 可知代理对象proxyWaiter的greetTo方法织入了切面类所定义的增强逻辑
          */
         proxyWaiter.greetTo("Jack");
         proxyWaiter.serverTo("Jack");
     }
 }
输出结果：

How are you!
Waiter greet to Jack ...

waiter server to Jack ...

4. 通过Spring配置方式织入切面

1）xml 配置

     <!-- 匹配切点的目标bean -->
     <bean id="waiter" class="com.smart.aop.advice.pointcut.Waiter" />

     <!-- 使用@AspectJ标注的切面类 -->
     <bean class="com.smart.aop.advice.aspectj.PreGreetingAspect" />

     <!-- 自动代理创建器，能够将@AspectJ标注的切面自动织入到目标bean中 -->
     <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />

2）测试

 package com.smart.aop.advice.aspectj;

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 import org.testng.annotations.Test;

 import com.smart.aop.advice.pointcut.Waiter;

 public class SpringAspectJTest {

     @Test
     public void beforeTest() {

         ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:com/smart/aop/advice/aspectj/beans-aspectj.xml");
         Waiter waiter = ctx.getBean("waiter", Waiter.class);

         waiter.greetTo("Jack");
         waiter.serverTo("Jack");
     }
 }

------------------------------------------------------------------------

基于XML配置切面

把切面类中的通过@Aspect和@Before("execution(* greetTo(..))")配置的‘连接点（切点和增强类型）’信息从切面类中剥离出来放到XML中配置，使原来的切面类成为真正意义上的POJO

1. 切面类 --- 成为一个普通的java类

package com.smart.aop.advice.aspectj;

public class PreGreetingAspect {

    public void preGreeting() {
        System.out.println("切入代码 How are you!");
    }
}

2. 在XML中配置切面

     <!-- 目标bean实例 -->
     <bean id="waiter" class="com.smart.aop.advice.pointcut.Waiter" />
     <!-- 切面实例 -->
     <bean id="greetingAspect" class="com.smart.aop.advice.aspectj.PreGreetingAspect" />

     <!-- proxy-target-class
            true, 声明的切面使用cglib代理技术
            false, 声明的切面使用JDK代理技术
             -->
     <aop:config proxy-target-class="true">
         <aop:aspect ref="greetingAspect">
             <!--
               aop:before，为前置增强
                   method属性，指定增强方法
                   pointcut属性，定义切点表达式
             -->
             <aop:before method="preGreeting" pointcut="target(com.smart.aop.advice.pointcut.Waiter) and execution(* greetTo(..))"/>
         </aop:aspect>
     </aop:config>

使用4-2的方法测试，验证System.out.println("切入代码 How are you!");已织入到Waiter#greeTo()方法的前面。

加入后置增强

1. 切面类

package com.smart.aop.advice.aspectj;

public class PreGreetingAspect {

    public void preGreeting() {
        System.out.println("Waiter#greetTo()方法执行前织入  How are you!");
    }

    public void postGreeting() {
        System.out.println("Waiter#greetTo()方法执行后织入 Byte!");
    }
}

2. XML配置

     <!-- 目标bean实例 -->
     <bean id="waiter" class="com.smart.aop.advice.pointcut.Waiter" />
     <!-- 切面实例 -->
     <bean id="greetingAspect" class="com.smart.aop.advice.aspectj.PreGreetingAspect" />

     <!-- proxy-target-class
            true, 声明的切面使用cglib代理技术
            false, 声明的切面使用JDK代理技术
             -->
     <aop:config proxy-target-class="true">

         <aop:pointcut id="greetToPointcut"
                 expression="target(com.smart.aop.advice.pointcut.Waiter) and execution(* greetTo(..))" />

         <!-- 定义一个切面greetingAspect -->
         <aop:aspect ref="greetingAspect">
             <!--
               aop:before，为前置增强
                   method属性，指定增强方法
                   pointcut属性，定义切点表达式
             -->
             <aop:before method="preGreeting" pointcut-ref="greetToPointcut"/>
         </aop:aspect>

         <aop:aspect ref="greetingAspect">
             <aop:after method="postGreeting" pointcut-ref="greetToPointcut"/>
         </aop:aspect>
     </aop:config>

3. 测试

     @Test
     public void beforeTest() {

         ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:com/smart/aop/advice/aspectj/beans-aspectj.xml");
         Waiter waiter = ctx.getBean("waiter", Waiter.class);

         waiter.greetTo("Jack");
         waiter.serverTo("Jack");
     }

输出结果：

Waiter#greetTo()方法执行前织入 How are you!
Waiter greet to Jack ...
Waiter#greetTo()方法执行后织入 Byte!
waiter server to Jack ...