什么是代理模式?

前言

设计模式系列文章，主要是把自己开发过程中用到的设计模式。温习一下，并且记录这个过程。

什么是代理模式?

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。
通俗的来讲代理模式就是我们生活中常见的中介。
为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。

举个栗子： 我要买一套二手房，这时我的核心诉求就是买房，需要做的事情就是选房、付钱。可是现实情况是你需要讨价还价、验房、过户、缴纳各种契税等。这时候你就可以找到房屋中介，他来给你办这个事情，你只需要交钱就可以了。

静态代理和动态代理

代理模式根据代理类的生成时机，分为静态代理和动态代理

静态代理： 是在java文件编译前，已经写好代理类对象。这样只能代理一类对象，即一类接口的类型
优点： 静态代理对调用者隐藏了被代理类接口的具体实现类，在一定程度上实现了解耦合，同时提高了安全性！
缺点： 静态代理类需要实现目标类（被代理类）的接口，并实现其方法，造成了代码的大量冗余。而且只能为固定的接口提供代理，灵活性不强。

动态代理： 是通过反射原理，在程序运行的时候动态的生成的代理对象，所以可以代理任意的类对象。
优点： 可以为实现了同一个接口的实现类提供代理，并且不需要像静态代理那样，在每个方法里面去增加操作，拓展性变强，冗余代码大大减少。
缺点： 相比于静态代理来说。冒的缺点…

实现方式

静态代理真实使用场景较少，这里不做详细的描述。主要讲下项目中常用的动态代理
动态代理的实现方式，有JDK动态代理和CGLIB两种实现方式

JDK动态代理

利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

定义一个接口

package com.tansen.study.proxy;

/**
 * 定义一个计算器接口
 *
 * @author sam
 * @version 1.0.0
 * @date 2021/4/13
 */
public interface Calculator {
   int add(int i, int j);

   int subtract(int i, int j);

   int multiple(int i, int j);

   int divide(int i, int j);
}

定义一个计算器的实现类

package com.tansen.study.proxy;

/**
 * 计算器实现类
 *
 * @author sam
 * @version 1.0.0
 * @date 2021/4/13
 */
public class MyCalculator implements Calculator {

    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    @Override
    public int subtract(int i, int j) {
        int result = i - j;
        return result;
    }

    @Override
    public int multiple(int i, int j) {
        int result = i * j;
        return result;
    }

    @Override
    public int divide(int i, int j) {
        int result = i / j;
        return result;
    }
}

定义一个代理类

/**
 * 获取代理
 * 要想代理类更加的通用，也可以将接口入参调整为Object
 * 这样的话传入什么，生成的就是什么
 *
 * @author sam
 * @version 1.0.0
 * @date 2021/4/13
 */
public class CalculatorProxy {

    public static Calculator getProxy(final Calculator calculator){
        //获取类加载器
        ClassLoader classLoader = calculator.getClass().getClassLoader();

        //获取需要实现的接口
        Class<?>[] interfaces = calculator.getClass().getInterfaces();

        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("方法名称：" + method.getName() + ",方法入参：" + args[0] + "," + args[1]);
                Object result = method.invoke(calculator, args);
                return result;
            }
        };

        Object o = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);

        return (Calculator)o;
    }
}

调用

/**
 * 调用
 *
 * @author sam
 * @version 1.0.0
 * @date 2021/4/13
 */
public class Test {
    public static void main(String[] args) {
        Calculator proxy = CalculatorProxy.getProxy(new MyCalculator());
        System.out.println(proxy.add(1, 1));
        System.out.println(proxy.subtract(1, 1));
        System.out.println(proxy.multiple(3, 6));
        System.out.println(proxy.divide(4, 2));
        System.out.println(proxy.getClass());

    }
}

代理处理的结果

JDK动态代理源码解析

