关于java:设计模式学习15Java实现代理模式

39次阅读

共计 9058 个字符，预计需要花费 23 分钟才能阅读完成。

写在后面

  • 记录学习设计模式的笔记
  • 进步对设计模式的灵活运用

学习地址

https://www.bilibili.com/vide…

https://www.bilibili.com/vide…

参考文章

http://c.biancheng.net/view/1…

** 我的项目源码
https://gitee.com/zhuang-kang/DesignPattern**

17，代理模式

17.1 代理模式的定义和特点

代理模式的定义：因为某些起因须要给某对象提供一个代理以管制对该对象的拜访。这时，拜访对象不适宜或者不能间接援用指标对象，代理对象作为拜访对象和指标对象之间的中介。

代理模式的次要长处有：

  • 代理模式在客户端与指标对象之间起到一个中介作用和爱护指标对象的作用；
  • 代理对象能够扩大指标对象的性能；
  • 代理模式能将客户端与指标对象拆散，在肯定水平上升高了零碎的耦合度，减少了程序的可扩展性

其次要毛病是：

  • 代理模式会造成零碎设计中类的数量减少
  • 在客户端和指标对象之间减少一个代理对象，会造成申请处理速度变慢；
  • 减少了零碎的复杂度；

17.2 代理模式的构造与实现

17.2.1 代理模式的构造

  1. 形象主题（Subject）类：通过接口或抽象类申明实在主题和代理对象实现的业务办法。
  2. 实在主题（Real Subject）类：实现了形象主题中的具体业务，是代理对象所代表的实在对象，是最终要援用的对象。
  3. 代理（Proxy）类：提供了与实在主题雷同的接口，其外部含有对实在主题的援用，它能够拜访、管制或扩大实在主题的性能。

依据代理的创立期间，代理模式分为动态代理和动静代理。

  • 动态：由程序员创立代理类或特定工具主动生成源代码再对其编译，在程序运行前代理类的 .class 文件就曾经存在了。
  • 动静：在程序运行时，使用反射机制动态创建而成

17.2.2 代码实现

关系类图

17.2.2.1动态代理

SellTickets

package com.zhuang.proxy.static_proxy;

/**
 * @Classname SellTickets
 * @Description 卖票接口
 * @Date 2021/3/26 8:01
 * @Created by dell
 */

public interface SellTickets {void sell();
}

Transition

package com.zhuang.proxy.static_proxy;

/**
 * @Classname Transition
 * @Description 火车站，具备卖票性能，实现接口
 * @Date 2021/3/26 8:01
 * @Created by dell
 */

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

ProxyPoint

package com.zhuang.proxy.static_proxy;

/**
 * @Classname ProxyPoint
 * @Description 代售点 实现接口
 * @Date 2021/3/26 8:02
 * @Created by dell
 */

public class ProxyPoint implements SellTickets {private Transition transition = new Transition();

    @Override
    public void sell() {System.out.println("代售点收取服务费");
        transition.sell();}
}

Client

package com.zhuang.proxy.static_proxy;

/**
 * @Classname Client
 * @Description 动态代理客户端测试类
 * @Date 2021/3/26 8:02
 * @Created by dell
 */

public class Client {public static void main(String[] args) {ProxyPoint proxyPoint = new ProxyPoint();
        proxyPoint.sell();}
}

从下面代码中能够看出测试类间接拜访的是 ProxyPoint 类对象，也就是说 ProxyPoint 作为拜访对象和指标对象的中介。同时也对 sell 办法进行了加强

17.2.2.2 JDK 动静代理

应用动静代理实现下面案例，先说说 JDK 提供的动静代理。Java 中提供了一个动静代理类 Proxy，Proxy 并不是咱们上述所说的代理对象的类，而是提供了一个创立代理对象的静态方法（newProxyInstance 办法）来获取代理对象。

SellTickets

package com.zhuang.proxy.jdk_proxy;

/**
 * @Classname SellTickets
 * @Description 卖票接口
 * @Date 2021/3/26 8:01
 * @Created by dell
 */

public interface SellTickets {void sell();
}

Transition

package com.zhuang.proxy.jdk_proxy;

/**
 * @Classname Transition
 * @Description 火车站，具备卖票性能，实现接口
 * @Date 2021/3/26 8:01
 * @Created by dell
 */

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

ProxyFactory

package com.zhuang.proxy.jdk_proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @Classname ProxyFactory
 * @Description 代理工厂 用来创立代理对象
 * @Date 2021/3/26 8:11
 * @Created by dell
 */

