代理设计模式

发表于 | 分类于

关于代理设计模式,很多时候都是使用这种机制针对特定的对象进行增强,说白了就是在目标方法执行前后执行我们新添加的逻辑,达到增强的目的

尤其是Spring中,我们通过@Configration注解把对象的创建权反转给spring,当我们再问spring索要对象的时候,返回给我们的其实是被cglib代理过的对象,而且AOP底层大规模使用cglib字节码代理生成技术:

真想把SpringAOP整的明明白白,想从底层去一行一行看Spring的代理,一定会疯掉!!! 随便打开一个类,就能看他有父类,父类还有父类,爷爷更变态,不仅有父亲还有接口, 我们知道,对象的创建是会调用父亲的构造方法的,这些东西全得看,不疯? 才怪,整的我都想以头抢地了

好,言归正传,重点认识cglib,基于字节码的动态代理技术的使用

  • 虚拟代理:

虚拟代理是 被代理对象的替身,真正的对象在创建前和创建中时,由虚拟代理替代他的位置,比如:我们用手机浏览图片,假如网络不好,就会出现一个圈圈在转动,或者一个默认的图片代替目标图片

  • 动态代理
    • jdk动态代理
    • cglib动态代理

区别:

jdk动态代理是是有限制的,就是被代理的类必须实现了接口(然后代理对象也会实现那个接口,两者知根知底,进而有代理增强的可能,我在前几篇博客 反射与动态代理 中有写具体的使用)

cflib,比较灵活,它认被代理的对象为父,从而不管被代理的类是否实现了接口

坐标

1
2
3
4
5
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.10</version>
</dependency>

被代理的类

1
2
3
4
5
6
7
8
9
10
11
12
public class MyService {

    public String firstTask(){
        System.out.println("第一个任务执行....");
        return "one";
    }
    public String secondTask(){
        System.out.println("第二个任务执行....");
        return "second";
    }

}

代理逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class MyCglib implements MethodInterceptor {

    private MyService target;

    public MyCglib() {
    }

    public MyCglib(MyService target) {
        this.target = target;
    }

    public MyService myCglibCreator() {
        // 获取增强子对象
        Enhancer enhancer = new Enhancer();

        // 初始化增强子对象   -- 把目标类 指定为父类 ( 这里就涉及到了
        // cglib的增强思想,它把我们当前的类当作父类,进而添加新的方法达到增强的目的,  --- 子类增强父类
        //    ---->  因此,我们的cglib 是不能对final类进行代理的!!!
        // 而jdk动态代理则是大家都实现同一个接口,我对你知根知底,进而增强你
        enhancer.setSuperclass(MyService.class);

        // 设置回调接口对象 ,  接受一个CallBack类型的,我们当前类已经实现了
        enhancer.setCallback(this);  

        // 创建cglib 动态代理对象 (向上转型)
        return (MyService) enhancer.create();
    }

    /**
     * 回调接口的方法
     * 方法执行的时机:
     * 代理对象执行目标方法时,会触发该方法的执行
     */
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 执行目标方法
        Object invoke = method.invoke(obj, args);
        // 执行增强的方法
        if (null != invoke) {
            invoke = ((String) invoke).toUpperCase();
        }
        // 我们用获取到的代理对象调用目标方法,会触发代理的回调机制,执行当前的 拦截方法,
        // 返回值就是 目标方法的返回值, 
        return invoke;
    }

}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MyText {
    public static void main(String[] args) {
        // 创建需要代理的对象
        MyService myService = new MyService();
        // 获取代理对象
        MyService proService = new MyCglib(myService).myCglibCreator();

        String s1 = proService.firstTask();
        System.out.println(s1);

        String s2 = proService.secondTask();
        System.out.println(s2);
    }
}