设计模式-代理模式

代理模式

参考资料

图解设计模式

大话设计模式

设计模式之禅

github我见过最好的设计模式

http://c.biancheng.net/view/1326.html

定义

• 代理模式为其他对象提供一种代理，用来控制对于这个对象的访问
• 在客户类和目标类之间起到中介作用
• 结构型设计模式

类图

image-20210103193938980

生活中的代理模式

• 房产中介
• 快递小哥
• 黄牛党

使用场景

• 保护目标对象
• 增强目标对象的功能

案例

静态代理

显示声明被代理的对象

image-20210103191744391

public class ZhangLaosan implements IPerson {

  private IPerson zhangsan;

  public ZhangLaosan(IPerson person) {
    this.zhangsan = person;
  }

  public void findLove() {
    System.out.println("张老三开始物色");
    person.findLove();
    System.out.println("开始交往");
  }

}

编译期就清楚了

有点类似于装饰者模式

动态代理

JDK

• Proxy#newProxyInstance
• InvocationHandler

image-20210103192839331

public class JdkMeipo implements InvocationHandler {
  private IPerson target;
  public IPerson getInstance(IPerson target){
    this.target = target;
    Class clazz =  target.getClass();
    return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
  }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    before();
    Object result = method.invoke(this.target,args);
    after();
    return result;
  }

  private void after() {
    System.out.println("双方同意，开始交往");
  }

  private void before() {
    System.out.println("我是媒婆，已经收集到你的需求，开始物色");
  }
}

问题

好像动态代理和静态代理没有区别

• 动态代理编译期确认的，没有硬编码

cglibProxy

导入依赖

  cglib
  cglib-nodep
  2.2

• 实现net.sf.cglib.proxy.MethodInterceptor

public class CGlibMeipo implements MethodInterceptor {

  public Object getInstance(Class clazz) throws Exception{
    //相当于Proxy，代理的工具类
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(clazz);
    enhancer.setCallback(this);
    return enhancer.create();
  }

  public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    before();
    Object obj = methodProxy.invokeSuper(o,objects);
    after();
    return obj;
  }

  private void before(){
    System.out.println("我是媒婆，我要给你找对象，现在已经确认你的需求");
    System.out.println("开始物色");
  }

  private void after(){
    System.out.println("OK的话，准备办事");
  }
}

一般$开头的类都是动态代理的类

深入了解代理模式

JDK的动态代理

通过反编译来查看字节码文件

    public static void generator() {
        byte[] bytes = ProxyGenerator.generateProxyClass("$proxy0", new Class[]{IPerson.class});
        FileOutputStream os = null;
        try {
            os = new FileOutputStream("/Users/zzy/Downloads/$proxy0.class");
            os.write(bytes);
            os.close();
            System.out.println("print success");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

反编译对应文件

jad $Proxy0.class

jad安装步骤可以参考https://blog.csdn.net/qing_gee/article/details/86510704

也可以直接放到idea中查看

编译后的内容如下

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

import com.zzjson.pattern.proxy.dynamicproxy.jdkproxy.IPerson;
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 IPerson {
  private static Method m1;
  private static Method m4;
  private static Method m2;
  private static Method m3;
  private static Method m0;

  public $proxy0(InvocationHandler var1) throws  {
    super(var1);
  }

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

  public final void findLove() throws  {
    try {
      super.h.invoke(this, m4, (Object[])null);
    } catch (RuntimeException | Error var2) {
      throw var2;
    } catch (Throwable var3) {
      throw new UndeclaredThrowableException(var3);
    }
  }

  public final String toString() throws  {
    try {
      return (String)super.h.invoke(this, m2, (Object[])null);
    } catch (RuntimeException | Error var2) {
      throw var2;
    } catch (Throwable var3) {
      throw new UndeclaredThrowableException(var3);
    }
  }

  public final void buyInsure() throws  {
    try {
      super.h.invoke(this, m3, (Object[])null);
    } catch (RuntimeException | Error var2) {
      throw var2;
    } catch (Throwable var3) {
      throw new UndeclaredThrowableException(var3);
    }
  }

  public final int hashCode() throws  {
    try {
      return (Integer)super.h.invoke(this, m0, (Object[])null);
    } catch (RuntimeException | Error var2) {
      throw var2;
    } catch (Throwable var3) {
      throw new UndeclaredThrowableException(var3);
    }
  }

  static {
    try {
      m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
      m4 = Class.forName(" com.zzjson.pattern.proxy.dynamicproxy.jdkproxy.IPerson").getMethod("findLove");
      m2 = Class.forName("java.lang.Object").getMethod("toString");
      m3 = Class.forName(" com.zzjson.pattern.proxy.dynamicproxy.jdkproxy.IPerson").getMethod("buyInsure");
      m0 = Class.forName("java.lang.Object").getMethod("hashCode");
    } catch (NoSuchMethodException var2) {
      throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
      throw new NoClassDefFoundError(var3.getMessage());
    }
  }
}

关键代码

public final void findLove() throws  {
  try {
    super.h.invoke(this, m4, (Object[])null);
  } catch (RuntimeException | Error var2) {
    throw var2;
  } catch (Throwable var3) {
    throw new UndeclaredThrowableException(var3);
  }
}

h实际上就是代理对象

所以说实际上就是调用的

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  before();
  Object result = method.invoke(this.target,args);
  after();
  return result;
}

手写

1. 动态生成源码.java文件

   1. 自己手动拼代码

2. Java文件输出到磁盘，保存为文件$Proxy0.java

   String filePath = MyProxy.class.getResource("").getPath();
   //           System.out.println(filePath);
   File f = new File(filePath + "$Proxy0.java");
   FileWriter fw = new FileWriter(f);
   fw.write(src);
   fw.flush();
   fw.close();
   

3. 把.java文件编译成$proxy0.class文件

   JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
   StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);
   Iterable iterable = manage.getJavaFileObjects(f);
   
   JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);
   task.call();
   manage.close();
   

