代理模式详解

柔光的暖阳◎ 2024-03-22 17:36 55阅读 0赞

### **第一节 代理模式介绍** ###

#### **1. 什么是代理模式** ####

代理(Proxy)是一种设计模式，提供了对目标对象另外的访问方式，即通过代理对象访问目标对象.这样做的好处是:**可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.**

代理模式分为静态代理和动态代理两种

#### **2. 静态代理** ####

静态代理在使用时,需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者继承相同的父类

**2.1 案例**

使用静态代理完成苹果手机专卖店代理苹果手机批发商卖手机的这一过程

* 定义接口
 
 package com.qf.proxy._static;
 
 public interface Seller {
    /**
     * 卖手机
     * @param price
     */
    void sellPhoneX(double price);
 }
 * 定义苹果手机批发商
 
 package com.qf.proxy._static;
 
 /**
 * 苹果手机批发商A
 */
 public class IPhoneWholesaler implements Seller{
 
    @Override
    public void sellPhoneX(double price) {
        System.out.println("苹果手机批发商A卖手机价格为：" + price);
   }
 }
 * 定义苹果手机专卖店
 
 package com.qf.proxy._static;
 
 /**
 * 苹果手机专卖店A代理卖苹果手机
 */
 public class IPhoneSpecialtyStoreA implements Seller{
 
    private  IPhoneWholesaler wholesaler;
 
    public IPhoneSpecialtyStoreA(IPhoneWholesaler wholesaler){
        this.wholesaler = wholesaler;
   }
 
    @Override
    public void sellPhoneX(double price) {
        double profit = 1000;
        System.out.println("代理盈利：" + profit);
        wholesaler.sellPhoneX(price);
        System.out.println("卖出价格：" + (price + profit));
   }
 }
 * 编写测试案例
 
 package com.qf.proxy._static;
 
 public class IPhoneSpecialtyStoreATest {
 
    public static void main(String[] args) {
        IPhoneWholesaler wholesaler = new IPhoneWholesaler();
        IPhoneSpecialtyStoreA specialtyStoreA = new IPhoneSpecialtyStoreA(wholesaler);
        specialtyStoreA.sellPhoneX(12000);
   }
 }

结论： **静态代理可以在不改变原有功能的基础上，对功能进行增强。**

**2.2 静态代理引发的问题**

假如现在又有一家专卖店准备代理售卖苹果手机，那么会出现如下的编码

如果有更多的专卖店来代理售卖苹果手机，那么这样的编码会反复出现多次。一旦批发商发生改变或者售卖产品发生改变，代理商也必须跟随者做出相应的改变。

如何应对这种变化呢？

使用动态代理。

**2.3 静态代理 >> 动态代理**

改变代理对象的方法调用思路

这里就出现了反射中 Method 对象，如果能够将 Method 对象的调用及前后实现的功能增强交给用户来实现，那么代理模式就可以为任何对象做代理了。

要实现用户自己定义增强功能，只能以接口的形式来定义，因为接口就是定义规则，用户遵守这个规则即可。那么如何来定义规则呢？分析代码不难发现，Method 对象的调用无非需要两个参数，一个是代理对象，一个是方法执行的参数。因为代理对象会变化，由用户自行决定，因此可以不考虑。那么就只剩下方法的参数了。而 Method 对象的调用也应该在用户的实现过程中，因此，Method对象也应该作为接口考虑的点。所以接口可以按下面的方式来定义：

public interface MethodInvocationHandler {
 
    Object invoke(Method method, Object[] args) throws IllegalArgumentException;
 }

此时使用 `MethodInvocationHandler` 来实现代理

修改测试案例

批发商改变

再次修改测试案例

到此，批发商改变问题就已经得到解决。

那么接下来需要考虑的就是大量的专卖店开进行代理售卖苹果手机的问题。那么就会产生大量的代理类。例如：

