JDK动态代理的原理

Proxy介绍

之前在研究hook的时候,使用到了Proxy动态代理。它是来自JDK的一个类:

1
2
3
package java.lang.reflect;

public class Proxy implements java.io.Serializable {

关键方法是:

1
2
3
4
5
6
7
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
}

使用起来很简单:

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* 获得动态代理
*
* @return
*/
public Object getProxyInstance() {
return Proxy.newProxyInstance(
realInstance.getClass().getClassLoader(),
realInstance.getClass().getInterfaces(),
this);
//那么这个对象到底是如何创建出来的呢?

}

只是一句话而已,就能得到一个接口的动态代理。

动态代理实现

只是一个很简单的类DynamicProxyInstance.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
* 动态代理对象
* 所谓,动态代理,它的优势,就是我使用之后,获取代理对象,不再依赖外部传入的接口,外部接口变化,我只需要改变真实对象的实例即可
*/
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);

// 看到了吧,同样的一个代理对象,可以实现多个真实对象的代理功能,而不是像静态代理一样,需要改动代理类
}
}

其他关联的类和接口是:

1
2
3
4
5
6
7
8
9
10
11
/**
* 公共接口,统一定义代理类和被代理类的行为
*/
public interface CommInterface {
/**
* 购买情趣娃娃
*
* @param size 娃娃的尺寸
*/
abstract void buyManTools(int size);
}
1
2
3
4
5
6
7
8
9
10
11
/**
* 公共接口,统一定义代理类和被代理类的行为
*/
public interface CommInterface2 {
/**
* 购买情趣娃娃
*
* @param size 娃娃的尺寸
*/
abstract void buyWomenTools(int size);
}
1
2
3
4
5
6
7
8
9
10
11
/**
* 真实对象
*/
public class RealInstance implements CommInterface {

@Override
public void buyManTools(int size) {
System.out.println("购买男性用品:size" + size);
}

}
1
2
3
4
5
6
7
8
9
10
11
/**
* 真实对象
*/
public class RealInstance2 implements CommInterface2 {

@Override
public void buyWomenTools(int size) {
System.out.println("购买女性用品::size" + size);
}

}

OK,代码贴完了,现在开始实例讲解:
上面的代码,是在模拟XX用品销售,男用、女用的分别用两个接口来定义,为了定义这两个功能,我用了两个接口,并且用两个实现类分别实现了这两个接口。DynamicProxyInstance.java则是代理类,外界(也就是这里的static void main函数)通过该代理类来进行购买动作

请看这段代码,它是new出了一个proxyObject,并且return出去

1
2
3
4
5
6
public Object getProxyInstance() {
return Proxy.newProxyInstance(realInstance.getClass().getClassLoader(), realInstance.getClass().getInterfaces(),
this);
// 那么这个对象到底是如何创建出来的呢?

}

而,拿到这个对象之后,强转为了CommInterface

1
2
3
// 先看看这个对象在debug的时候,是怎么样的一个对象引用
CommInterface commInterface = (CommInterface) instance.getProxyInstance();
commInterface.buyManTools(30);

为什么它可以强转为CommInterface?因为instance.init(new RealInstance()),这一句当中RealInstanceCommIntance的子类。从结果上来看,通过getInstance方法拿到的Object,直接就具备realInstance的功能。那这个Object到底是什么东西?它是如何生成的?

回到getInstance()方法,通过debug,我们发现

1
CommInterface commInterface = (CommInterface) instance.getProxyInstance();

它是一个名为$Proxy0的类的实例,其真实类型是RealInstance$Proxy0名字很诡异,但是先别想这么多,继续往下看

1
CommInterface2 commInterface2 = (CommInterface2) instance.getProxyInstance();

这会又变成了$Proxy1,其真实类型是RealInstance2

从0到1,看上去像是有一个整形序列在参与它的命名,也就是说,如果我们再来一次,肯定就是$Proxy2
$Proxy + 1个数字,这个类是如何生成的?在我们的代码里面命名没有去定义它啊?
进入源码:Proxy.javanewProxyInstance方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException {
Objects.requireNonNull(h);

final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}

/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);

这里有3个参数:

  • 第一个是 类加载器ClassLoader
  • 第二个是 接口(它的作用是定义这个动态代理类的行为)
  • 第三个是 InvocationHanlder实例,它的作用是用来对 被代理对象进行功能扩展

newProxyInstance方法往下看:Class<?> cl = getProxyClass0(loader, intfs);,这里是不是可能生成$Proxy1这种class的地方?进去:

1
2
3
4
5
6
7
8
9
10
11
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对象,它的类型是:WeakCache<ClassLoader, Class<?>[], Class<?>>
它是一个泛型类:final class WeakCache<K, P, V>3个泛型参数。

1
2
3
4
5
/**
* a cache of proxy classes
*/
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

