细说Spring——AOP详解（动态代理实现AOP）

前言

嗯，我应该是有一段实现没有写过博客了，在写完了细说Spring——AOP详解（AOP概览）之后，我发现我不知道该怎么写AOP这一部分，所以就把写博客这件事给放下了，但是这件事情又不想就这么放弃，所以今天我仔细思考了一下，决定还是要克服困难，我仔细的想了一下怎么讲解AOP实现这一部分，然后我决定由浅入深的讲解动态代理，然后用动态代理实现一个简单的AOP，感觉这样能够让人对AOP的原理有一个比较深刻的认识，希望能帮到大家。而且最近学习又组建了ACM比赛的队伍，虽然已经要大三了，按理来说应该一心学习Java Web的开发，可是我对算法也有一定的兴趣，并且之前也确实花过一段时间练习算法题，所以还是决定要参加一下，所以写博客可能就会慢一点吧。

一、什么是动态代理

动态代理其实就是Java中的一个方法，这个方法可以实现：动态创建一组指定的接口的实现对象（在运行时，创建实现了指定的一组接口的对象）
这里声明一下，本篇博客中会使用很多AOP中的术语，所以如果看不懂术语的话一定要先看一下细说Spring——AOP详解（AOP概览）
例如：

interface A {}
interface B {}
//obj对象的类型实现了A和B两个接口
Object obj = 方法(new Class[]{A.class, B.class})

二、动态代理初体验

我们根据上面的思路来体验一下Java中的动态代理吧，首先我们要先写两个接口。

interface A {
    public void a();
}
interface B {
    public void b();
}

然后我们就先来看一下动态代理的代码：

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)

上面这个就是动态代理类（Proxy）类中的创建代理对象的方法，下面介绍一下方法的三个参数：

  • ClassLoader loader：方法需要动态生成一个类，这个类实现了A和B两个接口，然后创建这个类的对象。需要生成一个类，而且这个类也需要加载到方法区中，所以我们需要一个ClassLoader来加载该类
  • Class<?>[] interfaces：我们需要代理对象实现的数组
  • InvocationHandler h：调用处理器

这里你可能对InvocationHandler有疑惑，这里先买个关子，下面马上揭晓。
我们现在就使用动态代理创建一个代理对象吧。

@Test
    public void test1() {
        /**
         * 三个参数
         * 1、ClassLoader
         * 方法需要动态生成一个类，这个类实现了A和B两个接口，然后创建这个类的对象
         * 需要生成一个类，这个类也需要加载到方法区中，所以我们需要一个ClassLoader来加载该类
         *
         * 2、Class[] interfaces
         * 我们需要代理对象实现的数组
         *
         * 3、InvocationHandler
         * 调用处理器
         */
        ClassLoader classLoader = this.getClass().getClassLoader();
        //这里创建一个空实现的调用处理器。
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        };
        Object obj = Proxy.newProxyInstance(classLoader, new Class[]{A.class, B.class}, invocationHandler);
        //强转为A和B接口类型，说明生成的代理对象实现了A和B接口
        A a = (A) obj;
        B b = (B) obj;
    }

经过测试代码运行成功，说明生成的代理对象确实实现了A接口和B接口，但是我想你一定会对代理对象如何实现了A接口和B接口感兴趣，你一定想知道如果使用代理对象调用相应接口的方法会发生什么感兴趣，下面我们一起来探究一下：

上面代码的基础上加上下面的代码
a.a();
b.b();

这里写图片描述

我们可以发现什么也没有发生。这是因为我们根本没有为代理对象添加实现逻辑。可是实现逻辑添加在哪里呢？哈哈，当然是InvocationHandler中了。下面就看一看添加了实现逻辑的代码：

 @Test
    public void test2() {
        /**
         * 三个参数
         * 1、ClassLoader
         * 方法需要动态生成一个类，这个类实现了A和B两个接口，然后创建这个类的对象
         * 需要生成一个类，这个类也需要加载到方法区中，所以我们需要一个ClassLoader来加载该类
         *
         * 2、Class[] interfaces
         * 我们需要代理对象实现的数组
         *
         * 3、InvocationHandler
         * 调用处理器
         *
         * 代理对象实现的所有接口中的方法，内容都是调用InvocationHandler的invoke()方法
         */
        ClassLoader classLoader = this.getClass().getClassLoader();
        //这里创建一个空实现的调用处理器。
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("你好！！！！");//注意这里添加了一点小逻辑
                return null;
            }
        };
        Object obj = Proxy.newProxyInstance(classLoader, new Class[]{A.class, B.class}, invocationHandler);
        //强转为A和B接口类型，说明生成的代理对象实现了A和B接口
        A a = (A) obj;
        B b = (B) obj;

        a.a();
        b.b();
    }

截图如下：

这里写图片描述

