Spring入门第十七课

AOP编程

问题：

代码混乱：

越来越多的非业务需求（日志和验证等）加入后，原有的业务方法急剧膨胀，每个方法在处理核心逻辑的同事还必须兼顾其他多个关注点。

代码分散：以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里面多次重复相同的日志代码，如果日志需求发生变化，必须修改所有模块。

先看使用动态代理：

package logan.study.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);
    

}

package logan.study.aop.helloworld;

public class ArithmeticCalculatorImpl implements ArithmeticCalculator {

    @Override
    public int add(int i, int j) {
        // TODO Auto-generated method stub
        int result = i + j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        // TODO Auto-generated method stub
        int result = i - j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        // TODO Auto-generated method stub
        int result = i * j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        // TODO Auto-generated method stub
        int result = i / j;
        return result;
    }

}

package logan.study.aop.helloworld;

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

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:正在返回的那个对象，一般情况下，在invok方法中都不使用该对象
             * method：正在被调用的方法
             * args：调用方法时传入的参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // TODO Auto-generated method stub
                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 = " + result);
                //返回
                return result;
            }
        };
        proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
        
        return proxy;
    }

}

package logan.study.aop.helloworld;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArithmeticCalculator target = new ArithmeticCalculatorImpl();
        ArithmeticCalculator proxy =  new ArithmeticCalculatorLoggingProxy(target).getLoggingProxy();
        
        int result = proxy.add(1, 2);
        System.out.println("-->"+result);
        
        result = proxy.div(8, 2);
        System.out.println("-->"+result);
        

    }

}

返回的结果：

The method addbegin with [1, 2]
The method addend with result = 3
-->3
The method divbegin with [8, 2]
The method divend with result = 4
-->4

但是使用动态代理比较麻烦，有没有更简单的方法来实现呢？

AOP（Aspect-Oriented-Programming，面向切面编程）是一种新的方法论，是对传统OOP（Object-Oriented-Programming，面向对象编程）的补充。

AOP的主要编程对象是切面（Aspect），而切面是模块化横切关注点。

在应用AOP编程时，仍然需要定义公共功能，但是可以明确地定义这个功能在哪里，以什么方式应用，并且不必修改受影响的类，这样一来，横切关注点就被模块化到特殊的对象（切面）里。

AOP好处：

-每个事物逻辑错位与一个位置，代码不分散，便于维护和升级

-业务模块更简洁，只包含核心的业务代码

AOP术语

切面（Aspect）：横切关注点（跨越应用程序多个模块的功能）被模块化的特殊对象。

通知（Advice）：切面必须要完成的工作。

目标（Target）：被通知的对象。

代理（Proxy）：向目标对象应用通知之后创建的对象。

连接点（Joinpoint）：程序执行的每个特定位置：如类某个方法调用前，调用后，方法抛出异常等等，连接点由两个信息确定：方法表示的程序的执行点，相对点表示的方位，例如ArithmeticCalculator#add()方法执行前的连接点执行点为ArithmeticCalculator#add();方位为该方法执行前的位置。

切点（pointcut）：每个类都拥有多个连接点，例如：ArithmethicCalculator的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务，AOP通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件，切点和连接点不是一对一关系，一个切点匹配多个连接点，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件。