静态代理和动态代理（JDK和CGLIB）的区别

怼烎@ 2023-06-06 03:46 18阅读 0赞

# 代理模式的优点： #

1：保护了被代理对象

2：可以是被代理的对象专注于自己的业务。

3:可以在被代理的对象上添加额外的业务，并不破坏原有的业务。

静态代理：

（租房例子  房东：被代理的对象  ，中介：代理对象 ）

1：需要创建租房接口：

package com.bjsxt.proxy1;
    
    public interface LetRoom {
    
          public    void  zf();
    
    }

两个房东：

package com.bjsxt.proxy1;
    
    public class FD implements  LetRoom {
    
    
        @Override
        public void zf() {
    
            System.out.println("出租赛迪工业园4号楼1层");
    
        }
    }

package com.bjsxt.proxy1;
    
    public class FD2 implements  LetRoom {
    
    
        @Override
        public void zf() {
    
            System.out.println("出租赛迪工业园4号楼3层");
    
        }
    }

中介：可以额外的拓展自己的业务，并且保护被代理对象。通过价格来区别不同的房东（if  else）

package com.bjsxt.proxy1;
    
    public class ZJ implements LetRoom {
    
        private  int  money;
    
        public ZJ(int money) {
            this.money = money;
        }
    
        @Override
        public void zf() {
    
            System.out.println("--收取介绍费500元--");
    
            if(money>3000){
                //中介最后出租的房子还是房东的房子
                new FD().zf();
            }else {
    
                new FD2().zf();
            }
    
    
    
            System.out.println("--赚取房屋差价1000元--");
    
        }
    }

租房：

package com.bjsxt.proxy1;
    
    public class MyRentRoom {
    
        public static void main(String[] args) {
    
            ZJ  zj =new ZJ(4500);
    
            zj.zf();
    
    
        }
    }

可以看出来，当租客比较少的情况下，使用静态代理可以实现租房的过程，但是我们仔细想想，当房东（被代理对象）过多，中介（代理对象）中就会加入大量的if，else语句来区别不同的被代理对象。就会导致大量的代码冗余。这个时候，我没就需要引入动态代理。

## 动态代理: ##

3.1 底层是根据反射实现的.

3.2 只要给代理对象传递被代理对象,直接调用被代理对象中方法

### JDK动态代理： ###

**先实现住房接口：**

package com.bjsxt.proxy2;
    
    public interface LetRoom {
    
          public    void  zf();
    
    }

**两个房东：**

package com.bjsxt.proxy2;
    
    
    public class FD implements  LetRoom {
    
        @Override
        public void zf() {
    
            System.out.println("出租赛迪工业园4号楼1层");
        }
    }

package com.bjsxt.proxy2;
    
    
    public class FD2 implements  LetRoom {
    
    
        @Override
        public void zf() {
    
            System.out.println("出租赛迪工业园4号楼3层");
    
        }
    }

**动态代理对象：**

package com.bjsxt.proxy2;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    //会动态的产生代理对象
    public class MyInv  implements InvocationHandler {
    
        private  LetRoom  lr;
    
        public MyInv(LetRoom lr) {
            this.lr = lr;
        }
    
        public  Object  getProxy(){
    
            /**
             * ClassLoader:只要给定一个ClassLoader类型的即可
             *
             * Class<?>[]:需要产生接口的数组
             *
             * InvocationHandler
             *
             * */
           return   Proxy.newProxyInstance(MyInv.class.getClassLoader(),new Class[]{LetRoom.class},this);
    
        }
    
    
    
        //这个方法就是暴露给用户的租房方法
    
        /**
         * proxy:代理对象
         *
         * method：代理对象的方法
         *
         * args：null
         *
         * */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    
            System.out.println("--收取介绍费500元--");
    
            //调用房东的租房方法
            Object invoke = method.invoke(lr, args);
    
            System.out.println("--收取房屋差价1000元--");
    
            return invoke;
        }
    }

租房：

package com.bjsxt.proxy2;
    
    public class TestA {
    
        public static void main(String[] args) {
    
            MyInv  m=new MyInv(new FD2());
    
            //返回的就是动态产生的中介对象
            LetRoom proxy = (LetRoom) m.getProxy();
    
            //调用的是中介的租房
            proxy.zf();
    
            Util.writeProxyClassToHardDisk("E:/$Proxy11.class",new FD2().getClass().getInterfaces() );
    
    
    
        }
    }

**查看源码需要的util类：**

