基于配置文件的方式来配置ＡＯＰ

示例：

applicationContext-xml.xml：

<?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.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
  
  <!-- 配置Bean -->
  <bean id="arithmeticCalculator"
        class="com.hk.spring.aop.xml.ArithmeticCalculatorImpl">
  </bean>
  
  <!-- 配置切面的Bean -->
  <bean id="loggingAspect"
        class="com.hk.spring.aop.xml.LoggingAspect">
  </bean>
  
  <bean id="vlidationAspect"
         class="com.hk.spring.aop.xml.VlidationAspect">
  </bean>
  
  <!-- 配置AOP -->
  <aop:config>
     <!-- 配置切点表达式 -->
     <aop:pointcut expression="execution(* com.hk.spring.aop.xml.ArithmeticCalculator.*(int,int))" 
                   id="pointcut"/>
     <!-- 配置切面和通知 -->
     <aop:aspect ref="loggingAspect" order="2" >
        <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
        <aop:after method="afterMethod" pointcut-ref="pointcut"/>
        <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="ex"/>
        <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result" />
     </aop:aspect>
     <aop:aspect ref="vlidationAspect" order="1">
        <aop:before method="validateArgs" pointcut-ref="pointcut"/>
     </aop:aspect>
  </aop:config>
</beans>

注：重点在代码里。

VlidationAspect.java：

package com.hk.spring.aop.xml;

import java.util.Arrays;

import org.aopalliance.intercept.Joinpoint;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


public class VlidationAspect {
    
    public void validateArgs(JoinPoint joinPoint){
        System.out.println("-->validate:" + Arrays.asList(joinPoint.getArgs()));
    }

}

LoggingAspect.java：

package com.hk.spring.aop.xml;

import java.util.Arrays;
import java.util.List;

import org.aopalliance.intercept.Joinpoint;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


public class LoggingAspect {
    
    /*
     * 定义一个方法，用于声明切入点表达式，一般该方法中再不需要加入其它代码
     */
    public void declareJointPointExpression(){
        
    }
    
    
    //声明该方法是一个前置通知：在目标方法之前执行
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The method " + methodName + " begins with " + args);
    }
    
    //后置通知：在目标方法执行后（无论是否发生异常)，执行的通知。
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " ends");
    }    
    
    
    /*
     * 在方法正常执行后执行的通知叫返回通知
     * 返回通知是可以访问到方法的返回值的
     */
    public void afterReturning(JoinPoint joinPoint,Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " ends with " + result);
    }
    
    /*
     * 在目标方法出现异常时，会执行代码。
     * 可以访问到异常对象；且可以指定在出现特定异常时在执行通知
     */
    public void afterThrowing(JoinPoint joinPoint,Exception ex){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The method " + methodName + " coours exception : " + ex);
    }
    
    /*
     * 环绕通知需要携带ProceedingJoinPoint 类型的参数
     * 环绕通知类似于动态代理的全过程：ProceedingJoinPoint这个类型的参数可以决定是否执行目标方法
     * 且环绕通知必须有返回值，返回值即为目标方法的返回值
     */
    public Object aroundMethod(ProceedingJoinPoint pjd){
        
        Object result = null;
        String methodName = pjd.getSignature().getName();
        
        //执行目标方法
        try {
            //前置通知
            System.out.println("The method " + methodName + "begins with " + Arrays.asList(pjd.getArgs()));
            result = pjd.proceed();
            //后置通知
            System.out.println("The method " + methodName + "ends with " + result);
        } catch (Throwable e) {
            //异常通知
            System.out.println("The method occurs exception:" + e);
        }
        //后置通知
        System.out.println("The method " + methodName + " ends");
        return result;
    }
}

ArithmeticCalculator.java：

package com.hk.spring.aop.xml;

public interface ArithmeticCalculator {
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}

ArithmeticCalculatorImpl.java：

package com.hk.spring.aop.xml;

import org.springframework.stereotype.Component;


public class ArithmeticCalculatorImpl implements ArithmeticCalculator {

    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        return result;
    }

}

运行结果：