源码
PS：这个就不给github项目地址了，它只是一个很简单的类
DynamicProxyInstance .java：如下.
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 动态代理对象
*
* 所谓，动态代理，它的优势，就是我使用之后，获取代理对象，不再依赖外部传入的接口，外部接口变化，我只需要改变真实对象的实例即可。
*
* @author GC-HANK
*
*/
public class DynamicProxyInstance implements InvocationHandler {
// 动态代理，这里不限制具体使用的接口是什么，而是使用Object表示真实对象
private Object realInstance;
public void init(Object realInstance) {
this.realInstance = realInstance;
}
/**
* 获得动态代理
*
* @return
*/
public Object getProxyInstance() {
return Proxy.newProxyInstance(realInstance.getClass().getClassLoader(), realInstance.getClass().getInterfaces(),
this);
// 那么这个对象到底是如何创建出来的呢？
}
/**
* 售前
*/
private void doBefore() {
System.out.println("售前");
}
/**
* 售后
*/
private void doAfter() {
System.out.println("售后");
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
doBefore();
Object res = method.invoke(realInstance, args);
doAfter();
return res;
}
public static void main(String[] args) {
// 动态代理和静态代理的唯一区别，就是在获取代理对象的时候，静态代理获取的是一个不可变功能的对象，一旦获取到，那么它的功能也就确定了
// 而，动态代理，
DynamicProxyInstance instance = new DynamicProxyInstance();
instance.init(new RealInstance());
CommInterface commInterface = (CommInterface) instance.getProxyInstance();
// 先看看这个对象在debug的时候，是怎么样的一个对象引用
commInterface.buyManTools(30);
// 现在，出现了一个 购买女性用品的接口，和它的实现类，也要用代理来访问
// 这样做
instance.init(new RealInstance2());
CommInterface2 commInterface2 = (CommInterface2) instance.getProxyInstance();
commInterface2.buyWomenTools(60);
// 看到了吧，同样的一个代理对象，可以实现多个真实对象的代理功能，而不是像静态代理一样，需要改动代理类
}
}
其他关联的类和接口是:
/**
* 公共接口，统一定义代理类和被代理类的行为
*
* @author GC-HANK
*
*/
public interface CommInterface {
/**
* 购买情趣娃娃
*
* @param size 娃娃的尺寸
*/
abstract void buyManTools(int size);
}
/**
* 公共接口，统一定义代理类和被代理类的行为
*
* @author GC-HANK
*
*/
public interface CommInterface2 {
/**
* 购买情趣娃娃
*
* @param size 娃娃的尺寸
*/
abstract void buyWomenTools(int size);
}
/**
* 真实对象
*
* @author GC-HANK
*
*/
public class RealInstance implements CommInterface {
@Override
public void buyManTools(int size) {
System.out.println("购买男性用品:size" + size);
}
}
/**
* 真实对象
*
* @author GC-HANK
*
*/
public class RealInstance2 implements CommInterface2 {
@Override
public void buyWomenTools(int size) {
System.out.println("购买女性用品::size" + size);
}
}
OK,代码贴完了，现在开始实例讲解：
上面的代码，是在模拟XX用品销售，男用、女用的分别用两个接口来定义，为了定义这两个功能，我用了两个接口，并且用两个实现类分别实现了这两个接口。
DynamicProxyInstance .java则 是代理类，外界（也就是这里的static void main函数）通过该代理类来进行购买动作.
准备开车，踩油门！
请看这段代码，它是new出了一个proxy的Object，并且return出去
public Object getProxyInstance() {
return Proxy.newProxyInstance(realInstance.getClass().getClassLoader(), realInstance.getClass().getInterfaces(),
this);
// 那么这个对象到底是如何创建出来的呢？
}
而，拿到这个对象之后，强转为了CommInterface
// 先看看这个对象在debug的时候，是怎么样的一个对象引用
CommInterface commInterface = (CommInterface) instance.getProxyInstance();
commInterface.buyManTools(30);
为什么它可以强转为 CommInterface?因为instance.init(new RealInstance()); 这一句当中，RealInstance是CommIntance的子类。从结果上来看，通过getInstance方法拿到的Object，直接就具备realInstance的功能. 那这个Object到底是什么东西？它是如何生成的？
回到getInstance()方法，通过debug，我们发现，
它是一个名为$Proxy0的类的实例， 其真实类型是RealInstance . $Proxy0名字很诡异，但是先别想这么多，继续往下看，
这会又变成了
$Proxy1， 其真实类型是RealInstance2.
从0到1，看上去像是有一个整形序列在参与它的命名，也就是说，如果我们再来一次，肯定就是 $Proxy2。
那$Proxy + 1个数字，这个类是如何生成的？在我们的代码里面命名没有去定义它啊？
进入源码：proxy.java的 newProxyInstance方法
这里有
3个参数，
第一个是类加载器classLoader
第二个是接口（它的作用是定义这个动态代理类的行为）
第三个是InvocationHanlder实例，它的作用是用来对 被代理对象进行功能扩展
newProxyInstance方法往下看：结果发现：
这里是不是可能生成
$Proxy1这种class的地方？
进去：
观察一下这个
proxyClassCache对象，它的类型是：WeakCache<ClassLoader, Class<?>[], Class<?>>
它是一个泛型类：final class WeakCache<K, P, V>3个泛型参数。
具体到这个地方，它的作用就是，通过get方法：
通过K和P，得到V，也就是通过 ClassLoader和Class<?>[] 得到 Class<?> ,
有些人看到这里应该有些迷了，感觉被泛型绕晕了，其实很简单，ClassLoader是类加载器，用来创建Class对象的，Class<?>[] 其实就是接口数组，Class<?> 是最终得到的Class对象。
之前我们探索的就是$Proxy1这个类的来源，那么到底是不是来自于这里呢？
当我们探究源码中的一个 方法的时候,关注3个点：
- 入参类型（这里的入参类型是泛型，具体类型要看这个当前对象在创建的时候，泛型具体化使用的是什么类）
- 使用参数的地方（我们入参传递进来，自然要产生作用，那么直接关心入参使用的代码即可）
- 方法返回值，（上面的这个方法有返回值，类型是泛型，也去看初始化对象的时候使用的V是什么类型，然后方法里面返回的value，就是我们最终需要的对象).
这里，我直接给出结论吧。
subkeyFactory.apply， 看下面两个图应该可以明白，在Proxy中，定义WeakCache的时候，就new了一个KeyFactory和一个ProxyClassFactory传进去，分别作为 WeakCache的subkeyFactory成员和valueFactory成员
上面，我们只使用了
subkeyFactory.apply，
它走的是这个过程：
根据参数interfaces.size的不同，返回不同的Key对象。
返回出去之后，
上面这段代码的红色标记如果看懂了的话，就基本明白了，他这里就是建了一个无限循环检测机制，最终结果都是要从supplier中get一个value返回出去，如果supplier是空，那就建一个Factory赋值给supplier(其实Factory是继承子Supplier的)
那么下一步，我们的关注点转移到，当supplier为空的时候，源码是如何建立一个Factory作为它的实例的？
关注这一段：
进入
Factory，它实现Supplier接口，这个接口中只有一个方法get，看看这个get方法是如何实现的
所以最终，我们还要进入valueFactory中去看看 它的 apply是如何实现的:
这段代码太复杂，我就只贴出关键点了（依然和之前一样，入参，使用入参的地方，返回值）：
这次我们从返回值开始反过来推断：
源码 直接返回了一个defineClass0(.....), 点进去一看，居然是一个native方法，那么探索只能到头了，当然，从结果上来看，它是生成了一个像这样$Proxy0 的 Class代理对象，那么代理class对象的特征，就只能从参数值来判断了，一个一个参数看:
ok,反推，类名是如何来的？IO流字节码的3个参数是干什么用的？
上面说的 proxyClassNamePrefix，其实就是
而这个num，它只是一个全局的计数器而已，让程序直到下一个代理类对象应该以什么数字命名.
而上面的字节数组byte[] proxyClassFile 其实就是定义了这个代理类的行为，它应该能包含怎么样的方法，这些方法就是当初传进来的interfaces决定的。
OK，探究完了，代理类的生成已经查完了，那么回到起点：
我们拿到这个代理类对象之后能干啥? 肯定是使用它来反射创建代理对象啊
看上面的关键代码：
这里有一个关键点，参数h，它是我们从外部传入的InvocationHandler对象，这个对象定义了我们对 被代理类的方法增强，即 我们可以在被代理类的指定方法（或者所有方法）执行的过程中，加入前置或者后置过程，还可以设置条件，根据条件决定被代理类的方法要不要执行。
那么它是如何发挥作用的呢？（下面的东西我就不细写过程了，直接给结论）
还记得上图中的这个字节码IO流相关的参数么，其实如果把这个byte[] 通过io流输出到本地文件，其实就是一个.class文件，反编译出来，就是一个java文件，类似下面的：
它这里保存了来自外部接口的各种方法(命名也是很耿直
m1,m2.....),并且这个saleManTools，就是我们demo中的接口的一个方法, 它反射执行了这个方法，这里的h，其实就是我们最初给的invocationHandler对象：
当我们调用代理对象的业务方法时，其实也执行了
invocationHandler的invoke方法，那么对被代理对象的方法的增强或者限制，我们就可以在重写invoke时随意处理了.
结语
就写到这里吧，做个总结，
java.lang.reflect.Proxy是JDK提供的动态代理类，我们探索过程中，至少发现了2处使用反射的地方，一处是 反射构造函数，然后执行它，创建代理类对象的过程，一处是 使用代理类对象，反射创建代理对象的过程（有没有晕？代理类对象和代理对象是不一样的，晕了的话留言，我看到就回答- -！）, 使用了反射，效率自然比不上静态代理，但是它能保证 真实对象无限扩展的时候，代理类不用做修改，只需要在创建代理类的时候，传入不同的真实对象即可，这种做法才符合程序设计的开闭原则，对扩展开放，对修改关闭。
网友评论