代理模式，静态代理和动态代理

作者: 天空在微笑 | 来源:发表于2021-03-18 22:06 被阅读0次

Spring之代理模式
带你初识Java的代理模式
设计模式~代理模式
java代理模式
编程常用的设计模式
设计模式-代理模式
代理模式
Maven项目&Spring AOP基础(一)
说说Java代理模式
设计模式

一、概述
在Java语言中有一种非常强大的设计模式：代理模式，代理模式又可以细分为静态代理和动态代理。那么什么是代理模式呢？什么是静态代理？什么又是动态代理？运行代理模式又有什么用？

那么咱们就来好好分析分析代理模式。

二、代理模式
静态代理：在代码运行之前就已经固定好了委托对象和代理对象，且在代码编译之后将不可更改。

动态代理：在程序运行时委托对象可以动态设置给代理对象。

在咱们日常生活中，会遇到这种情况：我想买一台Mac，但是国内购买的话价格太高，我听说在香港购买的话价格便宜很多，但是我得上班没空为这事跑一趟香港啊，这可怎么办？诶...对了，听说隔壁家的张狗蛋的姑妈的小女儿王小美在香港做代购？我可以找她给我代购一台Mac，然后把Mac拿给我，这不就解决问题了吗？。说不定熟络熟络还能谈谈人生理想呢...

接下来咱们就这个栗子来分析一下静态代理和动态代理：

1、静态代理
在上面栗子中，我是委托对象，王小美是代理对象，我不能做到的事情，将由我的代理王小美替我完成，最后将期望的结果返回给我。

那么现在咱们用代码实现：

1.首先抽象出一个公共接口，该接口具有我和王小美都需具备的方法。

public interface ICustomer {
    void buyMac();
}

2.构建委托对象：我。

public class Me implements ICustomer{
 
    @Override
    public void buyMac() {
        System.out.println("我终于买到了Mac");
    }
}

3.构建代理对象：王小美。

public class WangXiaomei implements ICustomer{
    //委托对象实例
    private Me me;
    public WangXiaomei(){
        me = new Me();
    }
 
    @Override
    public void buyMac() {
        System.out.println("王小美购买到Mac");
        //调用代理对象的buyMac()方法时，代理对象调用委托对象的buyMac()方法将结果传给委托对象
        System.out.println("王小美将购买到的Mac转交给我");
        me.buyMac();
    }
}

4.开始购买：

public class Main {
    public static void main(String[] args){
        WangXiaomei wangXiaomei = new WangXiaomei();
        wangXiaomei.buyMac();
    }
}

打印结果：

王小美购买到Mac
王小美将购买到的Mac转交给我
我终于买到了Mac

通过上面4个步骤，我终于买到了Mac，这个例子中真正实现购买这一动作的是代理对象王小美而不是我，但这并不是我关心的，我只需要得到我想要得到的结果就行。这就是最简单的静态代理！

2、动态代理
在上面的栗子中，王小美作为一个代购，她不可能只做我一个人的生意，大家需要代购其他商品时随时都会找她代理，因此她的委托者是不固定的。她执行购买操作之前可以随时更改她的委托对象，这就是动态代理。

接下来咱们用代码实现动态代理。

开始实现之前咱们先来看个好东西：

在Java中，官方api提供了这么一个Proxy类和一个InvocationHandler接口类，专门处理动态代理的实现。来看Proxy类：

/**
 * {@code Proxy} provides static methods for creating dynamic proxy
 * classes and instances, and it is also the superclass of all
 * dynamic proxy classes created by those methods.
 *
 * <p>To create a proxy for some interface {@code Foo}:
 * <pre>
 *     InvocationHandler handler = new MyInvocationHandler(...);
 *     Class&lt;?&gt; proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class);
 *     Foo f = (Foo) proxyClass.getConstructor(InvocationHandler.class).
 *                     newInstance(handler);
 * </pre>
 * or more simply:
 * <pre>
 *     Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
 *                                          new Class&lt;?&gt;[] { Foo.class },
 *                                          handler);
 * </pre>
 * ...
 */
public class Proxy implements java.io.Serializable {
...
}

这个类是用于创建动态代理实例对象，并且在注释中给出了相应的使用示例。

接着看InvocationHandler接口类：

/**
 * {@code InvocationHandler} is the interface implemented by
 * the <i>invocation handler</i> of a proxy instance.
 */
public interface InvocationHandler {
 
    /**
     * Processes a method invocation on a proxy instance and returns
     * the result.  This method will be invoked on an invocation handler
     * when a method is invoked on a proxy instance that it is
     * associated with.
     */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

InvocationHandler里边只有一个方法invoke()，InvocationHandler接口用于给代理类实现，负责处理委托对象的操作，规定每一个代理对象都有一个相关联的InvocationHandler，在代理对象调用代理方法时，都会回调invoke()方法，在这个方法内对委托对象做处理。

现在咱们以王小美代购这件事，用代码来说明动态代理。

1.和静态代理一样，先抽象出一个代理类和委托类都具有的属性接口：

public interface ICustomer {
    void buyMac();
}

2.构建另一个委托对象：王铁柱。

public class WangTiezhu implements ICustomer{
 
    @Override
    public void buyMac() {
        System.out.println("王铁柱终于买到了Mac");
    }
}

3.改造王小美成动态代理类：

public class WangXiaomei<T> implements InvocationHandler{
 
    private T delegation; //委托对象
 
    public WangXiaomei(T delegation){
        this.delegation = delegation;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理对象王小美执行操作：" + method.getName());
        Object result = method.invoke(delegation, args);
        return result;
    }
}

4.开始购买：

public class Main {
    public static void main(String[] args){
        WangXiaomei wangXiaomei = new WangXiaomei<ICustomer>(new WangTiezhu());
        ICustomer customerProxy = (ICustomer)Proxy.newProxyInstance(WangTiezhu.class.getClassLoader(), new Class<?>[]{WangTiezhu.class}, wangXiaomei);
        customerProxy.buyMac();
    }
}

执行结果：

代理对象王小美执行操作：buyMac
王铁柱终于买到了Mac

做了动态代理改造后，只要有人想买Mac时候直接找王小美就行，委托对象可以随时更换，只需要创建Wangxiaomei这个对象时候传入具体的委托对象实例即可。通过上面的栗子咱们看到，动态代理相比于静态代理更加灵活，可以很方便的对代理类和委托类做处理，动态代理全程只需要一个代理类来对不同委托类统一处理，很好地实现了编程的可拓展性。

原文链接：https://blog.csdn.net/qq_29152241/article/details/82142552