这些类都是属于代理，都使用了 `MethodInvocationHandler` 来完成代理的功能。可以将这些共有的功能抽取到父类中。

package com.qf.proxy._static;
 //因为是给代理继承使用，因此父类命名带有Proxy，创建出来的对象自然称为代理
 public class MyProxy {
 
    protected MethodInvocationHandler handler;
 
    protected MyProxy(MethodInvocationHandler handler) {
        this.handler = handler;
   }
 }
 
 package com.qf.proxy._static;
 
 import java.lang.reflect.Method;
 
 /**
 * 苹果手机专卖店A代理卖苹果手机
 */
 public class IPhoneSpecialtyStoreA extends MyProxy implements Seller{
 
    private static Method m;
    static {
        try {
            m = Class.forName("com.qf.proxy._static.Seller").getMethod("sellPhoneX", double.class);
       } catch (NoSuchMethodException e) {
            e.printStackTrace();
       } catch (ClassNotFoundException e) {
            e.printStackTrace();
       }
   }
 
    public IPhoneSpecialtyStoreA(MethodInvocationHandler handler){
        super(handler);
   }
 
    @Override
    public void sellPhoneX(double price) {
        handler.invoke(m, new Object[]{ price });
   }
 }
 
 package com.qf.proxy._static;
 
 import java.lang.reflect.Method;
 
 /**
 * 苹果手机专卖店B代理卖苹果手机
 */
 public class IPhoneSpecialtyStoreB extends MyProxy implements Seller{
 
    private static Method m;
    static {
        try {
            m = Class.forName("com.qf.proxy._static.Seller").getMethod("sellPhoneX", double.class);
       } catch (NoSuchMethodException e) {
            e.printStackTrace();
       } catch (ClassNotFoundException e) {
            e.printStackTrace();
       }
   }
 
    public IPhoneSpecialtyStoreB(MethodInvocationHandler handler){
        super(handler);
   }
 
    @Override
    public void sellPhoneX(double price) {
        handler.invoke(m, new Object[]{ price });
   }
 }

共有的功能抽取只是解决代码冗余问题，并没有解决上面提到的代理繁多的问题。如果这些代理类能够

使用代码来生成，然后再编译，再加载至 `JVM` 中，那么再多的代理也就不是问题了。

参照 `IPhoneSpecialtyStoreA` 来编写代理类生成代码，在 `MyProxy` 中编写如下方法：