这里我们发现A接口和B接口的实现逻辑都是调用了invoke这个方法中的逻辑，其实除了调用代理对象的native方法，调用代理对象的其他所有方法本质都是调用了invoke方法，下面我们再来看第三个实例，让我们对动态代理有更深刻的认识。

public void test3() {
        /**
         * 三个参数
         * 1、ClassLoader
         * 方法需要动态生成一个类，这个类实现了A和B两个接口，然后创建这个类的对象
         * 需要生成一个类，这个类也需要加载到方法区中，所以我们需要一个ClassLoader来加载该类
         *
         * 2、Class[] interfaces
         * 我们需要代理对象实现的数组
         *
         * 3、InvocationHandler
         * 调用处理器
         *
         * 代理对象实现的所有接口中的方法，内容都是调用InvocationHandler的invoke()方法
         */
        ClassLoader classLoader = this.getClass().getClassLoader();
        //这里创建一个空实现的调用处理器。
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("你好！！！！");
                return "Hello";//这里改为返回"Hello"
            }
        };
        Object obj = Proxy.newProxyInstance(classLoader, new Class[]{A.class, B.class}, invocationHandler);
        //强转为A和B接口类型，说明生成的代理对象实现了A和B接口
        A a = (A) obj;
        B b = (B) obj;
        a.toString();//注意这里调用了toString()方法
        b.getClass();//注意这里调用了getClass()方法
        //这里在A接口中添加了一个方法public Object aaa(String s1, int i);
        Object hello = a.aaa("Hello", 100);
        System.out.println(obj.getClass());//这里看一下代理对象是什么
        System.out.println(hello);//这里看一下返回值是什么

    }

这里写图片描述

通过代码的结果我们大胆的猜测一下，代理对象方法的返回值其实就是invoke方法的返回值，代理对象其实就是使用反射机制实现的一个运行时对象。哈哈，当然这些肯定不是猜测了，其实确实就是这样。下面是时候总结一下InvocationHandler的invoke方法了。如下图所示：
这里写图片描述

当我们调用代理对象的方法时，其对应关系就如上图所示。

三、初步实现AOP

在我们对动态代理有了一定的认识之后，我们就可以实现最基本版本的AOP了，当然，这是一个非常残缺的AOP实现，甚至都不能称之为AOP实现。
我们先写一个接口：

package demo2;

/**
 * Created by Yifan Jia on 2018/6/5.
 */
//服务生
public interface Waiter {
    //服务方法
    public void server();
}

然后给出该接口的实现类：

package demo2;

/**
 * Created by Yifan Jia on 2018/6/5.
 */
public class ManWaiter implements Waiter {

    @Override
    public void server() {
        System.out.println("服务中");
    }
}

然后我们就通过动态代理来对上面的ManWaiter进行增强：

package demo2;

import org.junit.Test;

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

/**
 * Created by Yifan Jia on 2018/6/5.
 */

public class Demo2 {
    @Test
    public void test1() {
        Waiter waiter = new ManWaiter();
        waiter.server();
    }

    @Test
    public void test2() {
        Waiter manWaiter = new ManWaiter();
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class[] interfaces = {Waiter.class};
        InvocationHandler invocationHandler = new WaiterInvocationHandler(manWaiter);
        //得到代理对象，代理对象就是在目标对象的基础上进行了增强的对象
        Waiter waiter = (Waiter) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        waiter.server();//前面添加“你好”，后面添加“再见”
    }
}

class WaiterInvocationHandler implements InvocationHandler {

    private Waiter waiter;

    WaiterInvocationHandler(Waiter waiter) {
        this.waiter = waiter;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("你好");
        waiter.server();//调用目标对象的方法
        System.out.println("再见");
        return null;
    }
}

结果如下：

这里写图片描述

你肯定要说了，这算什么AOP，增强的代码都是硬编码到invoke方法中的，大家稍安勿躁，我们不是已经对需要增强的对象做了增强吗。这里可以的目标对象为manWaiter，增强为System.out.println("你好");和System.out.println("再见");，切点为server()方法调用。其实还是可以看做一下原始的AOP的。

四、完善的AOP实现

我们从初步实现的AOP中可以发现很多问题，比如我们不能把增强的逻辑硬编码到代码中，我们需要实现可变的增强，下面我们就解决一下这些问题，来实现一个比较完善的AOP。
我们仍然引用上面的Waiter接口和Manwaiter实现类。
然后我们添加一个前置增强接口：

/**
 * 前置增强
 */
public interface BeforeAdvice {
    public void before();
}

再添加一个后置增强接口：

public interface AfterAdvice {
    public void after();
}

我们把产生代理对象的代码封装为一个类：

package demo3;

import com.sun.org.apache.regexp.internal.RE;
import org.junit.After;

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

/**
 * ProxFactory用来生成代理对象
 * 它需要所有的参数：目标对象，增强，
 * Created by Yifan Jia on 2018/6/5.
 */

