代理模式

发布于 2021-03-31  726 次阅读


注解、反射、代理,这几样东西在框架学习中常常能够遇到,以前也看过相关文章,但我总有一种感觉,那就是这些东西是零散的;而当我们的学习宽度和深度提升之后,才会发现这些知识是万丈高楼的基石;

正如今日我准备学习动态代理模式,发现需要有以下的前提知识:

1.代理模式

2.反射

3.类加载

4.JVM内存

5.双亲委派(4.5都由3衍生)

 

特此记录静态代理相关知识(文件夹ProxyAndDynamicProxy):

 

假设现在项目经历有一个需求,在现在所有的老师和学生的吃饭方法前打印对应的食物种类

如何在不修改原有代码的前提下,完成这个需求?

我们可以想到静态代理,具体做法:

1.为现有的每一个类都编写一个对应的代理类(此处只有学生代理类和老师代理类),并让它实现目标类的接口

 

2.在创建代理对象时,通过代理对象内部方法来塞入一个目标对象(这里我采用的是eat方法内部new,其实可以通过构造器塞入,也可以通过Set注入),然后在代理对象的同名方法内部调用目标对象的同名方法(即需要增强或扩展的方法),并在调用方法之前先调用代理对象的打印对应食物种类;

也就是说:代理对象 = 增强代码 +  目标对象

3.业务层之后使用代理对象即可;

静态代理的缺陷:

我们需要手动的为每一个目标类编写对应的代理类(此处我们只需要写学生和老师的,如果要加上工人,白领,警察,消防员,程序员,司机,演员...各行各业的目标类,那工作量是巨大的,同时也非常消耗资源),如果当前系统已经有了成千上万个类,则工作量太大;

所以,现在我们的努力方向是:如何少写或者不写代理类,却完成代理功能?

 

这里涉及到对象的创建知识,让我们先来回顾一下

很多初学Java的朋友眼中创建对象的过程:

 

源代码--->字节码--->JVM运行

实际上可以换个角度,也说得通

 

 

 

JVM层面:类加载ClassLoader加载.class文件到内存,生成Class对象(独一份)--->创建实例对象(详情见类加载)

所谓的Class对象,是Class类的实例,而Class类是描述所有类的,比如Person类,Student类

可以看出,要创建一个实例,最关键的就是得到对应的Class对象。只不过对于初学者来说,new这个关键字配合构造方法,实在太好用了,底层隐藏了太多细节,一句 Person p = new Person();直接把对象返回给你了。我自己刚开始学Java时,也没意识到Class对象的存在。

分析到这里,貌似有了思路:

能否不写代理类,而直接得到代理Class对象,然后根据它创建代理实例(反射)

Class对象包含了一个类的所有信息,比如构造器、方法、字段等。如果我们不写代理类,这些信息从哪获取呢?苦思冥想,突然灵光一现:代理类和目标类理应实现同一组接口。之所以实现相同接口,是为了尽可能保证代理对象的内部结构和目标对象一致,这样我们对代理对象的操作最终都可以转移到目标对象身上,代理对象只需专注于增强代码的编写。还是上面这幅图:

所以,可以这样说:接口拥有代理对象和目标对象共同的类信息。所以,我们可以从接口那得到理应由代理类提供的信息。但是别忘了,接口是无法创建对象的,怎么办?

 

动态代理

JDK提供了java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy类,这两个类相互配合,入口是Proxy,所以我们先聊它。

Proxy有个静态方法:getProxyClass(ClassLoader, interfaces),只要你给它传入类加载器和一组接口,它就给你返回代理Class对象。

用通俗的话说,getProxyClass()这个方法,会从你传入的接口Class中,“拷贝”类结构信息到一个新的Class对象中,但新的Class对象带有构造器,是可以创建对象的。打个比方,一个大内太监(接口Class),空有一身武艺(类信息),但是无法传给后人。现在江湖上有个妙手神医(Proxy类),发明了克隆大法(getProxyClass),不仅能克隆太监的一身武艺,还保留了小DD(构造器)...(这到底是道德の沦丧,还是人性的扭曲,欢迎走进动态代理)