private static String generateProxyClass(Class<?> clazz){
    if(!clazz.isInterface()) throw new IllegalArgumentException(clazz.getName() + " 不是接口");
    StringBuilder builder = new StringBuilder();
    builder.append("package ").append(clazz.getPackage().getName()).append(";\n");
    builder.append("import ").append(Method.class.getName()).append(";\n");
    builder.append("import ").append(MethodInvocationHandler.class.getName()).append(";\n");
    builder.append("import ").append(MyProxy.class.getName()).append(";\n");
    builder.append("public class $proxy0 extends MyProxy implements ").append(clazz.getSimpleName()).append("{\n");
    StringBuilder staticBuilder = new StringBuilder();
    staticBuilder.append("static {\n");
    staticBuilder.append("try {\n");
    StringBuilder overrideMethodBuilder = new StringBuilder();
    Method[] methods = clazz.getMethods();
    for(int i=0; i<methods.length; i++){
        builder.append("private static Method m").append(i).append(";\n");
        staticBuilder.append("m").append(i).append("=Class.forName(\"").append(clazz.getName()).append("\").getMethod(\"")
           .append(methods[i].getName()).append("\",");
        overrideMethodBuilder.append("\n@Override\n");
        overrideMethodBuilder.append("public ").append(methods[i].getReturnType().getSimpleName()).append(" ").append(methods[i].getName()).append("(");
        Parameter[] parameters = methods[i].getParameters();
        for(Parameter parameter : parameters){
            staticBuilder.append(parameter.getType().getSimpleName()).append(".class,");
            overrideMethodBuilder.append(parameter.getType().getSimpleName()).append(" ").append(parameter.getName()).append(",");
       }
        staticBuilder.deleteCharAt(staticBuilder.length()-1);
        staticBuilder.append(");\n");
        if(parameters.length > 0)
            overrideMethodBuilder.deleteCharAt(overrideMethodBuilder.length()-1);
        overrideMethodBuilder.append("){\n");
        Class returnType = methods[i].getReturnType();
        if(returnType != Void.class && returnType != void.class)
            overrideMethodBuilder.append("return (").append(methods[i].getReturnType().getSimpleName()).append(")");
        overrideMethodBuilder.append("handler.invoke(m").append(i).append(",new Object[]{");
        for(Parameter parameter : parameters){
            overrideMethodBuilder.append(parameter.getName()).append(",");
       }
        if(parameters.length > 0)
            overrideMethodBuilder.deleteCharAt(overrideMethodBuilder.length()-1);
        overrideMethodBuilder.append("});\n}");
   }
    staticBuilder.append("} catch (NoSuchMethodException e) {\ne.printStackTrace();\n}catch (ClassNotFoundException e) {\ne.printStackTrace();\n}\n");
    staticBuilder.append("}\n");
    builder.append(staticBuilder);
    builder.append("protected $proxy0(MethodInvocationHandler handler) {\nsuper(handler);\n}\n");
    builder.append(overrideMethodBuilder);
    builder.append("\n}");
    System.out.println(builder);
    return builder.toString();
 }

将生成的代理类保存至磁盘中，在 `MyProxy` 中编写如下方法：

编译代理类源文件，在 `MyProxy` 中编写如下方法：

加载编译好的代理类，这里需要自定义类加载器

编写创建代理实例的方法，在 `MyProxy` 中编写如下方法：

public static Object newProxyInstance(Class<?> clazz, MyClassLoader loader, MethodInvocationHandler handler) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    String proxyClass = generateProxyClass(clazz);
    saveProxyClass(proxyClass);
    compileProxyClass();
    Class<?> cl = loader.findClass("$proxy0.class");
    Constructor<?> constructor = cl.getDeclaredConstructor(MethodInvocationHandler.class);
    constructor.setAccessible(true);
    return constructor.newInstance(handler);
 }

编写测试案例

package com.qf.proxy._static;
 
 import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
 public class MyProxyTest {
 
    public static void main(String[] args) throws NoSuchMethodException, IOException, InstantiationException, IllegalAccessException, InvocationTargetException, ClassNotFoundException {
        IPhoneWholesalerNew wholesalerNew = new IPhoneWholesalerNew();
        MethodInvocationHandler handler = new MethodInvocationHandler() {
            @Override
            public Object invoke(Method method, Object[] args) throws IllegalArgumentException {
                double profit = 1000;
                System.out.println("代理盈利：" + profit);
                Object result = null;
                try {
                    result = method.invoke(wholesalerNew, args);
               } catch (IllegalAccessException | InvocationTargetException e) {
                    e.printStackTrace();
               }
                System.out.println("卖出价格：" + ((double)args[0] + profit));
                return result;
           }
       };
        MyClassLoader loader = new MyClassLoader(new File("d:\\"), Seller.class);
        Seller seller = (Seller) MyProxy.newProxyInstance(Seller.class, loader, handler);
        seller.sellPhoneX(12000);
   }
 }

到此代理繁多的问题也就是 解决了，这种实现方式称之为动态代理。

思考：如果实现多个接口，怎么处理？

#### **3. 动态代理** ####

动态代理根据代理的实现又分为 `JDK` 动态代理和 `CGLIB` 动态代理。如果是对接口做代理，那么使用的 `JDK` 动态代理；如果是对类做代理，那么使用的就是 `CGLIB` 动态代理。