public class ProxyFactory {private Transition transition = new Transition();

    public SellTickets getProxyObject() {
        // 应用 Proxy 获取代理对象
        /* newProxyInstance
        ClassLoader loader, 类加载器
        Class<?>[] interfaces, 接口
        InvocationHandler h 办法

        invoke 办法参数阐明
        proxy 代理对象
        method 对应于在代理对象调用的接口办法的 Method 实例
        args 代理对象调用接口办法时传递的理论参数
         */
        SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(transition.getClass().getClassLoader(),
                transition.getClass().getInterfaces()
                , new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("代售点收取服务费(JDK 动静代理形式)");
                        // 执行实在对象
                        Object result = method.invoke(transition, args);
                        return result;
                    }
                });
        return sellTickets;
    }
}

Client

package com.zhuang.proxy.jdk_proxy;

/**
 * @Classname Client
 * @Description JDK 动静代理 测试类
 * @Date 2021/3/26 8:20
 * @Created by dell
 */

public class Client {public static void main(String[] args) {
        // 获取代理对象
        ProxyFactory factory = new ProxyFactory();

        SellTickets proxyObject = factory.getProxyObject();
        proxyObject.sell();}
}

应用了动静代理，咱们思考上面问题：

  • ProxyFactory 是代理类吗？

    ProxyFactory 不是代理模式中所说的代理类，而代理类是程序在运行过程中动静的在内存中生成的类。通过阿里巴巴开源的 Java 诊断工具（Arthas【阿尔萨斯】）查看代理类的构造：

    package com.sun.proxy;

import com.itheima.proxy.dynamic.jdk.SellTickets;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

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

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

    static {
        try {m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.itheima.proxy.dynamic.jdk.SellTickets").getMethod("sell", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            return;
        }
        catch (NoSuchMethodException noSuchMethodException) {throw new NoSuchMethodError(noSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException classNotFoundException) {throw new NoClassDefFoundError(classNotFoundException.getMessage());
        }
    }

    public final boolean equals(Object object) {
        try {return (Boolean)this.h.invoke(this, m1, new Object[]{object});
        }
        catch (Error | RuntimeException throwable) {throw throwable;}
        catch (Throwable throwable) {throw new UndeclaredThrowableException(throwable);
        }
    }

    public final String toString() {
        try {return (String)this.h.invoke(this, m2, null);
        }
        catch (Error | RuntimeException throwable) {throw throwable;}
        catch (Throwable throwable) {throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int hashCode() {
        try {return (Integer)this.h.invoke(this, m0, null);
        }
        catch (Error | RuntimeException throwable) {throw throwable;}
        catch (Throwable throwable) {throw new UndeclaredThrowableException(throwable);
        }
    }

    public final void sell() {
        try {this.h.invoke(this, m3, null);
            return;
        }
        catch (Error | RuntimeException throwable) {throw throwable;}
        catch (Throwable throwable) {throw new UndeclaredThrowableException(throwable);
        }
    }
}

从下面的类中，咱们能够看到以下几个信息：

  • 代理类（$Proxy0）实现了 SellTickets。这也就印证了咱们之前说的实在类和代理类实现同样的接口。
  • 代理类（$Proxy0）将咱们提供了的匿名外部类对象传递给了父类。

  • 动静代理的执行流程是什么样？

    上面是摘取的重点代码：

    // 程序运行过程中动静生成的代理类
public final class $Proxy0 extends Proxy implements SellTickets {
    private static Method m3;

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

    static {m3 = Class.forName("com.itheima.proxy.dynamic.jdk.SellTickets").getMethod("sell", new Class[0]);
    }

    public final void sell() {this.h.invoke(this, m3, null);
    }
}

//Java 提供的动静代理相干类
public class Proxy implements java.io.Serializable {
    protected InvocationHandler h;
     
    protected Proxy(InvocationHandler h) {this.h = h;}
}

// 代理工厂类
public class ProxyFactory {private TrainStation station = new TrainStation();

    public SellTickets getProxyObject() {SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("代理点收取一些服务费用(JDK 动静代理形式)");
                        Object result = method.invoke(station, args);
                        return result;
                    }
                });
        return sellTickets;
    }
}


// 测试拜访类
public class Client {public static void main(String[] args) {
        // 获取代理对象
        ProxyFactory factory = new ProxyFactory();
        SellTickets proxyObject = factory.getProxyObject();
        proxyObject.sell();}
}

