[spring学习]10、AOP思想提出

基本介绍

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

上面这个是百度百科的介绍，如果是第一次接触，那肯定是看不懂的，应为aop颠覆了传统的oop的思想，提出了一种切面编程的思想，下面通过一个案例来说明aop的基本思想。

案例说明

现在有一个接口Vehicle，两个实现子类，分别是Car和Aircraft，内容如下

Vehicle接口

public interface Vehicle {

    public void run();
}

Car实现类

public class Car implements Vehicle{
    @Override
    public void run() {
        System.out.println("小汽车开始运行....");
    }
}

Aircraft实现类

public class Aircraft implements Vehicle{

    @Override
    public void run() {
        System.out.println("飞机开始起飞了.....");
    }
}

现在有一个要求，在调用run方法的时候，要在调用前输出，run方法开始执行了，调用结束后输出run方法执行完毕。

传统解决思路

我们要解决上面问题非常简单，只需要在实现类的run方法最开始和最后加上这条输出语句就行了，如下：

public class Car implements Vehicle {
    @Override
    public void run() {
        System.out.println("run方法开始执行了");
        System.out.println("小汽车开始运行....");
        System.out.println("run方法执行完毕");
    }
}

public class Aircraft implements Vehicle{

    @Override
    public void run() {
        System.out.println("run方法开始执行了");
        System.out.println("飞机开始起飞了.....");
        System.out.println("run方法执行完毕");
    }
}

这样就轻松实现了，但是这种方法好吗？这只是2个子类，如果有100个呢？我们可以发现，传统的实现方法存在着代码冗余，不利于维护，并且可扩展性很差。

动态代理方式实现

我们通过反射的方式，在原本代码不变的基础上，写一个代理对象类，这个类提供一个方法，返回一个代理对象。代码如下

public class VehicleProxyProvider {

    public static Vehicle getProxy(Vehicle vehicle) {
        //得到类构造器
        ClassLoader classLoader = vehicle.getClass().getClassLoader();
        //得到所有接口信息
        Class<?>[] interfaces = vehicle.getClass().getInterfaces();
        //通过Proxy得到代理对象，返回的是实现Vehicle的一个代理类
        Object o = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            /**
             * @param proxy 表示代理对象
             * @param method 表示要被代理的方法
             * @param args 方法的参数
             * @return 方法的返回值
             * @throws Throwable 抛出的异常
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method.getName() + "方法开始执行");
                //执行方法
                Object invoke = method.invoke(vehicle, args);
                System.out.println(method.getName() + "方法执行完毕");
                //将方法执行的结果返回
                return invoke;
            }
        });
        //返回代理对象
        return (Vehicle) o;
    }
}

我们将要进行代理的对象先创建，然后调用getProxy方法得到代理后的对象，然后再调用run方法，而我们在代理对象中，就已经在原本的方法调用前和调用后做了一些事情。我们创建一个测试方法来看是否有效，代码如下

    @Test
    public void t1(){
        Car car = new Car();
        Aircraft aircraft = new Aircraft();
        Vehicle carProxy = VehicleProxyProvider.getProxy(car);
        Vehicle aircraftProxy = VehicleProxyProvider.getProxy(aircraft);
        carProxy.run();
        System.out.println("--------------------------");
        aircraftProxy.run();
    }

输出如下

可以发现，我们通过动态代理，实现方法的统一处理就方便多了。

横切关注点

我们对上面的Proxy.newProxyInstance里面匿名内部类中的invoke进行一点扩展，变化后的代码如下

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object invoke = null;
                try {
                    System.out.println(method.getName() + "方法开始执行--前置通知");
                    //执行方法
                    invoke = method.invoke(vehicle, args);
                    System.out.println(method.getName() + "方法执行完毕--返回通知");
                } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                    System.out.println(method.getName()+"--异常通知");
                    e.printStackTrace();
                } finally {
                    System.out.println(method.getName()+"后置通知");
                }
                //将方法执行的结果返回
                return invoke;
            }
        });