4. 把生成的.class文件加载到JVM中

   Class proxyClass =  classLoader.findClass("$Proxy0");
   Constructor c = proxyClass.getConstructor(MyInvocationHandler.class);
   f.delete();
   

5. 返回新的代理对象

    return c.newInstance(h);
   

自己的类加载器

public class MyClassLoader extends ClassLoader {

  private File classPathFile;
  public MyClassLoader(){
    String classPath = MyClassLoader.class.getResource("").getPath();
    this.classPathFile = new File(classPath);
  }

  @Override
  protected Class findClass(String name) throws ClassNotFoundException {

    String className = MyClassLoader.class.getPackage().getName() + "." + name;
    if(classPathFile  != null){
      File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
      if(classFile.exists()){
        FileInputStream in = null;
        ByteArrayOutputStream out = null;
        try{
          in = new FileInputStream(classFile);
          out = new ByteArrayOutputStream();
          byte [] buff = new byte[1024];
          int len;
          while ((len = in.read(buff)) != -1){
            out.write(buff,0,len);
          }
          return defineClass(className,out.toByteArray(),0,out.size());
        }catch (Exception e){
          e.printStackTrace();
        }
      }
    }
    return null;
  }
}

CGLIb和DJK的区别

• CGLIB采用继承的方式，重写父类的方法
• JDK采用的方式，要求代理的目标对象一定要实现一个接口

思想：都是通过生成字节码，重组成一个新的类

• JDK Proxy对于用户而言，依赖性更强，调用也更加安全
• CGLIB要求目标类不能有final的方法，final方法不能被代理
• CGLIB更快
  • 效率更高，性能也更高，底层没有用到反射
• JDK的生成逻辑较为简单，执行效率姚笛，每次都要用反射

常见的动态代理

Spring

AOP

BeanPostProcessor核心还是在对象后置处理器

AbstractAdvisingBeanPostProcessor#postProcessAfterInitialization`

org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor#postProcessAfterInitialization

public Object postProcessAfterInitialization(Object bean, String beanName) {
  if (this.advisor == null || bean instanceof AopInfrastructureBean) {
    // Ignore AOP infrastructure such as scoped proxies.
    return bean;
  }

  if (bean instanceof Advised) {
    Advised advised = (Advised) bean;
    if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
      // Add our local Advisor to the existing proxy's Advisor chain...
      if (this.beforeExistingAdvisors) {
        advised.addAdvisor(0, this.advisor);
      }
      else {
        advised.addAdvisor(this.advisor);
      }
      return bean;
    }
  }

  if (isEligible(bean, beanName)) {
    ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
    if (!proxyFactory.isProxyTargetClass()) {
      evaluateProxyInterfaces(bean.getClass(), proxyFactory);
    }
    proxyFactory.addAdvisor(this.advisor);
    customizeProxyFactory(proxyFactory);
    return proxyFactory.getProxy(getProxyClassLoader());
  }

  // No proxy needed.
  return bean;
}

最终会执行到

DefaultAopProxyFactory#createAopProxy

org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy

    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

JDK动态代理

public Object getProxy(@Nullable ClassLoader classLoader) {
  if (logger.isTraceEnabled()) {
    logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
  }
  Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
  findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
  return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

对应的InvocationHandler

org.springframework.aop.framework.JdkDynamicAopProxy#invoke

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  Object oldProxy = null;
  boolean setProxyContext = false;

  TargetSource targetSource = this.advised.targetSource;
  Object target = null;

  try {
    if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
      // The target does not implement the equals(Object) method itself.
      return equals(args[0]);
    }
    else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
      // The target does not implement the hashCode() method itself.
      return hashCode();
    }
    else if (method.getDeclaringClass() == DecoratingProxy.class) {
      // There is only getDecoratedClass() declared -> dispatch to proxy config.
      return AopProxyUtils.ultimateTargetClass(this.advised);
    }
    else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
             method.getDeclaringClass().isAssignableFrom(Advised.class)) {
      // Service invocations on ProxyConfig with the proxy config...
      return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
    }

    Object retVal;

    if (this.advised.exposeProxy) {
      // Make invocation available if necessary.
      oldProxy = AopContext.setCurrentProxy(proxy);
      setProxyContext = true;
    }

    // Get as late as possible to minimize the time we "own" the target,
    // in case it comes from a pool.
    target = targetSource.getTarget();
    Class targetClass = (target != null ? target.getClass() : null);

    // Get the interception chain for this method.
    List