进入proxyClassCache.get(loader, interfaces)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public V get(K key, P parameter) {  //关注点1:入参
Objects.requireNonNull(parameter);

expungeStaleEntries();

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

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

// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); //关注点2:入参的使用
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;

while (true) {
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
V value = supplier.get();
if (value != null) {
return value; //关注点3:函数返回值
}
}

它的作用就是,通过KP,得到V,也就是通过ClassLoaderClass<?>[]得到Class<?>ClassLoader是类加载器,用来创建Class对象的,Class<?>[]其实就是接口数组,Class<?>是最终得到的Class对象。
之前我们探索的就是$Proxy0$Proxy1这个类的来源,那么到底是不是来自于这里呢?
当我们探究源码中的一个方法的时候,关注3个点:

  • 入参类型(这里的入参类型是泛型,具体类型要看这个当前对象在创建的时候,泛型具体化使用的是什么类)
  • 使用参数的地方(我们入参传递进来,自然要产生作用,那么直接关心入参使用的代码即可)
  • 方法返回值,(上面的这个方法有返回值,类型是泛型,也去看初始化对象的时候使用的V是什么类型,然后方法里面返回的value,就是我们最终需要的对象)

关注subkeyFactory.apply,在Proxy中,定义WeakCache的时候,就new了一个KeyFactory和一个ProxyClassFactory传进去,分别作为WeakCachesubkeyFactory成员和valueFactory成员

1
2
3
4
5
6
final class WeakCache<K, P, V> {
public WeakCache(BiFunction<K, P, ?> subKeyFactory,
BiFunction<K, P, V> valueFactory) {
this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
this.valueFactory = Objects.requireNonNull(valueFactory);
}

上面,我们只使用了subkeyFactory.apply,它走的是这个过程:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Proxy implements java.io.Serializable {

/**
* A function that maps an array of interfaces to an optimal key where
* Class objects representing interfaces are weakly referenced.
*/
private static final class KeyFactory
implements BiFunction<ClassLoader, Class<?>[], Object>
{
@Override
public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
switch (interfaces.length) {
case 1: return new Key1(interfaces[0]); // the most frequent
case 2: return new Key2(interfaces[0], interfaces[1]);
case 0: return key0;
default: return new KeyX(interfaces);
}
}
}

根据参数interfaces.length的不同,返回不同的Key对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); //拿到key对象
Supplier<V> supplier = valuesMap.get(subKey); //使用key对象,尝试从valuesMap中取出valueFactory
Factory factory = null;

while (true) { //无限循环
if (supplier != null) { //如果前面取到的supplier不是空
// supplier might be a Factory or a CacheValue<V> instance
V value = supplier.get(); //那就从supplier中取出value,并且返回出去
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) { //如果到了这一步,说明前面没有return,建立一个工厂
factory = new Factory(key, parameter, subKey, valuesMap);
}

if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory); //putIfAbsent的作用相当于,一个map,如果存了subKey对应的value,就返回这个value,如果没有存,就存进去
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);
}
}
}

上面这段代码的注释如果看懂了的话,就基本明白了,它这里就是建了一个无限循环检测机制,最终结果都是要从supplierget一个value返回出去,如果supplier是空,那就建一个Factory赋值给supplier(其实Factory是继承至Supplier的)

那么下一步,我们的关注点转移到,当supplier为空的时候,源码是如何建立一个Factory作为它的实例的?

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

进入Factory,它实现Supplier接口,这个接口中只有一个方法get,看看这个get方法是如何实现的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
private final class Factory implements Supplier<V> {

private final K key;
private final P parameter;
private final Object subKey;
private final ConcurrentMap<Object, Supplier<V>> valuesMap;

Factory(K key, P parameter, Object subKey,
ConcurrentMap<Object, Supplier<V>> valuesMap) {
this.key = key;
this.parameter = parameter;
this.subKey = subKey;
this.valuesMap = valuesMap;
}

@Override
public synchronized V get() { // serialize access
// re-check
Supplier<V> supplier = valuesMap.get(subKey); //看来这里有缓存机制
if (supplier != this) {
// something changed while we were waiting:
// might be that we were replaced by a CacheValue
// or were removed because of failure ->
// return null to signal WeakCache.get() to retry
// the loop
return null;
}
// else still us (supplier == this)

// create new value
V value = null;
try {
value = Objects.requireNonNull(valueFactory.apply(key, parameter)); //这里通过valueFactory.apply拿到value
} finally {
if (value == null) { // remove us on failure
valuesMap.remove(subKey, this);
}
}
// the only path to reach here is with non-null value
assert value != null;

// wrap value with CacheValue (WeakReference)
CacheValue<V> cacheValue = new CacheValue<>(value);

// put into reverseMap
reverseMap.put(cacheValue, Boolean.TRUE);

// try replacing us with CacheValue (this should always succeed)
if (!valuesMap.replace(subKey, this, cacheValue)) {
throw new AssertionError("Should not reach here");
}

// successfully replaced us with new CacheValue -> return the value
// wrapped by it
return value; //最终返回出去的对象
}
}