/**
 * 1、创建代理工厂
 * 2、给工厂设置目标对象、前置增强、后置增强
 * 3、调用creatProxy()得到代理对象
 * 4、执行代理对象方法时，先执行前置增强，然后是目标方法，最后是后置增强
 */
//其实在Spring中的AOP的动态代理实现的一个织入器也是叫做ProxyFactory 
public class ProxyFactory {
    private Object targetObject;//目标对象
    private BeforeAdvice beforeAdvice;//前值增强
    private AfterAdvice afterAdvice;//后置增强

    /**
     * 用来生成代理对象
     * @return
     */
    public Object creatProxy() {
        /**
         * 给出三个参数
         */
        ClassLoader classLoader = this.getClass().getClassLoader();
        //获取当前类型所实现的所有接口类型
        Class[] interfaces = targetObject.getClass().getInterfaces();

        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /**
                 * 在调用代理对象的方法时，会执行这里的内容
                 */
                if(beforeAdvice != null) {
                    beforeAdvice.before();
                }
                Object result = method.invoke(targetObject, args);//调用目标对象的目标方法
                //执行后续增强
                afterAdvice.after();

                //返回目标对象的返回值
                return result;
            }
        };
        /**
         * 2、得到代理对象
         */
        Object proxyObject = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        return proxyObject;

    }
//get和set方法略
}

然后我们将相关的参数注入到ProxyFactory后就可以通过creatProxy()方法获取代理对象了，代码如下：

package demo3;

import org.junit.Test;

/**
 * Created by Yifan Jia on 2018/6/5.
 */
public class Demo3 {
    @Test
    public void tset1() {

        ProxyFactory proxyFactory = new ProxyFactory();//创建工厂
        proxyFactory.setTargetObject(new ManWaiter());//设置目标对象
        //设置前置增强
        proxyFactory.setBeforeAdvice(new BeforeAdvice() {
            @Override
            public void before() {
                System.out.println("客户你好");
            }
        });
        //设置后置增强
        proxyFactory.setAfterAdvice(new AfterAdvice() {
            @Override
            public void after() {
                System.out.println("客户再见");
            }
        });
        Waiter waiter = (Waiter) proxyFactory.creatProxy();
        waiter.server();

    }
}

结果如下：


这里写图片描述

这时候我们已经可以自定义任意的增强逻辑了，是不是很神奇。

五、动态代理实现AOP总结

通过上面的内容，我们已经通过动态代理实现了一个非常简陋的AOP，这里的AOP实现还是有很多的不足之处。下面我把Spring中的ProxyFactory实现贴出来，大家可以研究一下Spring中的ProxyFactory的优势在哪里，另外，Spring中还有其他的基于动态代理实现的织入器，ProxyFactory只是其中最基础的版本，大家有兴趣可以研究一下。

public class ProxyFactory extends ProxyCreatorSupport {
    public ProxyFactory() {
    }

    public ProxyFactory(Object target) {
        Assert.notNull(target, "Target object must not be null");
        this.setInterfaces(ClassUtils.getAllInterfaces(target));
        this.setTarget(target);
    }

    public ProxyFactory(Class... proxyInterfaces) {
        this.setInterfaces(proxyInterfaces);
    }

    public ProxyFactory(Class<?> proxyInterface, Interceptor interceptor) {
        this.addInterface(proxyInterface);
        this.addAdvice(interceptor);
    }

    public ProxyFactory(Class<?> proxyInterface, TargetSource targetSource) {
        this.addInterface(proxyInterface);
        this.setTargetSource(targetSource);
    }

    public Object getProxy() {
        return this.createAopProxy().getProxy();
    }

    public Object getProxy(ClassLoader classLoader) {
        return this.createAopProxy().getProxy(classLoader);
    }

    public static <T> T getProxy(Class<T> proxyInterface, Interceptor interceptor) {
        return (new ProxyFactory(proxyInterface, interceptor)).getProxy();
    }

    public static <T> T getProxy(Class<T> proxyInterface, TargetSource targetSource) {
        return (new ProxyFactory(proxyInterface, targetSource)).getProxy();
    }

    public static Object getProxy(TargetSource targetSource) {
        if(targetSource.getTargetClass() == null) {
            throw new IllegalArgumentException("Cannot create class proxy for TargetSource with null target class");
        } else {
            ProxyFactory proxyFactory = new ProxyFactory();
            proxyFactory.setTargetSource(targetSource);
            proxyFactory.setProxyTargetClass(true);
            return proxyFactory.getProxy();
        }
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,793评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,567评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,342评论 0赞 338
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,825评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,814评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,680评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,033评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,687评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 42,175评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,668评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,775评论 1赞 332
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,419评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,020评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,978评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,206评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,092评论 2赞 351
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,510评论 2赞 343