jdk动态代理，生成代理对象的重点就在Proxy.class的567行apply()

 @Override
 public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
 
     Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
     
     for (Class<?> intf : interfaces) {
         Class<?> interfaceClass = null;
         try {
             interfaceClass = Class.forName(intf.getName(), false, loader);
         } catch (ClassNotFoundException e) {
         }
         if (interfaceClass != intf) {
             throw new IllegalArgumentException(
                 intf + " is not visible from class loader");
         }
         
         if (!interfaceClass.isInterface()) {
             throw new IllegalArgumentException(
                 interfaceClass.getName() + " is not an interface");
         }
         
         if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
             throw new IllegalArgumentException(
                 "repeated interface: " + interfaceClass.getName());
         }
     }
	//上面这部分都是校验
     String proxyPkg = null;     // package to define proxy class in
     int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
     
     for (Class<?> intf : interfaces) {
         int flags = intf.getModifiers();
         if (!Modifier.isPublic(flags)) {
             accessFlags = Modifier.FINAL;
             String name = intf.getName();
             int n = name.lastIndexOf('.');
             String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
             if (proxyPkg == null) {
                 proxyPkg = pkg;
             } else if (!pkg.equals(proxyPkg)) {
                 throw new IllegalArgumentException(
                     "non-public interfaces from different packages");
             }
         }
     }
	//拼接包名
     if (proxyPkg == null) {
         // if no non-public proxy interfaces, use com.sun.proxy package
         proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
     }

     //获取当前最新的代理数量，用于拼接代理对象名称，例如$Proxy0
     long num = nextUniqueNumber.getAndIncrement();
     //proxyClassNamePrefix是一个常量$Proxy
     String proxyName = proxyPkg + proxyClassNamePrefix + num;

     /*
      * Generate the specified proxy class.
      * 生成指定的代理类，将代理类加载到内存中
      */
     byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
         proxyName, interfaces, accessFlags);
     try {
     	//原生方法，生成代理的Class对象
         return defineClass0(loader, proxyName,
                             proxyClassFile, 0, proxyClassFile.length);
     } catch (ClassFormatError e) {
         /*
          * A ClassFormatError here means that (barring bugs in the
          * proxy class generation code) there was some other
          * invalid aspect of the arguments supplied to the proxy
          * class creation (such as virtual machine limitations
          * exceeded).
          */
         throw new IllegalArgumentException(e.toString());
     }
 }

CGLIB动态代理

“代理”的目的是构造一个和被代理的对象有同样行为的对象。
一个对象的行为是在类中定义的，对象只是类的实例。所以构造代理，不一定非得通过持有、包装对象这一种方式。
通过“继承”可以继承父类所有的公开方法，然后可以重写这些方法，在重写时对这些方法增强，这就是cglib的思想。

根据里氏代换原则（LSP），父类需要出现的地方，子类可以出现，所以cglib实现的代理也是可以被正常使用的。

CGLIB不同于JDK动态代理的地方在于，CGLIB不需要去实现接口。

CGLIB部分学习借鉴：https://blog.csdn.net/flyfeifei66/article/details/81481222

实现方式

package com.tansen.study.proxy.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * cglib代理类
 *
 * @author 谭森
 * @version 1.0.0
 * @date 2021/4/17
 */
public class MyCglib implements MethodInterceptor {
	/**
     * 根据给定的类型生成代理类
     * @param clazz
     * @return
     */
    public Object createProxyObj(Class<?> clazz) {
        //通过cglib动态代理获取代理对象的过程，创建调用的对象
        Enhancer enhancer = new Enhancer();
        //设置Enhancer的父类
        enhancer.setSuperclass(clazz);
        //设置enhancer的回调对象
        enhancer.setCallback(this);
        //创建代理对象
        return enhancer.create();
    }


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    	//增强操作
        System.out.println("方法名称：" + method.getName() + ",方法入参：" + objects[0] + "," + objects[1]);
        return methodProxy.invokeSuper(o,objects);
    }
}