动态代理模式-CSDN博客

本文链接：https://blog.csdn.net/zicair/article/details/107657271

代理模式可分为静态代理和动态代理，什么是代理模式以及代理模式怎么使用？

代理模式

1. 代理模式的定义

为其他对象提供一种代理以控制对这个对象的访问。也称为“委托模式”。根据字节码的创建时机又分为静态代理和动态代理。

如果根据字节码的创建时机来分类，可以分为静态代理和动态代理：

静态代理：在程序运行前就已经存在代理类的字节码文件，代理类和真实主题角色的关系在运行前就确定了。

动态代理：源码是在程序运行期间由JVM根据反射等机制动态的生成，所以在运行前并不存在代理类的字节码文件。

2. 静态代理

普通代理：上层模块必须知道代理类的存在。访问真实主题角色的时候，要通过代理，因此要在上层模块创建代理对象。代理对象关联真实角，第一种方式：创建代理对象时，传一个真实对象的引用；第二种方式：在代理类内部实现。如果采用第二种关联的方式，在代理类创建时，由代理类决定创建一个真实角色，上层模块也并不需要知道真实角色的具体类。

强制代理：真实角色必须通过代理才能访问，并且真实角色的代理的产生，由真实对象决定（与普通代理恰好相反）

2.1 普通代理

interface Subject {
    void doSomething();
}
 
class RealSubject implements Subject{
    @Override
    public void doSomething() {
        System.out.println("调用真实角色的方法");
    }
}
 
class Proxy implements Subject{
    private Subject realSubject;
 
    //关联真实角色的第一种方式：外部传入
    public Proxy(Suubject realSubject){
        this.realSubject = realSubject;
    }
    //关联真实角色的第二种方式：由代理类决定
    public Proxy(){
        realSubject = new RealSubject();
    }
    @Override
    public void doSomething() {
        this.realSubject.doSomething();
    }
} 
 
public class Clinet {
    public static void main(String[] args){
        Subject proxy = new Proxy();
        proxy.doSometing();
    }
}

上层模块在创建代理时，并不用知道真实角色，但是要知道代理角色的”类”（通过new创建一个RealSubject对象，一定要知道类型）。简而言之，是将真实类对象传给代理类。

2.2 强制代理

对于普通代理来说，上层模块一定要知道代理的类型，但对于强制代理来说，强制代理的创建由真实角色决定，也就是说，通过真实角色找到代理，然后通过代理完成真实角色要完成的工作。


interface Subject {
    void doSomething();
 
    Subject getProxy();
}
 
class RealSubject implements Subject{
 
    private Subject proxy;
 
    private boolean hasProxy() {
        return proxy != null;
    }
 
    @Override
    public void doSomething() {
        if(hasProxy())
            System.out.println("调用真实角色的方法");
        else {
            System.err.println("请使用代理调用！！！！");
        }
    }
 
    //代理的创建由真实角色决定
    @Override
    public Subject getProxy() {
        if(!hasProxy())
            this.proxy = new Proxy(this);
        return this.proxy;
    }
}
 
class Proxy implements Subject {
 
    private Subject realSubject;
 
    public Proxy(Subject realSubject) {
        this.realSubject = realSubject;
    }
 
    @Override
    public void doSomething() {
        this.realSubject.doSomething();
    }
 
    @Override
    public Subject getProxy() {
        return this;
    }
 
}
 
public class Client {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        realSubject.doSomething();
 
        realSubject.getProxy().doSomething();
    }
}

强制代理就是必须通过真实角色获得代理，然后由代理去完成真实角色的工作。除了强制代理需为接口增加获取代理的方法外，与普通代理不同的是强制代理的生成需要在真实角色的内部new出来，并将真是角色的this(本身对象)传给new出来的代理。

2.3 静态代理的缺点

虽然静态代理实现简单，且不侵入原代码，但是，当场景稍微复杂一些的时候，静态代理的缺点也会暴露出来。