执行流程如下：

  1. 在测试类中通过代理对象调用 sell()办法
  2. 依据多态的个性，执行的是代理类（$Proxy0）中的 sell()办法
  3. 代理类（$Proxy0）中的 sell()办法中又调用了 InvocationHandler 接口的子实现类对象的 invoke 办法
  4. invoke 办法通过反射执行了实在对象所属类 (TrainStation) 中的 sell()办法

17.2.2.3 CGLB 代理

TrainStation

package com.zhuang.proxy.cglib_proxy;

/**
 * @Classname TrainStation
 * @Description 火车站类
 * @Date 2021/3/26 8:31
 * @Created by dell
 */

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

ProxyFactory

package com.zhuang.proxy.cglib_proxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @Classname ProxyFactory
 * @Description 代理工厂 实现 MethodInterceptor
 * @Date 2021/3/26 8:32
 * @Created by dell
 */

public class ProxyFactory implements MethodInterceptor {private TrainStation target = new TrainStation();

    public TrainStation getProxyObject() {
        // 创立 Enhancer 对象  相似于 JDK 动静代理
        Enhancer enhancer = new Enhancer();
        // 设置父类的字节码对象
        enhancer.setSuperclass(target.getClass());
        // 设置回调函数
        enhancer.setCallback(this);
        // 创立代理对象
        TrainStation obj = (TrainStation) enhancer.create();
        return obj;

    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {System.out.println("代收点收取一些代理费用(CGLIB 动静代理形式)");
        Object result = methodProxy.invokeSuper(o, args);
        return result;
    }
}

Client

package com.zhuang.proxy.cglib_proxy;

/**
 * @Classname Client
 * @Description CGLIB 动静代理模式 测试类
 * @Date 2021/3/26 8:42
 * @Created by dell
 */

public class Client {public static void main(String[] args) {
        // 创立代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        // 获取代理对象
        TrainStation proxyObject = factory.getProxyObject();

        proxyObject.sell();}
}

17.2.3 三种代理的比照

  • jdk 代理和 CGLIB 代理

    应用 CGLib 实现动静代理，CGLib 底层采纳 ASM 字节码生成框架，应用字节码技术生成代理类，在 JDK1.6 之前比应用 Java 反射效率要高。惟一须要留神的是，CGLib 不能对申明为 final 的类或者办法进行代理，因为 CGLib 原理是动静生成被代理类的子类。

    在 JDK1.6、JDK1.7、JDK1.8 逐渐对 JDK 动静代理优化之后，在调用次数较少的状况下，JDK 代理效率高于 CGLib 代理效率，只有当进行大量调用的时候，JDK1.6 和 JDK1.7 比 CGLib 代理效率低一点，然而到 JDK1.8 的时候，JDK 代理效率高于 CGLib 代理。所以如果有接口应用 JDK 动静代理，如果没有接口应用 CGLIB 代理。

  • 动静代理和动态代理

    动静代理与动态代理相比拟，最大的益处是接口中申明的所有办法都被转移到调用处理器一个集中的办法中解决（InvocationHandler.invoke）。这样，在接口办法数量比拟多的时候，咱们能够进行灵活处理，而不须要像动态代理那样每一个办法进行直达。

    如果接口减少一个办法，动态代理模式除了所有实现类须要实现这个办法外，所有代理类也须要实现此办法。减少了代码保护的复杂度。而动静代理不会呈现该问题

17.3 代理模式利用场景

  • 近程（Remote）代理

    本地服务通过网络申请近程服务。为了实现本地到近程的通信，咱们须要实现网络通信，解决其中可能的异样。为良好的代码设计和可维护性，咱们将网络通信局部暗藏起来，只裸露给本地服务一个接口，通过该接口即可拜访近程服务提供的性能，而不用过多关怀通信局部的细节。

  • 防火墙（Firewall）代理

    当你将浏览器配置成应用代理性能时，防火墙就将你的浏览器的申请转给互联网；当互联网返回响应时，代理服务器再把它转给你的浏览器。

  • 爱护（Protect or Access）代理

    管制对一个对象的拜访，如果须要，能够给不同的用户提供不同级别的应用权限。

写在最初

  • 如果我的文章对你有用，请给我点个👍，感激你😊！
  • 有问题，欢送在评论区指出！💪

正文完
java
发表至： java
2021-07-11
 0
关于java:别再用-kill-9-了这才是微服务上下线的正确姿势
关于java:分布式日志组件GrayLog入门
关于java:JVM类加载机制
Java泛型