AOP

1.官方文档

AOP讲解：下载的spring文件-->spring-framework-5.3.8/docs/reference/html/core.html#aop

AOP APIs：下载的spring文件-->spring-framework-5.3.8/docs/reference/html/core.html#aop-api

2.动态代理

2.1案例说明

需求说明：

有Vehicle（交通工具接口，有一个run方法），下面有两个实现类Car，Ship

当运行Car对象的run()方法和Ship对象的run()方法时，输出如下内容，注意观察前后有统一的输出。

请思考如何完成？

2.2传统方式解决

Vehicle接口：

package com.li.proxy;

/**

 * @author 李

 * @version 1.0

 * 接口，定义了run方法

 */

public interface Vehicle {

    public void run();

}

Ship类，实现Vehicle接口：

package com.li.proxy;

/**

 * @author 李

 * @version 1.0

 */

public class Ship implements Vehicle {

    @Override

    public void run() {

        System.out.println("交通工具开始运行了...");

        System.out.println("大轮船在水上 running...");

        System.out.println("交通工具停止运行了...");

    }

}

Car类，实现Vehicle接口：

package com.li.proxy;

/**

 * @author 李

 * @version 1.0

 */

public class Car implements Vehicle {

    @Override

    public void run() {

        System.out.println("交通工具开始运行了...");

        System.out.println("小汽车在公路 running...");

        System.out.println("交通工具停止运行了...");

    }

}

TestVehicle测试类：

package com.li.proxy;

import org.testng.annotations.Test;

/**

 * @author 李

 * @version 1.0

 */

public class TestVehicle {

    @Test

    public void run() {

        Vehicle vehicle = new Car();//Vehicle vehicle = new Ship();

        vehicle.run();//动态绑定，根据实际运行类型调用run方法

    }

}

上面的方式，代码冗余，其实就是单个对象的调用，并没有很好的解决问题。

2.3动态代理方式解决

解决思路：在调用方法的时候，使用反射机制，根据方法去决定调用哪个对象方法

Vehicle接口不变：

package com.li.proxy;

/**

 * @author 李

 * @version 1.0

 * 接口，定义了run方法

 */

public interface Vehicle {

    public void run();

}

Ship：

package com.li.proxy;

/**

 * @author 李

 * @version 1.0

 */

public class Ship implements Vehicle {

    @Override

    public void run() {

        System.out.println("大轮船在水上 running...");

    }

}

Car：

package com.li.proxy;

/**

 * @author 李

 * @version 1.0

 */

public class Car implements Vehicle {

    @Override

    public void run() {

        System.out.println("小汽车在公路 running...");

    }

}

创建VehicleProxyProvider，该类返回一个代理对象：

package com.li.proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

/**

 * @author 李

 * @version 1.0

 * VehicleProxyProvider类可以返回一个代理对象

 */

public class VehicleProxyProvider {

    //定义一个属性

    //target_vehicle 表示真正要执行的对象

    //要求该对象的类实现了Vehicle接口

    private Vehicle target_vehicle;

    //构造器

    public VehicleProxyProvider(Vehicle target_vehicle) {

        this.target_vehicle = target_vehicle;

    }

    //编写一个方法，可以返回一个代理对象

    public Vehicle getProxy() {

        //(1)得到类加载器

        ClassLoader classLoader =

                target_vehicle.getClass().getClassLoader();

        //(2)得到要代理的对象/被执行的对象 的接口信息，底层通过接口来完成调用

        Class<?>[] interfaces = target_vehicle.getClass().getInterfaces();

        //(3)创建一个调用处理对象

        /**

         *   public interface InvocationHandler {

         *      public Object invoke(Object proxy, Method method, Object[] args)

         *      throws Throwable;

         *   }

         *   invoke 方法在将来执行我们的 target_vehicle的方法时，会调用到

         */

        //如上，因为InvocationHandler是接口，不能直接实例化

        // 以匿名内部类的方式来获取 InvocationHandler 对象

        //这个对象有一个方法:invoke, 到时可以通过反射，动态调用目标对象的方法

        InvocationHandler invocationHandler = new InvocationHandler() {

            /**

             * invoke()方法，在将来执行我们的target_vehicle的方法时会调用到

             * @param proxy 表示代理对象

             * @param method 就是通过代理对象调用方法时，的哪个方法

             * @param args 表示调用代理对象的方法时，传入方法的参数

             * @return 表示代理对象.方法(xx) 执行后的结果

             * @throws Throwable

             */

            @Override

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("交通工具开始运行了...");

                //这个地方的方法,就是你调用时动态传入的,可能是 run , 可能是 hi 等

                Object result = method.invoke(target_vehicle, args);

                System.out.println("交通工具停止运行了...");

                return result;

            }

        };