当需要代理多个类的时候，由于代理对象要实现与目标对象一致的接口，有两种方式：
- 只维护一个代理类，由这个代理类实现多个接口，但是这样就导致代理类过于庞大
- 新建多个代理类，每个目标对象对应一个代理类，但是这样会产生过多的代理类
当接口需要增加、删除、修改方法的时候，目标对象与代理类都要同时修改，不易维护。

3. 动态代理

3.1 实现原理

设计动态代理类（DynamicProxy）时，不需要显式实现与目标对象类（RealSubject）相同的接口，而是将这种实现推迟到程序运行时由 JVM来实现

即：在使用时再创建动态代理类 & 实例
静态代理则是在代理类实现时就指定与目标对象类（RealSubject）相同的接口

通过Java 反射机制的method.invoke（），通过调用动态代理类对象方法，从而自动调用目标对象的方法

3.2 步骤详解

步骤1： 声明目标对象的抽象接口

Subject.java

public interface Subject {
    // 定义目标对象的接口方法
    // 代购物品
    public  void buybuybuy();

}

步骤2： 声明目标对象类

Buyer1.java

// 小成，真正的想买Mac的对象 = 目标对象 = 被代理的对象
// 实现抽象目标对象的接口
public class Buyer1 implements Subject  {

    @Override
    public void buybuybuy() {
        System.out.println("小成要买Mac");
    }

}

Buyer2.java

// 小何，真正的想买iPhone的对象 = 目标对象 = 被代理的对象
// 实现抽象目标对象的接口
public class Buyer2 implements Subject  {

    @Override
    public void buybuybuy() {
        System.out.println("小何要买iPhone");
    }

}

步骤3： 声明代理类

DynamicProxy.java

public class DynamicProxy implements InvocationHandler {
    // 声明代理对象
    // 作用：绑定关系，即关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke（）
    private Object ProxyObject;

    public Object getProxyInstance(Object ProxyObject){
        this.ProxyObject =ProxyObject;
        return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
                ProxyObject.getClass().getInterfaces(),this);
        // 参数1：指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
        // 参数2：指定目标对象的实现接口
        // 即要给目标对象提供一组什么接口。若提供了一组接口给它，那么该代理对象就默认实现了该接口，这样就能调用这组接口中的方法
        // 参数3：指定InvocationHandler对象。即动态代理对象在调用方法时，会关联到哪个InvocationHandler对象
    }

    //  复写InvocationHandler接口的invoke（）
    //  动态代理对象调用目标对象的任何方法前，都会调用处理器类的invoke（）
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
        // 参数1：动态代理对象（即哪个动态代理对象调用了method（）
        // 参数2：目标对象被调用的方法
        // 参数3：指定被调用方法的参数
        System.out.println("代购出门了");
        // 通过Java反射机制调用目标对象方法
        Object result = method.invoke(ProxyObject, args);
        return result;
    }

}

步骤4： 通过动态代理对象，调用目标对象的方法
Main.java

public static void main(String args[]) {
    DynamicProxy DynamicProxy = new DynamicProxy();
    // 通过调用动态代理对象方法从而调用目标对象方法
    // 实际上是调用了invoke（），再通过invoke（）里的反射机制调用目标对象的方法
    Buyer1 mBuyer1 = new Buyer1();
    Subject Buyer1_DynamicProxy = (Subject)DynamicProxy.getProxyInstance(mBuyer1);
    Buyer1_DynamicProxy.buybuybuy();

    // 以下是代购为小何代购iPhone
    Buyer2 mBuyer2 = new Buyer2();
    Subject Buyer2_DynamicProxy = (Subject)DynamicProxy.getProxyInstance(mBuyer2);
    Buyer2_DynamicProxy.buybuybuy();
}

// 输出：
// 代购出门了
// 小成要买Mac
// 代购出门了
// 小何要买iPhone