代理模式之动静态代理

追踪一下getProxyClass0方法：

private static Class getProxyClass0(ClassLoader loader,
    Class... interfaces) {
    if (interfaces.length > 65535) {
 throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    return proxyClassCache.get(loader, interfaces);
}
//继续查看proxyClassCache的get方法
public V get(K key, P parameter) {
    Objects.requireNonNull(parameter);

    expungeStaleEntries();

    Object cacheKey = CacheKey.valueOf(key, refQueue);

    // lazily install the 2nd level valuesMap for the particular cacheKey
    ConcurrentMap> valuesMap = map.get(cacheKey);
    if (valuesMap == null) {
 ConcurrentMap> oldValuesMap
     = map.putIfAbsent(cacheKey,
  valuesMap = new ConcurrentHashMap<>());
 if (oldValuesMap != null) {
     valuesMap = oldValuesMap;
 }
    }

    // create subKey and retrieve the possible Supplier stored by that
    // subKey from valuesMap
    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    Supplier supplier = valuesMap.get(subKey);
    Factory factory = null;

    while (true) {
 if (supplier != null) {
     // 结合上下文可以看出supplier是个Factory，调用get方法过去代理类类对象
     V value = supplier.get();
     if (value != null) {
  return value;
     }
 }
 // else no supplier in cache
 // or a supplier that returned null (could be a cleared Cachevalue
 // or a Factory that wasn't successful in installing the Cachevalue)

 // lazily construct a Factory
 if (factory == null) {
     factory = new Factory(key, parameter, subKey, valuesMap);
 }

 if (supplier == null) {
     supplier = valuesMap.putIfAbsent(subKey, factory);
     if (supplier == null) {
  // successfully installed Factory
  supplier = factory;
     }
     // else retry with winning supplier
 } else {
     if (valuesMap.replace(subKey, supplier, factory)) {
  // successfully replaced
  // cleared CacheEntry / unsuccessful Factory
  // with our Factory
  supplier = factory;
     } else {
  // retry with current supplier
  supplier = valuesMap.get(subKey);
     }
 }
    }
}

// 保存生成的代理类的字节码文件
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
ProxyHandler proxyHandler = new ProxyHandler(new BuyHouseImpl());
BuyHouse buyHouse = (BuyHouse) proxyHandler.getProxy();
buyHouse.buyHouse();

public final class $Proxy0 extends Proxy implements BuyHouse {
 public final void buyHouse() throws  {
 try {
     //调用ProxyHandler的invoke方法
     super.h.invoke(this, m3, (Object[])null);
 } catch (RuntimeException | Error var2) {
     throw var2;
 } catch (Throwable var3) {
     throw new UndeclaredThrowableException(var3);
 }
    }
}

    cglib
    cglib
    3.3.0

public class MyMethodInterceptor implements MethodInterceptor {

    
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
 System.out.println("我是前置增加功能");
 Object result = methodProxy.invokeSuper(o, objects);
 System.out.println("我是后置增加功能");
 return result;
    }
}

public static void main(String[] args) {
    Enhancer enhancer = new Enhancer();
    //设置代理类父类即被代理对象的class
    enhancer.setSuperclass(BuyHouseImpl.class);
    //设置方法拦截器实例
    enhancer.setCallback(new MyMethodInterceptor());
    //获取代理对象
    BuyHouseImpl buyHouse = (BuyHouseImpl) enhancer.create();
    //调用代理对象代理方法会被方法拦截器拦截
    buyHouse.buyHouse();
}

public Object create() {
    classonly = false;
    argumentTypes = null;
    return createHelper();
}
//接着看createHelper()
private Object createHelper() {
    //执行前校验
    prevalidate();
    //创建EnhancerKey对象
    Object key = KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
      ReflectUtils.getNames(interfaces),
      filter == ALL_ZERO ? null : new WeakCacheKey(filter),
      callbackTypes,
      useFactory,
      interceptDuringConstruction,
      serialVersionUID);
    this.currentKey = key;
    //调用Enhancer父类的create方法
    Object result = super.create(key);
    return result;
}

protected Object create(Object key) {
    try {
 ClassLoader loader = getClassLoader();
 Map cache = CACHE;
 ClassLoaderData data = cache.get(loader);
 if (data == null) {
     synchronized (AbstractClassGenerator.class) {
  cache = CACHE;
  data = cache.get(loader);
  if (data == null) {
      Map newCache = new WeakHashMap(cache);
      data = new ClassLoaderData(loader);
      newCache.put(loader, data);
      CACHE = newCache;
  }
     }
 }
 this.key = key;
 Object obj = data.get(this, getUseCache());
 if (obj instanceof Class) {
     return firstInstance((Class) obj);
 }
 //最终执行这个
 return nextInstance(obj);
    } catch (RuntimeException e) {
 throw e;
    } catch (Error e) {
 throw e;
    } catch (Exception e) {
 throw new CodeGenerationException(e);
    }
}

protected Object nextInstance(Object instance) {
    EnhancerFactoryData data = (EnhancerFactoryData) instance;

    if (classOnly) {
 return data.generatedClass;
    }

    Class[] argumentTypes = this.argumentTypes;
    Object[] arguments = this.arguments;
    if (argumentTypes == null) {
 argumentTypes = Constants.EMPTY_CLASS_ARRAY;
 arguments = null;
    }
    return data.newInstance(argumentTypes, arguments, callbacks);
}
//最终调用了newInstance方法
//第一个参数为代理对象的构造器class，第二个为代理对象构造方法参数，第三个为对应回调对象（方法拦截器）
//根据这些参数反射生成代理对象（通过代理对象构造器calss获取构造器并实例化代理对象）
public Object newInstance(Class[] argumentTypes, Object[] arguments, Callback[] callbacks) {
    setThreadCallbacks(callbacks);
    try {
 // Explicit reference equality is added here just in case Arrays.equals does not have one
 if (primaryConstructorArgTypes == argumentTypes ||
     Arrays.equals(primaryConstructorArgTypes, argumentTypes)) {
     // If we have relevant Constructor instance at hand, just call it
     // This skips "get constructors" machinery
     return ReflectUtils.newInstance(primaryConstructor, arguments);
 }
 // Take a slow path if observing unexpected argument types
 return ReflectUtils.newInstance(generatedClass, argumentTypes, arguments);
    } finally {
 // clear thread callbacks to allow them to be gc'd
 setThreadCallbacks(null);
    }

}

public final void buyHouse() {
    MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
    if (var10000 == null) {
 CGLIB$BIND_CALLBACKS(this);
 var10000 = this.CGLIB$CALLBACK_0;
    }

    if (var10000 != null) {
 var10000.intercept(this, CGLIB$buyHouse$0$Method, CGLIB$emptyArgs, CGLIB$buyHouse$0$Proxy);
    } else {
 super.buyHouse();
    }
}