设计模式（五）代理模式

代理模式

黑马程序员：https://www.bilibili.com/video/BV1Np4y1z7BU?p=55

概述

由于某些原因需要给某对象提供一个代理以控制该对象的访问。
这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象的中介。

Java中的代理模式按照代理类生成时机不同分为：

• 静态代理 （编译期生成）
• 动态代理 （运行时动态生成） 分为JDK代理和CGLib代理两种

静态代理

例：火车站买票

如果要买火车票的话，需要去火车站买票，比较麻烦。我们可以去火车站的多个代售点买票。

UML类图

代码实现

SellTickets（抽象主题类）

public interface SellTickets {
    void sell();
}

TrainStation（真实主题类）

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

ProxyPoint（代理类）

public class ProxyPoint implements SellTickets{
    //声明火车站对象
    private TrainStation trainStation=new TrainStation();
    @Override
    public void sell() {
        System.out.println("代售点收取服务费用！！！");
        trainStation.sell();
    }
}

Client（测试类）

public class Client {
    public static void main(String[] args) {
        //创建代理对象
        ProxyPoint proxyPoint = new ProxyPoint();
        //调用方法，进行买票
        proxyPoint.sell();
    }
}

结果

动态代理 JDK动态代理

Java中提供了一个动态代理类Proxy，Proxy并不是我们上面所说的代理对象类，而是提供一个创建对象的静态方法new ProxyInstance（）方法来获取代理对象。

代码实现

抽象主题类

public interface SellTickets {
    void sell();
}

车站类

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

ProxyFactory不是代理模式种所说的代理类，而代理类是程序在运行过程中动态的在内存中生成的类。

获取代理对象的共产类

public class ProxyFactory {
    //声明目标对象
    private TrainStation station = new TrainStation();
    //获取代理对象的方法
    public SellTickets getProxyObject() {
        //返回代理对象
        SellTickets proxyObject = (SellTickets)Proxy.newProxyInstance(
                station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {
                    /*
                        Object proxy:   代理对象  和proxyObject对象是同一个对象，在invoke中基本不用
                        Method method:  对接口中的方法进行封装的method对象
                        Object[] args:  调用方法的实际参数
                        返回值： 就是方法的返回值。
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("invoke方法执行了");
                        System.out.println("代售点收取一定的服务费用(jdk动态代理)");
                        //执行目标对象的方法(station)
                        Object obj = method.invoke(station, args);//null
                        return obj;
                    }
                }
        );
        /*
            ClassLoader loader,  类加载器，用于加载代理类。可以通过目标对象获取类加载器
            Class[] interfaces,  代理类实现的接口的字节码对象
            InvocationHandler h    代理对象的调用处理程序
         */
        return proxyObject;
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        //获取代理对象
        //1.创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //2.使用工厂对象的方法获取代理对象
        SellTickets proxyObject = factory.getProxyObject();
        //3.调用卖票的方法
        proxyObject.sell();
    }
}

结果

CGLIB动态代理

如果没有定义SellTickets接口，之定义了TrainStation（火车站类）。很显然JDK代理无法使用。

CG是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。

具体实现

导入jar包

<dependency>
<groupId>cglibgroupId>
<artifactId>cglibartifactId>
<version>2.2.2version>
dependency>

火车站类

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

代理工厂类

public class ProxyFactory implements MethodInterceptor {

    //声明火车站对象
    private TrainStation station=new TrainStation();

    public TrainStation getProxyObject(){
        //1.创建Enhancer对象。类似于JDK代理中的Proxy类
        Enhancer enhancer = new Enhancer();
        //2.设置父类字节码对象
        enhancer.setSuperclass(TrainStation.class);
        //3.设置回调函数
        enhancer.setCallback(this);
        //4.创建代理对象
        TrainStation proxyObject = (TrainStation) enhancer.create();
        return proxyObject;
    }
    //5.实现MethodInterceptor接口
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //System.out.println("方法执行了");
        System.out.println("代售点收取一定的服务费用(CGLIB代理)");
        //要调用目标对象的方法
        Object obj = method.invoke(station, objects);
        return obj;
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        //创建代理工厂对象
        ProxyFactory factory=new ProxyFactory();
        //获取代理对象
        TrainStation proxyObject = factory.getProxyObject();
        //调用代理对象中的sell方法卖票
        proxyObject.sell();

    }
}

结果

三种模式的对比 动态模式与静态模式

• 在动态代理中，接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。
• 如果接口增加一个方法，静态代理除了所有实现类需要实现这个方法外，所有的代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现该问题。

JDK代理与CGLIB代理

• JDK1.6、1.7、1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLIB代理。只有当进行大量调用的时候，JDK1.6、1.7、1.8比CGLIB代理效率低一点。所以如果有接口使用JDK代理，没有接口使用CGLIB代理。
• CGLIB底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用反射效率高。唯一需要注意的是，CGLIB不能对声明为final的类或者方法进行处理，因为CGLIB原来是动态生成被代理的子类。

优缺点 优点

• 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
• 代理对象可以扩展目标对象的功能；
• 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度。

缺点

• 增加了系统的复杂度

使用场景

• 远程（Remote）代理
  本地服务通过网络请求远程服务。为了实现贝蒂到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问服务提供的功能，而不必过多关心通信部分的细节。 RPC通信
• 防火墙（Firewall）代理
  当你将浏览器配置成使用代理功能时，防火墙将将你的浏览器的请求转给互联网；
  当互联网返回响应时，代理服务器再把它转给你的浏览器。
• 保护（Protect or Access）代理
  控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。