一、代理模式{proxy-pattern}

痛定思痛。 2022-10-04 14:56 69阅读 0赞

下面所用的代码地址：https://github.com/RononoaZoro/archer-pattern

--------------------

### 一、（what）什么是代理模式？ ###

##### 代理 #####

*  在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
 *  代理角色通常会拥有被代理角色的应用，分为动态代理和静态代理，所有业务已知的情况下，可以使用静态代理（人工），编码前业务未知，使用动态代理（自动化，智能化）
 *  代理是英文 Proxy 翻译过来的。我们在生活中见到过的代理，大概最常见的就是朋友圈中卖面膜的同学了。  
    她们从厂家拿货，然后在朋友圈中宣传，然后卖给熟人。  
    ![这里写图片描述][0c8b2a09cbe4604e4f0e52290c293b09.png]

**动态代理执行图**  
![image.png][]

### 二、（where&when&why&who）在哪里使用与何时用，解决了什么问题？为什么使用它，它具备什么优势？谁使用？ ###

*  \*\*意图：\*\*为其他对象提供一种代理以控制对这个对象的访问。
 *  \*\*主要解决：\*\*在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。
 *  \*\*何时使用：\*\*想在访问一个类时做一些控制。
 *  \*\*如何解决：\*\*增加中间层。
 *  \*\*关键代码：\*\*实现与被代理类组合。  
    ![image.png][image.png 1]

### 三、（how）怎么使用？ ###

##### 1、静态代理 #####

**被代理类接口**

package com.luo.steady;
    
    /**
     * @author luoxuzheng
     * @create 2019-08-12 12:28
     **/
    public interface Person {
        
    
        void findLove();
    
        void zufangzi();
    
        void buy();
    
        void findJob();
    }

**被代理类**

package com.luo.steady;
    
    /**
     * @author luoxuzheng
     * @create 2019-08-12 12:29
     **/
    public class Son implements Person {
        
        @Override
        public void findLove() {
        
            //找对象的具体逻辑
            System.out.println("肤白貌美大长腿");
        }
    
        @Override
        public void zufangzi() {
        
    
        }
    
        @Override
        public void buy() {
        
    
        }
    
        @Override
        public void findJob() {
        
    
        }
    }

**代理类**

package com.luo.steady;
    
    /**
     * @author luoxuzheng
     * @create 2019-08-12 12:29
     **/
    public class Father {
        
        Person person;
    
        //没办法拓展，拿到目标对象的引用
        public Father(Person person){
        
            this.person = person;
        }
    
        public void findLove() {
        
            System.out.println("根据你的要求物色");
            this.person.findLove();
            System.out.println("双方父母是不是同意");
        }
    }

**测试类**

package com.luo.steady;
    
    /**
     * @author luoxuzheng
     * @create 2019-08-12 12:37
     **/
    public class StaticProxyTest {
        
        public static void main(String[] args) {
        
    
            //只能帮儿子找对象
            //不能帮表妹、不能帮陌生人
            Person son = new Son();
            Father father = new Father(son);
    
            father.findLove();
        }
    }

##### 2、动态代理 #####

###### 2.1、JDK实现 ######

**被代理类**

package com.luo.dynamic.jdk;
    
    import com.luo.steady.Person;
    
    import java.io.Serializable;
    
    /**
     * @author luoxuzheng
     * @create 2019-08-12 14:03
     **/
    public class Xiaoluoluo implements Person {
        
    
    
        public void findLove(){
        
            System.out.println("高富帅");
            System.out.println("身高180cm");
            System.out.println("胸大，6块腹肌");
    
        }
    
        @Override
        public void zufangzi() {
        
            System.out.println("租房子");
        }
    
        @Override
        public void buy() {
        
            System.out.println("买东西");
        }
    
        @Override
        public void findJob() {
        
            System.out.println("月薪20K-50k");
            System.out.println("找工作");
        }
    }

**代理类一**

package com.luo.dynamic.jdk;
    
    import com.luo.steady.Person;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * @author luoxuzheng
     * @create 2019-08-12 14:06
     **/
    public class JDKMeiPo implements InvocationHandler {
        
    
        Person target;
    
       public Object getInstance(Person target){
        
           this.target = target;
    
           Class<? extends Person> clazz = target.getClass();
    
           //以字节码重组的方式来形成一个新的代理类
           Object obj = Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    
           return obj;
       }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            System.out.println("我是媒婆：我要给你找对象，现在已经拿到你的需求");
            System.out.println("开始物色");
    
            method.invoke(this.target,args);
    
            System.out.println("如果合适的话，就准备办事");
    
            return  null;
        }
    }

**代理类二**

