Spring AOP

AOP简介
　　AOP(Aspect-Oriented Programming，面向切面编程):是一种新的方法论，是对传统OOP的补充
　　AOP的主要编程对象时切面(aspect)，而切面模块化横切关注点
　　在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能在哪里，以什么方式应用，并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的对象(切面)里。
　　AOP的好处
　　　　每个事务逻辑位于一个位置，代码不分散，便于维护和升级
　　　　业务模块更简洁，只包含核心业务代码

AOP术语
　　切面(Aspect):横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象
　　通知(Advice):切面必须要完成的工作
　　目标(Target):被通知的对象
　　代理(Proxy):向目标对象应用通知之后创建的对象
　　连接点(Joinpoint):程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点有两个信息确定：方法表示的程序执行点，相对点表示的方位。例如ArithmeticCalculator#add()方法执行前的连接点，执行点为ArithmeticCalculator#add()；方位为该方法执行前的位置。
　　切点(pointcut):每个类都拥有多个连接点。例如ArithmeticCalculator的所有方法其实都是连接点，即连接点是程序类中客观存在的事务。AOP通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件。

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

下面实现一个简单的计算器来解释AOP的产生背景。

接口：ArithmeticCalculator.java，定义加减乘除方法

package com.yl.spring.aop.helloworld;

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.yl.spring.aop.helloworld;

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;
    }

}

至此，上面两段代码实现了基本的计算器。新的需求时在计算前后增加日志。

最简单的实现就是在每个方法的计算语句前后增加日志代码，即输出语句。具体实现如下：

ArithmeticCalculatorLoggingImpl.java

package com.yl.spring.aop.helloworld;

public class ArithmeticCalculatorLoggingImpl implements ArithmeticCalculator {

    @Override
    public int add(int i, int j) {
        System.out.println("the method add begin with[" + i + ", " + j + "]");
        int result = i + j;
        System.out.println("the method add end with " +result);
        return result;
        
    }

    @Override
    public int sub(int i, int j) {
        System.out.println("the method sub begin with[" + i + ", " + j + "]");
        int result = i - j;
        System.out.println("the method sub end with " +result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("the method mul begin with[" + i + ", " + j + "]");
        int result = i * j;
        System.out.println("the method mul end with " +result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("the method div begin with[" + i + ", " + j + "]");
        int result = i / j;
        System.out.println("the method div end with " +result);
        return result;
    }

}

 但是上述的实现方法增加了业务模块的复杂度，而且修改日志代码时也不方便。

下面在介绍一个新的方法，即动态代理。具体实现如下：

ArithmeticCalculatorLoggingProxy.java

package com.yl.spring.aop.helloworld;

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

import org.springframework.beans.propertyeditors.ClassArrayEditor;

public class ArithmeticCalculatorLoggingProxy {
    //要代理的对象
    private ArithmeticCalculator target;
    
    public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target) {
        this.target = target;
    }
    
    public ArithmeticCalculator getLoggingProxy() {
        ArithmeticCalculator proxy = null;
        
        //代理对象由哪一个类加载器负责加载
        ClassLoader loader = target.getClass().getClassLoader();
        //代理对象的类型，即其中有哪些方法
        Class [] interfaces = new Class[]{ArithmeticCalculator.class};
        //当调用代理对象其中的方法时，该执行的代码
        InvocationHandler h =  new InvocationHandler() {
            /**
             * proxy:正在返回的那个代理对象，一般情况下，在invoke方法中都不使用该对象
             * method:正在调用的方法
             * args:调用方法时，传入的参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                //此句话或造成循环调用，最终内存溢出
                //System.out.println(proxy.toString());
                
                
                String methodName = method.getName();
                //日志
                System.out.println("the method " + methodName + " begin with " + Arrays.asList(args));
                //执行该方法
                Object result = method.invoke(target, args);
                //日志
                System.out.println("the method " + methodName + " end with " + result);
                return result;
            }
        };
        
        proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
        
        return proxy;
    }

}

至此，动态代理的实现完毕。

测试类：

package com.yl.spring.aop.helloworld;

public class Main {
    public static void main(String[] args) {
        
        /*//测试日志
        ArithmeticCalculator arithmeticCalculator = null;
        arithmeticCalculator = new ArithmeticCalculatorLoggingImpl();
        
        int result = arithmeticCalculator.add(1, 2);
        System.out.println("-->" + result);
        
        result = arithmeticCalculator.div(4, 2);
        System.out.println("-->" + result);*/
        
        //动态代理测试
        ArithmeticCalculator target = new ArithmeticCalculatorImpl();
        ArithmeticCalculator proxy = new ArithmeticCalculatorLoggingProxy(target).getLoggingProxy();
        
        System.out.println(proxy.getClass().getName());
        
        int result = proxy.add(1, 2);
        System.out.println("-->" + result);
        
        result = proxy.div(4, 2);
        System.out.println("-->" + result);
    }
}

AOP的具体用法还请参考本系列的后续文章......