基于@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 ...