spring的AOP编程

基于注解的方式

cfg.xml中

    <!-- 通过注释的方式来实现AOP所以要扫描包 -->
    <context:component-scan base-package="spring_aop_helloworld"></context:component-scan>    
    <!-- 要把切面自动生成代理写上 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

要在计算器的每个方法的开始和结束时打印日志文件

首先计算器类被配置成bean，然后

Logging.java

package spring_aop_helloworld;

import java.util.Arrays;

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;

@Order(2)
@Aspect
@Component
public class Logging {
    //以这种方式实现重用，不用每次都写execution(* spring_aop_helloworld.Calculator.*(int,int))
    @Pointcut(value="execution(* spring_aop_helloworld.Calculator.*(int,int))")
    public void getExpression(){}
    
    /**
     * 前置通知，在执行* spring_aop_helloworld.Calculator.*(int,int)（使用了AspectJ表达式）前执行此方法
     * 
     * JoinPoint j传入参数
     * j.getSignature().getName()获取方法名
     * j.getArgs()获取参数数组
     * */
    @Before(value="getExpression()")
    public void before(JoinPoint j){
        System.out.println("Before通知"+j.getSignature().getName()+":"+Arrays.asList(j.getArgs())    );
    }
    
    /**
     * 后置通知，在执行后执行此方法，不管这个方法有没有异常，能不能执行
     * */
    @After(value="execution(* spring_aop_helloworld.Calculator.*(int,int))")
    public void after(JoinPoint j){
        System.out.println("After通知"+j.getSignature().getName()+":"+Arrays.asList(j.getArgs()));
    }
    
    /**
     * 返回通知，在方法返回结果之后执行
     * returning="result"通过参数中和其名字相同的参数传入可以得到被代理方法的返回值
     * */
    @AfterReturning(value="execution(* spring_aop_helloworld.Calculator.*(int,int))",returning="result")
    public void afterReturning(JoinPoint j,Object result){
        System.out.println("AfterReturning通知:"+j.getSignature().getName()+":"+Arrays.asList(j.getArgs())+":"+result);
    }
    
    /**
     * 异常通知，在方法抛出异常之后执行，若没有异常则不执行
     * throwing="e"通过参数中和其名字相同的参数传入发生的异常。
     * 也可以只在指定异常抛出后通知
     * */
    @AfterThrowing(value="execution(* spring_aop_helloworld.Calculator.*(int,int))",throwing="e")
    public void afterEhroeing(JoinPoint j,Exception e){
        System.out.println("AfterThrowing通知:"+j.getSignature().getName()+":"+Arrays.asList(j.getArgs())+":"+e);
    }
    
    /**
     * 环绕通知
     * */
    @Around(value="execution(* spring_aop_helloworld.Calculator.*(int,int))")
    public Object around(ProceedingJoinPoint p){
        String methodName = p.getSignature().getName();
        Object o = null;
        
        try {
            System.out.println("-->等同前置通知");
            o = (int) p.proceed();
            System.out.println("-->等同返回通知");
        } catch (Throwable e) {
//            throw new RuntimeException(e);
            System.out.println("-->等同异常通知");
        }
        System.out.println("-->等同后置通知");
        return o;
    }
}

验证器类

package spring_aop_helloworld;

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;


/**
 * Order(1)代表切面被调用的优先级，数字越小越先调用
 * Aspect 表示这是一个切面
 * Component 表示这是一个组件，IOC容器可以扫描到
 * */
@Order(1)
@Aspect
@Component
public class Validation {
    
    //spring_aop_helloworld.Logging.getExpression()返回要代理的方法,实现重用
    @Before(value="spring_aop_helloworld.Logging.getExpression()")
    public void before_validation(JoinPoint j){
        System.out.println("0000验证前置"+j.getSignature().getName());
    }
    
}

基于配置文件的方式

cfg.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.0.xsd">
    
    
    <bean id="calculatorImpl" class="spring_aop_xml.CalculatorImpl"></bean>
    <bean id="logging" class="spring_aop_xml.Logging"></bean>
    <bean id="validation" class="spring_aop_xml.Validation"></bean>
    
    <aop:config>
        <aop:pointcut expression="execution(* spring_aop_xml.Calculator.*(int, int))" id="expression"/>
        <aop:aspect ref="logging" order="2">
            <aop:before method="before" pointcut-ref="expression"/>
            <aop:after method="after" pointcut-ref="expression"/>
            <aop:after-returning method="afterReturning" pointcut-ref="expression" returning="result"/>
            <aop:after-throwing method="afterthrowing" pointcut-ref="expression" throwing="e"/>
            <aop:around method="around" pointcut-ref="expression"/>
        </aop:aspect>
        <aop:aspect ref="validation" order="1">
            <aop:before method="before_validation" pointcut-ref="expression"/>
        </aop:aspect>
    </aop:config>
    
</beans>

验证器类和日志文件类都和基于注解的一样，只不过去掉注解。

传统的代理方法实现面向切面编程

package spring_aop_old;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class CalculatorProxy {
    private Calculator c;
    
    //通过构造器传入被代理的对象
    public CalculatorProxy(Calculator c) {
        this.c = c;
    }
    //获取代理对象
    public Object getInstance(){
        Object proxy = null;
        
        InvocationHandler handler = new InvocationHandler() {
        
            /**
             * 当想要运行被代理对象的相关方法时，代理对象通过调用invoke来调用被代理对象的方法
             * 
             * Object proxy是getInstance()返回的代理对象
             * Method method被代理对象的方法
             * Object[] args被代理对象的方法中的参数
             * */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) {
                Object result = null;
                
                System.out.println("之前..类似前置");
                try {
                    result = method.invoke(c, args);
                } catch (Exception e) {
                    System.out.println("异常..类似异常");
                }
                System.out.println("之后..类似后置");
                
                return result;
            }
        };
        proxy = Proxy.newProxyInstance(c.getClass().getClassLoader(), new Class[]{Calculator.class}, handler);
        
        return proxy;
    }
}

package spring_aop_old;

public class TestAOPHello {

    public static void main(String[] args) {
        Calculator c = (Calculator) new CalculatorProxy(new CalculatorImpl()).getInstance();
        System.out.println(c.add(1, 2));
        System.out.println(c.div(10, 0));
    }

}