package com.bjsxt.proxy2;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    import sun.misc.ProxyGenerator;
    
    public class Util {
    	
    	  
    	  
        /** 
         *  Util.writeProxyClassToHardDisk("E:/$Proxy11.class",new FD1().getClass().getInterfaces() );
         */  
        public static void writeProxyClassToHardDisk(String path,Class[]  cla) {  
    
            byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy11", cla);
              
            FileOutputStream out = null;  
              
            try {  
                out = new FileOutputStream(path);  
                out.write(classFile);  
                out.flush();  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                try {  
                    out.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    
    }

JDK动态代理就是当我们需要传入那个被代理的对象，便能够通过反射产生代理类，getProxy是产生代理的对象，invoke是需要我们来进行方法的修改，也就是对代理对象的zf方法进行添加或者修改。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70][]

源码分析：

import com.bjsxt.proxy2.*;
    import java.lang.reflect.*;
    
    public final class $Proxy11 extends Proxy implements LetRoom
    {
        private static Method m1;
        private static Method m3;
        private static Method m2;
        private static Method m0;
        
        public $Proxy11(final InvocationHandler invocationHandler) {
            super(invocationHandler);
        }
        
        public final boolean equals(final Object o) {
            try {
                return (boolean)super.h.invoke(this, $Proxy11.m1, new Object[] { o });
            }
            catch (Error | RuntimeException error) {
                throw;
            }
            catch (Throwable t) {
                throw new UndeclaredThrowableException(t);
            }
        }
        
        public final void zf() {
            try {
                super.h.invoke(this, $Proxy11.m3, null);
            }
            catch (Error | RuntimeException error) {
                throw;
            }
            catch (Throwable t) {
                throw new UndeclaredThrowableException(t);
            }
        }
        
        public final String toString() {
            try {
                return (String)super.h.invoke(this, $Proxy11.m2, null);
            }
            catch (Error | RuntimeException error) {
                throw;
            }
            catch (Throwable t) {
                throw new UndeclaredThrowableException(t);
            }
        }
        
        public final int hashCode() {
            try {
                return (int)super.h.invoke(this, $Proxy11.m0, null);
            }
            catch (Error | RuntimeException error) {
                throw;
            }
            catch (Throwable t) {
                throw new UndeclaredThrowableException(t);
            }
        }
        
        static {
            try {
                $Proxy11.m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
                $Proxy11.m3 = Class.forName("com.bjsxt.proxy2.LetRoom").getMethod("zf", (Class<?>[])new Class[0]);
                $Proxy11.m2 = Class.forName("java.lang.Object").getMethod("toString", (Class<?>[])new Class[0]);
                $Proxy11.m0 = Class.forName("java.lang.Object").getMethod("hashCode", (Class<?>[])new Class[0]);
            }
            catch (NoSuchMethodException ex) {
                throw new NoSuchMethodError(ex.getMessage());
            }
            catch (ClassNotFoundException ex2) {
                throw new NoClassDefFoundError(ex2.getMessage());
            }
        }
    }

CGLIB动态代理：

JDK动态代理的是一个是平级的关系，它生成的被代理的对象是平级关系，都实现了接口来约束

CGLIB动态代理不需要接口来实现，和被代理对象是父与子的关系。租房的话，代理对象的父类就是房东

房东：

package com.bjsxt.proxy3;
    
    
    
    public class FD  {
    
        public void zf() {
    
            System.out.println("出租赛迪工业园4号楼1层");
        }
    }

生产被代理对象：

package com.bjsxt.proxy3;
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    //动态产生代理对象
    public class MyIntp  implements MethodInterceptor{
    
        public   Object   getProxy(){
    
            Enhancer  e=new Enhancer();
    
            //设置代理对象的父类
            e.setSuperclass(FD.class);
    
            e.setCallback(this);
    
            Object o = e.create();
    
            return o;
    
        }
    
    
        /**
         * method:被代理对象中的方法
         *
         * objects：方法中的参数
         *
         * methodProxy：代理对象中的方法
         *
         *
         * */
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    
            System.out.println(method+"--"+objects+"---"+methodProxy);
    
            System.out.println("--收取管理费500元--");
    
            Object o1 = methodProxy.invokeSuper(o, objects);
    
    
            System.out.println("--收取差价1000元--");
    
            return o1;
        }
    }

package com.bjsxt.proxy3;
    
    public class TestA {
    
        public static void main(String[] args) {
    
            MyIntp  m=new MyIntp();
    
    
            //动态产生的代理对象
            FD proxy = (FD) m.getProxy();
    
            proxy.zf();
    
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70]: /images/20230601/aa2e5334aaec45cd8cc6df2c2079783f.png