所以最终,我们还要进入valueFactory中去看看它的apply是如何实现的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
public class Proxy implements java.io.Serializable {

private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy"; //类名前缀

// next number to use for generation of unique proxy class names
private static final AtomicLong nextUniqueNumber = new AtomicLong(); //全局计数器,计算下一个代理类对象应该以什么数字命名

@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

...

String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package. Verify that
* all non-public proxy interfaces are in the same package.
*/
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 + ".";
}

/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;

/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
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());
}
}
}

这段代码太复杂,这里只贴出关键点(依然和之前一样,入参,使用入参的地方,返回值),这次我们从返回值开始反过来推断:

1
2
3
4
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {

源码直接返回了一个defineClass0(.....),点进去一看,居然是一个native方法,那么探索只能到头了。当然,从结果上来看,它是生成了一个像这样$Proxy0Class代理对象,那么代理Class对象的特征,就只能从参数值来判断了,一个一个参数看:

1
2
private static native Class<?> defineClass0(ClassLoader loader, String name,
byte[] b, int off, int len);
  • ClassLoader loader 类加载器
  • String name 类名
  • byte[] b, int off, int len 字节码IO流相关的参数

反推,类名是如何来的?IO流字节码的3个参数是干什么用的?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num; //包名 类名前缀$Proxy 序号(AtomicLong nextUniqueNumber自增得到)

/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass( //字节码
proxyName, interfaces, accessFlags); //类名 接口 接口修饰符
try {
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());
}

而上面的字节数组byte[] proxyClassFile其实就是定义了这个代理类的行为,它应该能包含什么样的方法,这些方法就是当初传进来的interfaces决定的。

OK,探究完了,代理类的生成已经查完,那么回到起点Class<?> cl = getProxyClass0(loader, intfs),我们拿到这个代理类对象Class<?> cl之后能干啥? 肯定是使用它来反射创建代理对象啊

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
...

/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs); //前面拿到的代理类对象$Proxy0

/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}

final Constructor<?> cons = cl.getConstructor(constructorParams); //取得构造函数
final InvocationHandler ih = h; //这是外部传进来的InvocationHandler对象
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h}); //这里反射创建一个代理类对象并return出去,注意参数h
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}

这里有一个关键点,参数h,它是我们从外部传入的InvocationHandler对象,这个对象定义了我们对被代理类的方法增强,即我们可以在被代理类的指定方法(或者所有方法)执行的过程中,加入前置或者后置过程,还可以设置条件,根据条件决定被代理类的方法要不要执行。那么它是如何发挥作用的呢?

1
2
3
4
5
6
7
8
9
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass( //字节码
proxyName, interfaces, accessFlags); //类名 接口 接口修饰符
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {

还记得这个字节码IO流相关的参数么,其实如果把这个byte[]通过IO流输出到本地文件,其实就是一个.class文件,反编译出来,就是一个.java文件,类似下面的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public final class $Proxy0
extends Proxy //派生自Proxy
implements AaFactory //实现了业务接口
{
private static Method m1; //各种方法
private static Method m8;
private static Method m3;
private static Method m2;
private static Method m6;
private static Method m5;
private static Method m7;
private static Method m9;
private static Method m0;
private static Method m4;

public final void saleManTools(String paramString)
throws
{
try
{
this.h.invoke(this, m3, new Object[] { paramString }); //m3是其中一个代理方法
return;
}

这里保存了来自外部接口的各种方法(命名也是很耿直 m1,m2…..),并且这个saleManTools,就是我们demo中的接口的一个方法,它反射执行了这个方法,这里的h,其实就是我们最初给的invocationHandler对象:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class DynamicProxyInstance implements InvocationHandler {

/**
* 获得动态代理
*
* @return
*/
public Object getProxyInstance() {
return Proxy.newProxyInstance(realInstance.getClass().getClassLoader(), realInstance.getClass().getInterfaces(),
this); //this即InvocationHandler对象

}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
doBefore();
Object res = method.invoke(realInstance, args);
doAfter();
return res;
}

当我们调用代理对象的业务方法时,其实也执行了invocationHandlerinvoke方法,那么对被代理对象的方法的增强或者限制,我们就可以在重写invoke时随意处理了。

结语

就写到这里吧,做个总结,java.lang.reflect.Proxy是JDK提供的动态代理类,我们探索过程中,至少发现了2处使用反射的地方,一处是 反射构造函数,然后执行它,创建代理类对象的过程,一处是使用代理类对象,反射创建代理对象的过程(代理类对象和代理对象是不一样的)。

使用了反射,效率自然比不上静态代理,但是它能保证真实对象无限扩展的时候,代理类不用做修改,只需要在创建代理类的时候,传入不同的真实对象即可,这种做法才符合程序设计的开闭原则,对扩展开放,对修改关闭。

我们去使用一个类,一定会先和获得这个类的class对象,利用Proxy可以动态去创建Proxy0proxy1这样子的class对象。然后才利用这个对象反射执行构造函数去创建proxy0对象。

本文转载至:https://www.jianshu.com/p/647b7cd0a7d9

Powered by AppBlog.CN     浙ICP备14037229号

Copyright © 2012 - 2020 APP开发技术博客 All Rights Reserved.

访客数 : | 访问量 :