【Java设计模式005】代理模式-Toy模板网

这篇具有很好参考价值的文章主要介绍了【Java设计模式005】代理模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

概述

由于一些特定原因某些对象不适合或者不能直接引用目标对象，这时就可以使用代理模式。代理模式为目标对象提供一个代理以控制访问对象对目标对象的访问。客户端只能直接访问代理对象，不能直接访问目标对象，这么做确保了目标对象的安全。生活中一个常见的例子就是买房，客户想买房，房东想卖房，此时客户是客户端，房东是服务端，但一般情况下房东不会直接带客户看房，这个工作通常由中介完成。还是从客户的视角看，不论是中介还是房东，他们都是服务端，提供同样的卖房服务，也就是说客户会将中介看成一个抽象房东，同样能提供卖房服务。

实现

Java 中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成，而动态代理代理类则是在 Java 运行时动态生成。动态代有JDK 代理和CGLib 代理两种。

代理模式包含如下几个角色：

抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

静态代理

实现的关键在于代理类通过组合的方式调用目标对象的功能。以租房为例：

首先定义一个接口定义租房业务。

public interface IRentHouse {  
    void rentHouse();  
}

IRentHouse 就是抽象主题类，接着定义其实现类，也就是真实主题类：

public class RentHouse implements IRentHouse{
    @Override
    public void rentHouse() {
        System.out.println("房东租房");
    }
}

租房一般通过中介，所以还需要定义一个中介类作为代理，向客户提供租房服务：

public class IntermediaryProxy implements IRentHouse {  
    private RentHouse rentHouse;  
  
    public IntermediaryProxy() {  
        rentHouse = new RentHouse();  
    }  
  
    @Override  
    public void rentHouse() {  
        System.out.println("审查租房人资质");  
        if (isQualified()) {  
            System.out.println("资质审查通过");  
            rentHouse.rentHouse();  
            System.out.println("收取中介费");  
        } else {  
            System.out.println("资质审核失败");  
        }  
    }  
  
    private boolean isQualified() {  
        return new Random().nextBoolean();  
    }  
}

在中介类中通过组合的方式完成代理，同时能够对调用者进行安全检查。最后就是客户端；

public class Client {  
    public static void main(String[] args) {  
        // 创建中介代理  
        IntermediaryProxy proxy = new IntermediaryProxy();  
        proxy.rentHouse();  
    }  
}

测试结果：

审查租房人资质
资质审查通过
房东租房
收取中介费

在租房这个场景，客户既可以通过中介租房，也可以直接找到房东租房，因此该场景下的真实主题类并没有设置为私有。

动态代理

JDK 动态代理

JDK 提供了动态代理，Java 提供了一个类 Proxy，它并不是上述所说的代理对象的类，而是提供了一个创建代理对象的静态方法
（newProxyInstance方法）来获取代理对象。

还是先定义业务接口：

public interface SellTickets {  
    // 卖票接口  
    void sell();  
}

然后是业务实现类，即真实主题类：

public class TrainStation implements SellTickets {
    public void sell() {
        System.out.println("火车站卖票");
    }
}

接着是代理类工厂：

public class ProxyFactory {  
    private final TrainStation trainStation = new TrainStation();  
  
    /*  
        newProxyInstance()方法参数说明：  
        ClassLoader loader ：类加载器，用于加载代理类，使用真实对象的类加载器即可  
        Class<?>[] interfaces ：真实对象所实现的接口，代理模式真实对象和代理对象实现相同的接口  
        InvocationHandler h ：代理对象的调用处理程序  
    */    public Object getProxyObjet() {  
  
        return Proxy.newProxyInstance(trainStation.getClass().getClassLoader(), trainStation.getClass().getInterfaces(),  
                /*  
                    InvocationHandler中invoke方法参数说明(指定业务逻辑顺序)：  
                    proxy ： 代理对象  
                    method ： 对应于在代理对象上调用的接口方法的 Method实例  
                    args ： 代理对象调用接口方法时传递的实际参数  
                */                (proxy, method, args) -> {  
  
                    System.out.println("收取一定的费用");  
                    return method.invoke(trainStation, args);  
                });  
    }  
}

最后是客户端：

public class Client {
    public static void main(String[] args) {
        ProxyFactory factory = new ProxyFactory();
        SellTickets proxyObject = (SellTickets) factory.getProxyObjet();
        proxyObject.sell();

        System.out.println(proxyObject.getClass());
    }
}

通过反编译看一下动态代理类的结构：

