一代理模式{proxy-pattern}

Posted 2021-08-12 archerLuo罗

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

---

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

代理

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

动态代理执行图

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

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

三、（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、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。