所以,一旦我们明确接口,完全可以通过接口的Class对象,创建一个代理Class,通过代理Class即可创建代理对象。

大体思路
静态代理
动态代理

所以,按我理解,Proxy.getProxyClass()这个方法的本质就是:以Class造Class。

有了Class对象,就很好办了,具体看代码:

完美。

根据代理Class的构造器创建对象时,需要传入InvocationHandler。每次调用代理对象的方法,最终都会调用InvocationHandler的invoke()方法:

怎么做到的呢?

上面不是说了吗,根据代理Class的构造器创建对象时,需要传入InvocationHandler。通过构造器传入一个引用,那么必然有个成员变量去接收。没错,代理对象的内部确实有个成员变量invocationHandler,而且代理对象的每个方法内部都会调用handler.invoke()!InvocationHandler对象成了代理对象和目标对象的桥梁,不像静态代理这么直接。

大家仔细看上图右侧的动态代理,我在invocationHandler的invoke()方法中并没有写目标对象。因为一开始invocationHandler的invoke()里确实没有目标对象,需要我们手动new。

preview

但这种写法不够优雅,属于硬编码。我这次代理A对象,下次想代理B对象还要进来改invoke()方法,太差劲了。改进一下,让调用者把目标对象作为参数传进来:

public class ProxyTest {
	public static void main(String[] args) throws Throwable {
		CalculatorImpl target = new CalculatorImpl();
                //传入目标对象
                //目的:1.根据它实现的接口生成代理对象 2.代理对象调用目标对象方法
		Calculator calculatorProxy = (Calculator) getProxy(target);
		calculatorProxy.add(1, 2);
		calculatorProxy.subtract(2, 1);
	}

	private static Object getProxy(final Object target) throws Exception {
		//参数1:随便找个类加载器给它, 参数2:目标对象实现的接口,让代理对象实现相同接口
		Class proxyClazz = Proxy.getProxyClass(target.getClass().getClassLoader(), target.getClass().getInterfaces());
		Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);
		Object proxy = constructor.newInstance(new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println(method.getName() + "方法开始执行...");
				Object result = method.invoke(target, args);
				System.out.println(result);
				System.out.println(method.getName() + "方法执行结束...");
				return result;
			}
		});
		return proxy;
	}
}

这样就非常灵活,非常优雅了。无论现在系统有多少类,只要你把实例传进来,getProxy()都能给你返回对应的代理对象。就这样,我们完美地跳过了代理类,直接创建了代理对象!

 

个人实现流程:

  1. 创建需要代理的类(即目标类)对象
  2. 传入目标类对象
  3. 根据其实现接口生成代理对象,代理对象调用目标对象方法,动态生成代理
    1. 使用JDK所提供的 Proxy.getProxyClass();
    2. 参数1.类加载器,参数2.接口Class;
    3. 通过接口的Class对象得到有参构造器;
    4. 利用反射通过构造器创建代理实例并返回(invoke方法)
  4. 调用代理对象的方法;

代码及截图如下:

总体结构:

 

不过实际编程中,一般不用getProxyClass(),而是使用Proxy类的另一个静态方法:Proxy.newProxyInstance(),直接返回代理实例,连中间得到代理Class对象的过程都帮你隐藏:

public class ProxyTest {
	public static void main(String[] args) throws Throwable {
		CalculatorImpl target = new CalculatorImpl();
		Calculator calculatorProxy = (Calculator) getProxy(target);
		calculatorProxy.add(1, 2);
		calculatorProxy.subtract(2, 1);
	}