        /*(4)

          public static Object newProxyInstance(ClassLoader loader,

                                                    Class<?>[] interfaces,

                                                    InvocationHandler h)

          1.Proxy.newProxyInstance() 可以返回一个代理对象

          2.ClassLoader loader ：类加载器

          3.Class<?>[] interfaces：要代理的对象的接口信息

          4.InvocationHandler h：调用处理器/对象，该对象有一个非常重要的方法-invoke

         */

        //将上面的 loader, interfaces, invocationHandler构建一个 Vehicle的代理对象.

        Vehicle proxy =

                (Vehicle) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);

        return proxy;

    }

}

TestVehicle测试类：

@Test

public void proxyRun(){

    //创建Ship对象

    Vehicle vehicle = new Ship();

    //创建VehicleProxyProvider对象，并且传入要代理的对象

    VehicleProxyProvider vehicleProxyProvider = new VehicleProxyProvider(vehicle);

    //获取代理对象，该对象可以代理执行方法

    //1.proxy 编译类型是Vehicle

    //2.proxy 运行类型是 代理类型: class com.sun.proxy.$Proxy3

    Vehicle proxy = vehicleProxyProvider.getProxy();

    System.out.println("proxy 的运行类型是="+proxy.getClass());

    proxy.run();

}

2.4动态代理机制debug

如上所示，当执行proxy.run();时，成功输出了目标信息，那么代码是怎么执行到代理对象的invoke方法上的？

1.在proxy.run();旁打上断点，点击step into，光标跳转至VehicleProxyProvider的invoke方法：

2.点击step over，光标跳转到下一行，此时method，target_vehicle代表了什么？

如上，此时的method就是我们Vehicle接口中的run方法，target_vehicle对象的实际运行类型是Ship，因为我们没有传值进去所以args为null。

3.在这行点击step into，进入invoke方法的源码，点击step over跳到return ma.invoke(obj, args);：

在这行点击step into：

可以看到，底层最终执行了invoke0()方法：

这里可以发现method 就是Vehicle的run方法，该方法会通过动态绑定，根据实际运行对象的类型（在这里即Ship），调用Ship中的run方法；var2就是我们调用代理对象的方法时传入的参数，这里为null：

4.在这行再次点击step into，可以看到光标跳转到了Ship对象的run方法中，此时调用了Ship中的run方法：

5.点击step over，因为底层代码执行完毕。光标层层返回到之前的method.invoke(target_vehicle,args)语句：

6.因为Ship的run方法返回void，因此result的值为null：

7.当执行到return result;时，相当于使用代理对象执行run方法执行完毕，因此返回上一层：

至此，总体的流程就执行完毕了。

总结梳理：

1.proxy的编译类型是Vehicle，因此可以调用run方法；proxy的运行类型是class com.sun.proxy.$Proxy3，所以当执行run方法时会执行到代理对象的invoke方法

2.invoke 方法使用反射机制来调用 run()方法（注意这个 run 方法也可以是Vehicle 的其它方法），这时就可以在调用 run()方法前，进行前置处理和后置处理

3.也就是说 proxy 的 target_vehicle 运行类型只要是实现了 Vehicle 接口，就可以去调用不同的方法，是动态的，变化的，底层就是使用反射完成的。

3.动态代理练习

3.1案例说明

需求说明：

有一个SmartAnimal接口，可以完成简单的加减法，要求在执行getSum()和getSub()时，输出执行前、执行过程、执行后的日志输出(参考如下)，请思考如何实现

方法执行开始-日志-方法名-getSub-参数 [10.0, 2.0]

方法内部打印 result = 8.0

方法执行正常结束-日志-方法名-getSub-结果 result= 8.0

//可能的异常信息

方法最终结束-日志-方法名-getSub//finally的输出

======================

方法执行开始-日志-方法名-getSum-参数 [10.0, 2.0]

方法内部打印 result = 12.0

方法执行正常结束-日志-方法名-getSum-结果 result= 12.0

//可能的异常信息

方法最终结束-日志-方法名-getSum//finally的输出

3.2传统方式解决

SmartAnimal接口：

package com.li.aop.proxy2;

/**

 * @author 李

 * @version 1.0

 */

public interface SmartAnimal {

    //求和

    float getSum(float a, float b);

    //求差

    float getSub(float a, float b);

}

SmartCat类实现接口SmartAnimal：

package com.li.aop.proxy2;

/**

 * @author 李

 * @version 1.0

 */

public class SmartCat implements SmartAnimal {

    @Override

    public float getSum(float a, float b) {

        System.out.println("日志-方法名-getSum-参数 " + a + " " + b);

        float result = a + b;

        System.out.println("方法内部打印 result = " + result);

        System.out.println("日志-方法名-getSum-结果result= " + result);

        return result;

    }

    @Override