package com.luo.dynamic.jdk;
    
    import com.luo.steady.Person;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * @author luoxuzheng
     * @create 2019-08-12 14:16
     **/
    public class JDK58 implements InvocationHandler {
        
    
        private Person target;
    
        public Object getInstance(Person target){
        
            this.target=target;
    
            Class<? extends Person> clazz = target.getClass();
    
            Object obj = Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(),
                    this);
    
            return obj;
        }
    
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
    
    
            System.out.println("我是58：我要给你找工作，现在已经拿到你的简历");
            System.out.println("开始投递");
    
            method.invoke(this.target,args);
    
            System.out.println("安排面试");
    
            return null;
        }
    }

**测试类**

package com.luo.dynamic.jdk;
    
    import com.luo.steady.Person;
    import sun.misc.ProxyGenerator;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.lang.reflect.Proxy;
    
    /**
     * @author luoxuzheng
     * @create 2019-08-12 14:12
     **/
    public class JDKProxyTest {
        
    
        public static void main(String[] args) {
        
            Person obj = (Person)new JDKMeiPo().getInstance(new Xiaoluoluo());
            System.out.println(obj.getClass());
            obj.findLove();
    
    
            //原理：
            //1、拿到被代理对象的引用，并且获取到它的所有的接口，反射获取
            //2、JDK Proxy类重新生成一个新的类、同时新的类要实现被代理类所有实现的所有的接口
            //3、动态生成Java代码，把新加的业务逻辑方法由一定的逻辑代码去调用（在代码中体现）
            //4、编译新生成的Java代码.class
            //5、再重新加载到JVM中运行
            //以上这个过程就叫字节码重组
    
            //JDK中有个规范，只要要是$开头的一般都是自动生成的
    
            //通过反编译工具可以查看源代码
    
            byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{
        Person.class});
            try {
        
                FileOutputStream fos = new FileOutputStream("E:\\dynamicClass" +
                        "\\$Proxy0.class");
                fos.write(bytes);
                fos.flush();
                fos.close();
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

###### 2.2、Cglib实现 ######

**被代理类**

package com.luo.dynamic.cglib;
    
    /**
     * @author luoxuzheng
     * @create 2019-08-12 14:54
     **/
    public class AZheng {
        
        public void findLove(){
        
            System.out.println("肤白貌美大象腿");
        }
    }

**代理类**

package com.luo.dynamic.cglib;
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    /**
     * @author luoxuzheng
     * @create 2019-08-12 14:54
     **/
    public class CglibMeiPo implements MethodInterceptor {
        
    
    
        public Object getInstance(Class<?> clazz){
        
            Enhancer enhancer = new Enhancer();
    
            enhancer.setSuperclass(clazz);
    
            enhancer.setCallback(this);
    
            Object obj = enhancer.create();
    
            return obj;
        }
    
    
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        
            //业务的增强
    
            System.out.println("我是媒婆：我要给你找对象，现在已经拿到你的需求");
            System.out.println("开始物色");
    
            methodProxy.invokeSuper(o,objects);
    
            System.out.println("如果合适的话，就准备办事");
            return null;
        }
    }

**测试类**

package com.luo.dynamic.cglib;/** * @author luoxuzheng * @create 2019-08-12 14:59 **/public class CglibProxyTest {
            public static void main(String[] args) {
                AZheng obj = (AZheng) new CglibMeiPo().getInstance(AZheng.class);        obj.findLove();        System.out.println("--------------------------------");        System.out.println(obj.getClass());    }}

###### 2.3、自定义实现动态代理 ######

*  参考项目代码和Spring、Apache中的BeanUtils

### 四、总结与应用 ###

###### 1）、应用场景与有趣点 ######

*  1、Windows 里面的快捷方式。 2、猪八戒去找高翠兰结果是孙悟空变的，可以这样理解：把高翠兰的外貌抽象出来，高翠兰本人和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟空，所以说孙悟空是高翠兰代理类。 3、买火车票不一定在火车站买，也可以去代售点。 4、一张支票或银行存单是账户中资金的代理。支票在市场交易中用来代替现金，并提供对签发人账号上资金的控制。 5、spring aop。
 *  优点： 1、职责清晰。 2、高扩展性。 3、智能化。
 *  缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

###### 2）、使用场景与注意事项 ######

*  **按职责来划分，通常有以下使用场景：** 1、远程代理。 2、虚拟代理。 3、Copy-on-Write 代理。 4、保护（Protect or Access）代理。 5、Cache代理。 6、防火墙（Firewall）代理。 7、同步化（Synchronization）代理。 8、智能引用（Smart Reference）代理。
 *  **注意事项：** 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

[0c8b2a09cbe4604e4f0e52290c293b09.png]: /images/20221004/1f80866da7c1434fb6b6e159701e6430.png
[image.png]: /images/20221004/337aaf109c56457e96e624ab0f89f10b.png
[image.png 1]: /images/20221004/7c51e02e88fa47cc86582d248b69f7b8.png