	private static Object getProxy(final Object target) throws Exception {
		Object proxy = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),/*类加载器*/
				target.getClass().getInterfaces(),/*让代理对象和目标对象实现相同接口*/
				new InvocationHandler(){/*代理对象的方法最终都会被JVM导向它的invoke方法*/
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						System.out.println(method.getName() + "方法开始执行...");
						Object result = method.invoke(target, args);
						System.out.println(result);
						System.out.println(method.getName() + "方法执行结束...");
						return result;
					}
				}
		);
		return proxy;
	}
}

现在,我们应该能看懂动态代理了。

最后讨论一下代理对象是什么类型。

首先,请区分两个概念:代理Class对象和代理对象。

代理Class对象:class java.lang.Class
代理对象class com.sun.proxy.$Proxy0

 

代理对象com.DynamicProxy.Pojo.Student@12a3a380

代理Class对象:class com.sun.proxy.$Proxy0

单从名字看,代理Class和Toeat的接口确实相去甚远,但是我们却能将代理对象赋值给接口类型:

千万别觉得名字奇怪,就怀疑它不能用接口接收,只要实现该接口就是该类型。

代理对象的本质就是:和目标对象实现相同接口的实例。代理Class可以叫任何名字,whatever,只要它实现某个接口,就能成为该接口类型。

我写了一个MyProxy类,那么它的Class名字必然叫MyProxy。但这和能否赋值给接口没有任何关系。由于它实现了Serializable和Collection,所以myProxy(代理实例)同时是这两个接口的类型。

 

 

小结

我想了个很骚的比喻,希望能解释清楚:

接口Class对象是大内太监,里面的方法和字段比做他的一身武艺,但是他没有小DD(构造器),所以不能new实例。一身武艺后继无人。

那怎么办呢?

正常途径(implements):

写一个类,实现该接口。这个就相当于大街上拉了一个人,认他做干爹。一身武艺传给他,只是比他干爹多了小DD,可以new实例。

非正常途径(动态代理):

通过妙手圣医Proxy的克隆大法(Proxy.getProxyClass()),克隆一个Class,但是有小DD。所以这个克隆人Class可以创建实例,也就是代理对象。

代理Class其实就是附有构造器的接口Class,一样的类结构信息,却能创建实例。

JDK动态代理:

CGLib动态代理:
preview

如果说继承的父类是亲爹(只有一个),那么实现的接口是干爹(可以有多个)。

实现接口是一个类认干爹的过程。接口无法创建对象,但实现该接口的类可以。

比如

class Student extends Person implements A, B

这个类new一个实例出来,你问它:你爸爸是谁啊?它会告诉你:我只有一个爸爸Person。

但是student instanceof A interface,或者student instanceof B interface,它会告诉你两个都是它干爹(true),都可以用来接收它。

然而,凡是有利必有弊。

也就是说,动态代理生成的代理对象,最终都可以用接口接收,和目标对象一起形成了多态,可以随意切换展示不同的功能。但是切换的同时,只能使用该接口定义的方法。


关于类加载器

初学者可能对诸如“字节码文件”、Class对象比较陌生。所以这里花一点点篇幅介绍一下类加载器的部分原理。如果我们要定义类加载器,需要继承ClassLoader类,并覆盖findClass()方法:

@Override
public Class<?> findClass(String name) throws ClassNotFoundException {
	try {
		/*自己另外写一个getClassData()
                  通过IO流从指定位置读取xxx.class文件得到字节数组*/
		byte[] datas = getClassData(name);
		if(datas == null) {
			throw new ClassNotFoundException("类没有找到:" + name);
		}
		//调用类加载器本身的defineClass()方法,由字节码得到Class对象
		return this.defineClass(name, datas, 0, datas.length);
	} catch (IOException e) {
		e.printStackTrace();
		throw new ClassNotFoundException("类找不到:" + name);
	}
}

所以,这就是类加载之所以能把xxx.class文件加载进内存,并创建对应Class对象的深层原因。

部分知识来源于:https://www.zhihu.com/question/20794107/answer/658139129

作者:bravo1988 yangbili.co

 


她喜欢所以就做咯