基于XML配置的AOP实现日志打印

Spring中可以使用注解或XML文件配置的方式实现AOP。
1、导入jar包

• com.springsource.net.sf.cglib -2.2.0.jar
• com.springsource.org.aopalliance-1.0.0 .jar
• com.springsource.org.aspectj.weaver-1.6.8 .RELEASE.jar
• commons-logging-1.1.3. jar
• spring-aop-4.0.0.RELEASE.jar
• spring-aspects-4.0.0.RELEASE.jar
• spring-beans-4.0.0.RELEASE.jar
• spring-context-4.0.0.RELEASE.jar
• spring-core-4.0.0.RELEASE.jar
• spring-expression-4.0.0.RELEASE.jar

aspectaop相关jar包 ---> 资源目录--->jar包资源--->AOP日志打印相关jar包（切面类） 

Spring相关jar包 ---> 资源目录--->jar包资源--->Spring相关jar包 

2、新建代理类和切面类

@Component
public class MathCalculator {
    public void add(int i, int j) {
        int result=i+j;
        System.out.println("目标方法add(int)执行了");
    }
    public void sub(int i, int j) {
        int result=i-j;
        System.out.println("目标方法sub执行了");
    }
    public void mult(int i, int j) {
        int result=i*j;
        System.out.println("目标方法mult执行了");
    }
    public void div(int i, int j) {
        int result=i/j;
        System.out.println("目标方法div执行了");
    }
}

切面类1：LogAspectp1：声明4中通知方法，Before、After、AfterThrowing、AfterReturning

public class LogAspectp1{
    public void showBeginLog(JoinPoint jPoint){
        Object[] args = jPoint.getArgs();//获取方法参数
        List<Object> asList = Arrays.asList(args);//转化成List集合
        Signature signature = jPoint.getSignature();
        String name = signature.getName();//获取方法的名字
        System.out.println("LogAspectp1-----AOP日志开始");
        System.out.println("目标方法名："+name+"，参数列表："+asList);
    }
    public void showAfterLog(){
        System.out.println("LogAspectp1-----AOP方法结束");
    }
    public void showExceptionLog(Exception ex){
        System.out.println("LogAspectp1-----AOP方法异常");
        System.out.println("异常信息:"+ex.getMessage());
    }
    public void showReturnLog(Object result){
        System.out.println("方法返回值:"+result);
        System.out.println("LogAspectp1-----AOP方法最终返回");
    }
}

切面类2：LogAspectp2：声明Around通知方法，代替前面的4中通知

public class LogAspectp2{
    public Object showLog(ProceedingJoinPoint point){
        Object[] args = point.getArgs();
        List<Object> asList = Arrays.asList(args);
        Signature signature = point.getSignature();
        String name = signature.getName();
        Object result = null;
        try {
            try {
                //目标方法之前要执行的操作,相当于@before
                System.out.println("LogAspect2-----[环绕日志]"+name+"开始了，参数为:"+asList);
                //调用目标方法
                result = point.proceed(args);
            } finally {
                //方法最终结束时执行的操作，相当于@after
                System.out.println("LogAspect2-----[环绕日志]"+name+"结束了!");
            }
            //目标方法正常执行之后的操作，相当于@AfterReturning
            System.out.println("LogAspect2-----[环绕日志]"+name+"返回了，返回值为:"+result);
        } catch (Throwable e) {
            //目标方法抛出异常信息之后的操作，相当于@AfterThrowing
            System.out.println("LogAspect2-----[环绕日志]"+name+"出异常了，异常对象为:"+e);
            throw new RuntimeException(e.getMessage());
        }
        return result;
    }
}

3、在Spring的配置文件applicationContext.xml中进行配置

