Spring的静态代理和动态代理

文章目录
一、前言
二、分类
2.1、静态代理
2.2、动态代理
2.2.1、分类
2.2.2、对比
三、实现
3.1 静态代理
3.1 动态代理
3.1.1基于jdk的动态代理
3.1.2基于cglib的动态代理
四、结语
一、前言
        开始接触代理是在设计模式动态代理中了解的,大概是这样的:张三喜欢一个女孩,但是她不敢表白怎么办,很简单,他找李四帮他去表白。这里李四就是代理对象,代替张三干活,可以看下面的画面:

        慢慢积累之后,发现很多经典的框架背后都使用了代理的模式,例如Spring的AOP实现原理便是动态代理;常用的ORM模型中mybatis框架实现原理也是动态代理;事务的实现原理反射+动态代理;dubbo的实现中也有动态代理…很多很多,我们可以得出的结论是熟悉代理以及熟悉动态代理的重要性。代理模式是:通过代理控制对目标对象的访问,下面是代理类图,我们先对代理有个整体认识。


二、分类
       代理分为静态代理和动态代理,他们的区别是静态代理有真实的代理类存在,就是我们会代码中创建一个代理类,并在代理类的方法中调用目标对象的方法,以此来完成代理的工作。动态代理的代理类没有在代码中创建一个代理类,而是在运行时在JVM里面创建代理对象。

2.1、静态代理
       我们知道静态代理是有实实在在的代理类存在,并且和目标类实现相同的接口。他的特点是效率高,因为所有的类都是已经编写完成的,客户端只需要取得代理对象并且执行即可,同时他可以实现对目标对象中指定的方法进行增强。但是他也有如下缺点:

与目标类实现相同的接口代码冗余
如果接口发生改变,代理类中的方法也要修改
代理类服务于一种类型的对象,如果要服务多类型的对象,那么势必要为每种类型的对象都生成代理类
2.2、动态代理
       与静态代理的硬编码方式相比,动态代理支持运行时动态生成代理对象这种方式。动态代理能用很少的代码对一个类的所有方法实现一样的增强效果,但是不能增强其中的某一个方法,他的好处很明显,在编码时代理逻辑与业务逻辑互相独立,各不影响,减少侵入,降低耦合。

2.2.1、分类
       动态代理可以分为两种,一种是基于JDk的动态代理一种是基于CGLIB的动态代理。在spring中使用他们的区别是:当目标对象有实现接口时,默认使用jdk动态代理的方式,当目标类没有实现接口时使用cglib的动态代理方式,并且代理对象以目标对象为父类。

2.2.2、对比
       

jdk    cglib
依赖    基于spring,不需要引用    需要引用第三方类库
方式    有实现的接口,常见是mybatis的mapper文件是代理    没有,原理目标对象作为父类
对targetObject要求    实现接口    不能用final修饰
生成对象的技术    反射,使用了动态生成字节码技术    使用字节码技术,使用了动态生成字节码技术
三、实现
       没有代码的讲理论等于耍流氓,下面分享一下我在实践中的code,同时进行适当的补充。

3.1 静态代理
       有代理类,实实在在的存在代理类,是动态代理的理论基础,这里有一个work接口,接口中有一个唱歌的方法,我们想通过访问经纪人(代理对象)来达到让明星(目标对象)唱歌的方法。

//接口
public interface Work {
    void sing();
}
1
2
3
4
//目标对象
public class TargetObj implements Work {
    @Override
    public void sing() {
        System.out.println("明星在唱歌");;
    }
}
1
2
3
4
5
6
7
//代理对象
public class ProxyObj implements Work {
    Work obj=null;
    public ProxyObj() {
        obj=new TargetObj();
    }

    @Override
    public void sing() {
        System.out.println("先到经济人");
        obj.sing();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
3.1 动态代理
3.1.1基于jdk的动态代理
//接口
public interface Work {
    void sing();
}
1
2
3
4
//目标对象
public class TargetObj implements Work {
    @Override
    public void sing() {
        System.out.println("明星在唱歌");;
    }
}
1
2
3
4
5
6
7
public class MainTest {
    //JDK方式发的动态代理
    public static void main(String[] args) {
        //1.创建真实的对象
        Work targetObj=new TargetObj();
        //2.创建代理对象
        Work proxyObj = (Work) Proxy.newProxyInstance( 
                targetObj.getClass().getClassLoader(),//真实类使用什么类加载器
                targetObj.getClass().getInterfaces(),//真实实现的接口
                new InvocationHandler() { //调用处理器
                    /**
                     * 处理器的方法
                     * @param proxy 参数一:代理对象,一般不会使用
                     * @param method 参数二:外面的代理对象调用的方法引用,代理对象.sing(),method便是sing这个方法的引用
                     * @param args 参数三:外面的代理对象调用的方法里面的参数。代理对象.sing(“参数"),args就是“参数”
                     * @return
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //反射调用
                        return method.invoke(targetObj,args);//方法的返回参数
                    }
                }
        );
        //3让代理工作
        proxyObj.sing("北冰洋");
    }
}
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
       从代码中我们可以get到两点

基于jdk的动态代理需要有实现的接口
动态代理的核心:是创建了处理器 InvocationHandler实例
在调用目标对象时,会调用代理对象,代理对象中请求目标对象,invoke方法便是调用目标对象的方法生成代理对象的过程,同时增强工作也是在invoke方法中进行的。
3.1.2基于cglib的动态代理
<!-- https://mvnrepository.com/artifact/cglib/cglib -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.12</version>
        </dependency>
1
2
3
4
5
6
public class TargetObj2  {
    public String sing(String args) {
        System.out.println("明星在唱歌");
        return args;
    }
    public void dance() {
        System.out.println("明星在跳舞");
    }
}
1
2
3
4
5
6
7
8
9
public class MainTest {
    public static void main(String[] args) {
        //1.真实对象
        TargetObj2 targetObj2=new TargetObj2();
        //2.创建代理对象
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(targetObj2.getClass());
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                //增强功能
                System.out.println("123");
                return method.invoke(targetObj2,objects);
            }
        });
        //创建代理
        TargetObj2 proxyObj = (TargetObj2) enhancer.create();
        //让代理工作
        String ret= proxyObj.sing("丁香花");
        System.out.println(ret);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
       从cglib中我们可以get到两点

基于cglib的动态代理是没有实现接口的,他是以目标类作为代理类的父类
cglib动态代理的关键是基于enhancer.setCallback方法,和其中的MethodInterceptor() 方法
在MethodInterceptor实例中重写intercept方法中调用invoke方法设置代理对象,最后通过enhancer.create()创建代理对象。
四、结语
       理论知识会比较空洞和抽象,但是实践一下我们会有不一样的收获。
       感谢您宝贵的阅读时间。
--------------------- 
作者:Viola_tt 
来源:CSDN 
原文:https://blog.csdn.net/SweetyoYY/article/details/90743578 
版权声明:本文为博主原创文章,转载请附上博文链接!

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值