public final class $Proxy0
extends Proxy
implements SellTickets {
    private static Method m3;

    public final void sell() {
        try {
			// h是Proxy中的一个成员变量InvocationHandler（接口），调用的invoke方法就是我们重写实现的方法。
            this.h.invoke(this, m3, null);
            return;
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public $Proxy0(InvocationHandler invocationHandler) {
        super(invocationHandler);
    }

    static {
        try {
			
			// 获取的是接口（SellTickets）中的sell方法。
            m3 = Class.forName("com.pcx.proxy.jdk_demo.SellTickets").getMethod("sell", new Class[0]);
          
            return;
        }
        catch (NoSuchMethodException noSuchMethodException) {
            throw new NoSuchMethodError(noSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException classNotFoundException) {
            throw new NoClassDefFoundError(classNotFoundException.getMessage());
        }
    }
}

调用流程总结：

调用代理对象的sell()方法；
根据多态的特性，执行的是代理类Proxy0中的sell()方法；
Proxy0中的sell()方法调用的是InvocationHandler对象的invoke()方法；
查看接口实现，调用具体的实现方法；
invoke()方法通过反射执行了真实类的对应方法。

CGLIB 动态代理

CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为 JDK 的动态代理提供了很好的补充。想要使用 CGLIB 需要一下配置：

<dependency>
	<groupId>cglib</groupId>
	<artifactId>cglib</artifactId>
	<version>2.2.2</version>
</dependency>

测试代码如下：

public class ProxyFactory implements MethodInterceptor {


    public TrainStation getProxyObject() {
        // 创建Enhancer类，类似于JDK代理中的Proxy
        Enhancer enhancer = new Enhancer();
        // 设置父类的字节码对象
        enhancer.setSuperclass(TrainStation.class);
        // 设置回调函数
        enhancer.setCallback(this);

        // 创建代理对象
        TrainStation proxyObject = (TrainStation) enhancer.create();

        return proxyObject;
    }


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        /*
            intercept方法参数说明：
            o ： 代理对象
            method ： 真实对象中的方法的Method实例
            args ： 实际参数
            methodProxy ：代理对象中的方法的method实例
         */
        System.out.println("收取cglib服务费");
        // 调用目标对象的方法
        methodProxy.invokeSuper(o, objects);
        return null;
    }
}

小结

JDK 动态代理通过反射机制实现，CGLIB 则采用 ASM 字节码生成框架，使用字节码技术生成代理类。在 JDK1.6 之前 CGLIB 比反射效率高，但是 JDK1.8 之后 JDK 代理的效率会高于 CGLIB 代理，所以如果有接口使用 JDK 动态代理，如果没有接口使用 CGLIB 代理，此外，CGLib 不能对声明为 final 的类或者方法进行代理，因为 CGLib 原理是动态生成被代理类的子类。

动态代理的最大优势是将业务接口，即抽象主题类中声明的所有方法都被转移到调用处理器一个集中的方法中处理 InvocationHandler.invoke，而静态代理需要中转每一个方法；此外，如果接口增加了一个方法，静态代理模式所有的真实主题类和代理类都需要实现该方法，而动态代理不会出现这样的问题。

总结

使用场景

延迟初始化（虚拟代理）。如果有一个偶尔使用的重量级服务对象，一直保持该对象运行会消耗系统资源时，可使用代理模式；
如果你只希望特定客户端使用服务对象，这里的对象可以是操作系统中非常重要的部分，而客户端则是各种已启动的程序（包括恶意程序），此时可使用代理模式；
本地执行远程服务（远程代理），适用于服务对象位于远程服务器上的情形；
适用于需要缓存客户请求结果并对缓存生命周期进行管理时，特别是当返回结果的体积非常大时。

优点

代理模式在客户端与目标对象之间起到一个中介和保护目标对象的作用；
代理对象可以扩展目标对象的功能；
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；
虚拟代理通过使用一个小对象来代表一个大对象，可以减少系统资源的消耗，对系统进行优化并提高运行速度。

缺点

增加了系统复杂度；
服务响应可能会延迟。

补充说明

外观模式与代理模式的相似之处在于它们都缓存了一个复杂实体并自行对其进行初始化。区别在于代理类与其服务对象遵循同一接口，使得自己和服务对象可以互换；
装饰这模式和代理模式同样有相似的结构，但是其意图却非常不同。这两个模式的构建都基于组合原则，也就是说一个对象应该将部分工作委派给另一个对象。两者之间的不同之处在于代理模式通常自行管理其服务对象的生命周期，而装饰这模式的生成则总是由客户端进行控制。

往期回顾

【Java设计模式004】建造者模式
【Java设计模式003】原型模式
【Java设计模式002】工厂模式
【Java设计模式001】单例模式

文中难免会出现一些描述不当之处（尽管我已反复检查多次），欢迎在留言区指正，相关的知识点也可进行分享，希望大家都能有所收获！！如果觉得我的文章写得还行，不妨支持一下。你的每一个转发、关注、点赞、评论都是对我最大的支持！文章来源地址https://www.toymoban.com/news/detail-661975.html

到了这里，关于【Java设计模式005】代理模式的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！