    public float getSub(float a, float b) {

        System.out.println("日志-方法名-getSub-参数 " + a + " " + b);

        float result = a - b;

        System.out.println("方法内部打印 result = " + result);

        System.out.println("日志-方法名-getSub-结果result= " + result);

        return result;

    }

}

AopTest测试类：

package com.li.aop.proxy2;

import org.testng.annotations.Test;

/**

 * @author 李

 * @version 1.0

 */

public class AopTest {

    @Test

    public void testSmartAnimal() {

        SmartAnimal smartAnimal = new SmartCat();

        smartAnimal.getSum(10, 2);

        System.out.println("=======================");

        smartAnimal.getSub(10, 2);

    }

}

传统方法的特点：

优点：实现简单直接

缺点：日志代码维护不方便，代码复用性差

解决思路：

3.3动态代理方法解决

SmartAnimal接口不变。

SmartDog实现SmartAnimal接口：

package com.li.aop.proxy2;

/**

 * @author 李

 * @version 1.0

 */

public class SmartDog implements SmartAnimal {

    @Override

    public float getSum(float a, float b) {

        float result = a + b;

        System.out.println("方法内部打印 result = " + result);

        return result;

    }

    @Override

    public float getSub(float a, float b) {

        float result = a - b;

        System.out.println("方法内部打印 result = " + result);

        return result;

    }

}

MyProxyProvider类：

package com.li.aop.proxy2;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Arrays;

/**

 * @author 李

 * @version 1.0

 * 返回一个动态代理对象，可以执行被代理的对象的方法

 */

public class MyProxyProvider {

    //定义要执行的目标对象，该对象需要实现 SmartAnimal接口

    private SmartAnimal target_animal;

    //构造器

    public MyProxyProvider(SmartAnimal target_animal) {

        this.target_animal = target_animal;

    }

    //定义方法返回代理对象，该代理对象可以执行目标对象

    public SmartAnimal getProxy() {

        //(1)先得到类加载器对象

        ClassLoader classLoader = target_animal.getClass().getClassLoader();

        //(2)得到要执行的目标对象的接口信息

        Class<?>[] interfaces = target_animal.getClass().getInterfaces();

        //(3)使用匿名内部类 创建 InvocationHandler对象

        InvocationHandler invocationHandler = new InvocationHandler() {

            @Override

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                Object result = null;

                try {

                    System.out.println("方法执行开始-日志-方法名-" + method.getName() +

                            "-参数 " + Arrays.toString(args));//这里从AOP的角度看，就是一个横切关注点-前置通知

                    //使用反射真正调用方法

                    result = method.invoke(target_animal, args);

                    System.out.println("方法执行正常结束-日志-方法名-" + method.getName()

                            + "-结果 result = " + result);//也是一个横切关注点-返回通知

                } catch (Exception e) {

                    //如果反射出现异常，就会进入到catch块

                    System.out.println("方法执行异常-日志-方法名" + method.getName()

                            + "-异常类型=" + e.getClass().getName());//也是一个横切关注点-异常通知

                    e.printStackTrace();

                } finally {//无论是否出现异常，最终都会执行到 finally{}

                    //也是一个横切关注点-最终通知

                    System.out.println("方法最终结束-日志-方法名-" + method.getName());

                }

                return result;

            }

        };

        //(4)创建代理对象

        SmartAnimal proxy = (SmartAnimal) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);

        return proxy;

    }

}

测试方法：

@Test

public void testSmartAnimal() {

    SmartAnimal smartAnimal = new SmartDog();

    MyProxyProvider myProxyProvider

            = new MyProxyProvider(smartAnimal);

    SmartAnimal proxy = myProxyProvider.getProxy();

    proxy.getSum(10, 2);

    System.out.println("=======================");

    proxy.getSub(10, 2);

}

3.4问题提出

在MyProxyProvider类中，我们的输出语句功能比较弱，在实际开发中，我们希望是以一个方法的形式，嵌入到真正执行的目标方法前，怎么办？

day08-AOP-01

AOP

1.官方文档

2.动态代理

2.1案例说明

2.2传统方式解决

2.3动态代理方式解决

2.4动态代理机制debug

3.动态代理练习

3.1案例说明

3.2传统方式解决

3.3动态代理方法解决

3.4问题提出

day08-AOP-01的相关教程结束。

相关推荐

SpringBoot AOP @Pointcut切入点表达式排除某些类方式是什么

在springboot中怎么使用AOP进行全局日志记录

springAop如何实现权限管理数据校验操作日志

SpringBoot2.0 基础案例(11)：配置AOP切面编程，解决日志记录业务

day08-SpringCloud Gateway-服务网关

Spring AOP 分享

day08-优惠券秒杀04

AOP在大规模软件开发项目中的应用(图)