Spring AOP的实现思想之动态代理

学习过Spring AOP后，对其实现的原理有了基本的了解，明白其核心是动态代理机制，通过匿名内部类方法对条件进行拦截，达到了切面编程的效果。那么，具体的实现过程是怎样的呢？

 

首先假设我们有一个演员，通过签约的经济公司从事各种表演活动养家糊口，定义一个接口IActor

/**
 * 经济公司对签约艺人的标准
 */
public interface IActor {

    void basicAct(float money);

    void dangerAct(float money);

}

 

接下来，创建一个演员类Actor实现接口IActor的方法

/**
 * 一个演员
 */
public class Actor implements IActor{

    /**
     * 基础的演出
     * @param money
     */
    public void basicAct(float money){
        System.out.println("拿到钱，开始基本的表演：" + money);
    }

    /**
     * 危险的表演
     * @param money
     */
    public void dangerAct(float money){
        System.out.println("拿到钱，开始危险的表演：" + money);
    }

}

进行了基本的约定后，演员该开始赚钱了。

假设演员加入了一个剧组，因为是经济公司对外签约，并提供演员演出，所以是由经济公司出面与剧组进行签约，并且在拿到钱后抽成。经济公司在这里通过动态代理的核心，是实现了InvocationHandler接口，实现了invoke()方法进行代理对象的回调。

/**
 * 模拟一个剧组
 */
public class Client {

    public static void main(String[] args){

        final Actor actor = new Actor();

        /**
         * 动态代理：
         *  作用：不改变源码的基础上，对已有方法增加。（是AOP思想的实现技术）
         *  分类：
         *      1、基于接口的动态代理：
         *          要求：被代理类至少实现一个接口
         *          提供者：JDK
         *          涉及的类：Proxy
         *          创建代理对象的方法：
         *          newProxyInstance(ClassLoader,Class[],InvocationHandler)
         *          参数的含义：
         *              ClassLoader：类加载器。和被代理对象实现相同的类加载器。一般是固定写法：xxx.getClass().getClassLoader()
         *              Class[]：字节码数组。被代理类实现的接口，要求代理对象和被代理对象具有相同的行为。一般是固定写法：xxx.getClass().getInterfaces()
         *              InvocationHandler：是一个接口，用于我们提供增强代码的地方。一般是写一个该接口的实现类，实现类可以是匿名内部类
         *                                 含义：如何代理。此处的代码只能是谁用谁提供。
         */


        IActor proxyActor = (IActor) Proxy.newProxyInstance(actor.getClass().getClassLoader(),
                actor.getClass().getInterfaces(), new InvocationHandler() {
                    /**
                     * 执行被代理对象的任何方法都会经过该方法，该方法有拦截的功能
                     * @param proxy：代理对象的引用。不一定每次都会有。
                     * @param method：当前执行的方法。
                     * @param args：当前执行方法所需的参数。
                     * @return 当前执行方法的返回值
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object returnValue = null;
                        //1.取出执行方法中的参数：给的多少钱
                        Float money = (Float) args[0];
                        //2.判断当前执行的是什么方法
                        if ("basicAct".equals(method.getName())){
                            //基本演出
                            if (money > 10000){
                                //执行方法
                                returnValue = method.invoke(actor,money);
                            }
                        }
                        if ("dangerAct".equals(method.getName())){
                            //危险演出
                            if (money > 50000){
                                //执行方法
                                returnValue = method.invoke(actor,money);
                            }
                        }

                        return returnValue;
                    }
                });

        proxyActor.basicAct(15000);
        proxyActor.dangerAct(66666);

    }

}

 

转载于:https://www.cnblogs.com/zbb2161228/p/10424878.html