<!-- 将需要加载到IOC容器中的bean配置好 -->
<bean id="mathCalculator" class="com.bwlu.common.MathCalculator"></bean>
<bean id="logAspectp1" class="com.bwlu.common.LogAspectp1"></bean>
<bean id="logAspectp2" class="com.bwlu.common.LogAspectp2"></bean>
<!-- 配置AOP,需要导入AOP名称空间 -->
<aop:config>
    <!-- 声明切入点表达式 -->
    <aop:pointcut expression="execution(public * com.bwlu.aop.MathCalculatorImpl.*(..))" id="pointcut"/>
    <!-- 配置日志切面类,引用前面的类 ,通过order属性控制优先级-->
    <aop:aspect ref="logAspectp1" order="20">
        <!-- 通过method属性指定切面类的切面方法，通过pointcut-ref指定切入点表达式 -->
        <aop:before method="showBeginLog" pointcut-ref="pointcut"/>
        <aop:after method="showAfterLog" pointcut-ref="pointcut"/>
        <aop:after-throwing method="showExceptionLog" pointcut-ref="pointcut" throwing="ex"/>
        <aop:after-returning method="showReturnLog" pointcut-ref="pointcut" returning="result"/>
    </aop:aspect>
    <aop:aspect ref="logAspectp2" order="10">
        <aop:around method="showLog" pointcut-ref="pointcut"/>
    </aop:aspect>
</aop:config>

4、新建Junit测试类进行测试

ApplicationContext ioc=new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test() {
    //需要进行强转，如果该类实现了一个接口（并且切入点表达式指向这个类），那么获取到的将不是该类的对象，需要强转
    //MathCalculatorImpl实现了MathCalculator接口，则
    //MathCalculator bean = (MathCalculator)ioc.getBean("mathCalculatorImpl");
    MathCalculator bean = (MathCalculator)ioc.getBean("mathCalculator");
    bean.add(10, 5);
    System.out.println();
    bean.add(10.0, 5);
    System.out.println();
    bean.sub(10, 5);
    System.out.println();
    bean.mult(10, 5);
    System.out.println();
    bean.div(10, 0);
}

运行结果：

LogAspectp2-----[环绕日志]add开始了，参数为:[10, 5]
LogAspectp1-----AOP日志开始
目标方法名：add，参数列表：[10, 5]
目标方法add(int)执行了
LogAspectp1-----AOP方法结束
方法返回值:null
LogAspectp1-----AOP方法最终返回
LogAspectp2-----[环绕日志]add结束了!
LogAspectp2-----[环绕日志]add返回了，返回值为:null

LogAspectp2-----[环绕日志]add开始了，参数为:[10.0, 5.0]
LogAspectp1-----AOP日志开始
目标方法名：add，参数列表：[10.0, 5.0]
目标方法add(double)执行了
LogAspectp1-----AOP方法结束
方法返回值:15.0
LogAspectp1-----AOP方法最终返回
LogAspectp2-----[环绕日志]add结束了!
LogAspectp2-----[环绕日志]add返回了，返回值为:15.0

LogAspectp2-----[环绕日志]sub开始了，参数为:[10, 5]
LogAspectp1-----AOP日志开始
目标方法名：sub，参数列表：[10, 5]
目标方法sub执行了
LogAspectp1-----AOP方法结束
方法返回值:null
LogAspectp1-----AOP方法最终返回
LogAspectp2-----[环绕日志]sub结束了!
LogAspectp2-----[环绕日志]sub返回了，返回值为:null

LogAspectp2-----[环绕日志]mult开始了，参数为:[10, 5]
LogAspectp1-----AOP日志开始
目标方法名：mult，参数列表：[10, 5]
目标方法mult执行了
LogAspectp1-----AOP方法结束
方法返回值:null
LogAspectp1-----AOP方法最终返回
LogAspectp2-----[环绕日志]mult结束了!
LogAspectp2-----[环绕日志]mult返回了，返回值为:null

LogAspectp2-----[环绕日志]div开始了，参数为:[10, 0]
LogAspectp1-----AOP日志开始
目标方法名：div，参数列表：[10, 0]
LogAspectp1-----AOP方法结束
LogAspectp1-----AOP方法异常
异常信息:/ by zero
LogAspectp2-----[环绕日志]div结束了!
LogAspectp2-----[环绕日志]div出异常了，异常对象为:java.lang.ArithmeticException: / by zero