Spring的静态代理和动态代理

超、凢脫俗 2021-12-10 05:39 276阅读 0赞

文章目录  
一、前言  
二、分类  
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的动态代理  
  
        <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   
版权声明：本文为博主原创文章，转载请附上博文链接！