架构师内功心法:设计模式(三)结构型模式(一)
写在前面:
- 你好,欢迎你的阅读!
- 我热爱技术,热爱分享,热爱生活, 我始终相信:技术是开源的,知识是共享的!
- 博客里面的内容大部分均为原创,是自己日常的学习记录和总结,便于自己在后面的时间里回顾,当然也是希望可以分享自己的知识。目前的内容几乎是基础知识和技术入门,如果你觉得还可以的话不妨关注一下,我们共同进步!
- 除了分享博客之外,也喜欢看书,写一点日常杂文和心情分享,如果你感兴趣,也可以关注关注!
- 微信公众号:傲骄鹿先生
结构型模式主要涉及如何组合各种对象以便获得更好、更灵活的结构。虽然面向对象的继承机制提供了最基本的子类扩展父类的功能,但结构型模式不仅仅简单地使用继承,而更多地通过组合与运行期的动态组合来实现更灵活的功能。
一、代理模式(Proxy Pattern):静态代理
1、介绍
-
定义:给目标对象提供一个代理对象,并由代理对象控制对目标对象的引用
-
主要作用:通过代理对象的方式间接访问目标对象
-
解决的问题:防止直接访问目标对象给系统带来不必要的麻烦
2、UML图及简单实现
接下来将通过一个简单的实例来实现:
我想买一台最新的顶配Mac电脑,但是国内还没有上只有美国才有,想找人进行代购。即代购(代理对象)代替我(真实对象)去是买Mac(间接访问操作)
(1)创建抽象对象接口( Subject ): 声明我(真实对象)需要让代购(代理对象)帮忙做的事(买Mac)
public interface Subject {
public void buyMac();
}
(2) 步骤2: 创建真实对象类(RealSubject),即”我“
public class RealSubject implement Subject{
@Override
public void buyMac() {
System.out.println(”买一台Mac“);
}
}
(3) 步骤3:创建代理对象类(Proxy),即”代购“,并通过代理类创建真实对象实例并访问其方法
public class Proxy implements Subject{
@Override
public void buyMac{
//引用并创建真实对象实例,即”我“
RealSubject realSubject = new RealSubject();
//调用真实对象的方法,进行代理购买Mac
realSubject.buyMac();
//代理对象额外做的操作
this.WrapMac();
}
public void WrapMac(){
System.out.println(”用盒子包装好Mac“);
}
}
(4) 步骤4:客户端调用
public class ProxyPattern {
public static void main(String[] args){
Subject proxy = new Proxy();
proxy.buyMac();
}
}
3、优缺点
(1)优点
-
协调调用者和被调用者,降低了系统的耦合度
-
代理对象作为客户端和目标对象之间的中介,起到了保护目标对象的作用
(2)缺点
-
由于在客户端和真实主题之间增加了代理对象,因此会造成请求的处理速度变慢;
-
实现代理模式需要额外的工作(有些代理模式的实现非常复杂),从而增加了系统实现的复杂度。
4、应用场景
一、代理模式(Proxy Pattern):动态代理
1、为什么要使用动态代理?
代理模式中的静态代理模式存在一些特点:
-
1个静态代理 只服务1种类型的目标对象
-
若要服务多类型的目标对象,则需要为每种目标对象都实现一个静态代理对象
在目标对象较多的情况下,若采用静态代理,则会出现 静态代理对象量多、代码量大,从而导致代码复杂的问题,因此可以使用动态代理来解决这个问题。
2、动态代理的实现
接下来还是通过一个实例来实现:
我想买一台最新的顶配Mac电脑,我朋友想买一台iPhone XS Max,但是国内还没有上只有美国才有,想找人进行代购。即代购(动态代理对象)同时代替我和朋友(目标对象)去买Mac、iPhone XS Max(间接访问操作)
(1)步骤一:声明调用处理器类
<-- 作用 -->
// 1、生成动态代理对象
// 2、指定代理对象运行目标对象方法时需要完成的具体任务
// 注:需实现InvocationHandler接口 = 调用处理器接口
// 所以称为调用处理器类
public class DynamicProxy implements InvocationHandler {
// 声明代理对象
// 作用:绑定关系,即关联到哪个接口(与具体的实现类绑定)的哪些方法将被调用时,执行invoke()
private Object ProxyObject;
public Object newProxyInstance(Object ProxyObject){
this.ProxyObject =ProxyObject;
// Proxy类 = 动态代理类的主类
// Proxy.newProxyInstance()作用:根据指定的类装载器、一组接口 & 调用处理器生成动态代理类实例,并最终返回
// 参数说明:
// 参数1:指定产生代理对象的类加载器,需要将其指定为和目标对象同一个类加载器
// 参数2:指定目标对象的实现接口
// 即要给目标对象提供一组什么接口。若提供了一组接口给它,那么该代理对象就默认实现了该接口,这样就能调用这组接口中的方法
// 参数3:指定InvocationHandler对象。即动态代理对象在调用方法时,会关联到哪个InvocationHandler对象
return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
ProxyObject.getClass().getInterfaces(),this);
}
// 复写InvocationHandler接口的invoke()
// 动态代理对象调用目标对象的任何方法前,都会调用调用处理器类的invoke()
@Override
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
// 参数说明:
// 参数1:动态代理对象(即哪个动态代理对象调用了method()
// 参数2:目标对象被调用的方法
// 参数3:指定被调用方法的参数
System.out.println("代购出门了");
Object result = null;
// 通过Java反射机制调用目标对象方法
result = method.invoke(ProxyObject, args);
return result;
}
}
(2)步骤二:声明目标对象类的抽象接口
public interface Subject {
// 定义目标对象的接口方法
// 代购物品
public void buybuybuy();
}
(3)步骤三:声明目标对象类、
// 我,真正的想买Mac的对象 = 目标对象 = 被代理的对象// 实现抽象目标对象的接口
public class Buyer1 implements Subject {
@Override
public void buybuybuy() {
System.out.println("我要买Mac");
}
}
// 朋友,真正的想买iPhone的对象 = 目标对象 = 被代理的对象// 实现抽象目标对象的接口
public class Buyer2 implements Subject {
@Override
public void buybuybuy() {
System.out.println("朋友要买iPhone");
}
}
(4)步骤四:通过动态代理对象,调用目标对象的方法
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 1. 创建调用处理器类对象
DynamicProxy DynamicProxy = new DynamicProxy();
// 2. 创建目标对象对象
Buyer1 mBuyer1 = new Buyer1();
// 3. 创建动态代理类 & 对象:通过调用处理器类对象newProxyInstance()
// 传入上述目标对象对象
Subject Buyer1_DynamicProxy = (Subject) DynamicProxy.newProxyInstance(mBuyer1);
// 4. 通过调用动态代理对象方法从而调用目标对象方法
// 实际上是调用了invoke(),再通过invoke()里的反射机制调用目标对象的方法
Buyer1_DynamicProxy.buybuybuy();
// 以上代购为我代购Mac
// 以下是代购为朋友代购iPhone
Buyer2 mBuyer2 = new Buyer2();
Subject Buyer2_DynamicProxy = (Subject) DynamicProxy.newProxyInstance(mBuyer2);
Buyer2_DynamicProxy.buybuybuy();
}
}
3、实现原理、优缺点
(1)实现原理
-
设计动态代理类(DynamicProxy)时,不需要显式实现与目标对象类(RealSubject)相同的接口,而是将这种实现推迟到程序运行时由 JVM来实现
-
即:在使用时再创建动态代理类 & 实例
-
静态代理则是在代理类实现时就指定与目标对象类(RealSubject)相同的接口
-
通过Java 反射机制的method.invoke(),通过调用动态代理类对象方法,从而自动调用目标对象的方法
(2)优点
-
只需要1个动态代理类就可以解决创建多个静态代理的问题,避免重复、多余代码
-
更强的灵活性
-
设计动态代理类(DynamicProxy)时,不需要显式实现与目标对象类(RealSubject)相同的接口,而是将这种实现推迟到程序运行时由 JVM来实现
-
在使用时(调用目标对象方法时)才会动态创建动态代理类 & 实例,不需要事先实例化
-
(3)缺点
-
效率低
相比静态代理中直接调用目标对象方法,动态代理则需要先通过Java反射机制 从而 间接调用目标对象方法
-
应用场景局限
因为 Java 的单继承特性(每个代理类都继承了 Proxy 类),即只能针对接口创建代理类,不能针对类创建代理类
4、应用场景、与静态代理的区别
(1)应用场景
-
基于静态代理应用场景下,需要代理对象数量较多的情况下使用动态代理
-
AOP 领域
-
定义:即 Aspect Oriented Programming = 面向切面编程,是OOP的延续、函数式编程的一种衍生范型
-
作用:通过预编译方式和运行期动态代理实现程序功能的统一维护。
-
优点:降低业务逻辑各部分之间的耦合度 、 提高程序的可重用性 & 提高了开发的效率
-
具体应用场景:日志记录、性能统计、安全控制、异常处理
-
(2)与静态代理的区别
五、源码分析
在步骤(4)中有两个值得重要的源码分析点:
a、创建动态代理类 & 对象:通过调用处理器类对象newProxyInstance()
b、通过调用动态代理对象方法从而调用目标对象方法
关注一:创建动态代理类 & 对象:通过调用处理器类对象newProxyInstance()
我们直接进入到DynamicProxy.newProxyInstance():
<-- 关注1:调用处理器 类的newProxyInstance() -->// 即步骤1中实现的类:DynamicProxy
// 作用:
// 1、生成动态代理对象
// 2、指定代理对象运行目标对象方法时需要完成的具体任务
// 注:需实现InvocationHandler接口 = 调用处理器 接口
public class DynamicProxy implements InvocationHandler {
// 声明代理对象
private Object ProxyObject;
public Object newProxyInstance(Object ProxyObject){
this.ProxyObject =ProxyObject;
return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
ProxyObject.getClass().getInterfaces(),this);
// Proxy.newProxyInstance()作用:根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类实例,并最终返回
// ->>关注2
}
// 以下暂时忽略,下文会详细介绍
// 复写InvocationHandler接口的invoke()
// 动态代理对象调用目标对象的任何方法前,都会调用调用处理器类的invoke()
@Override
public Object invoke(Object proxy, Method method, Object[] args)
// 参数1:动态代理对象(即哪个动态代理对象调用了method()
// 参数2:目标对象被调用的方法
// 参数3:指定被调用方法的参数
throws Throwable {
System.out.println("代购出门了");
Object result = null;
// 通过Java反射机制调用目标对象方法
result = method.invoke(ProxyObject, args);
return result;
}
// 至此,关注1分析完毕,跳出}
<-- 关注2:newProxyInstance()源码解析-->
// 作用:根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类及其对象实例,并最终返回
public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h) throws IllegalArgumentException {
// 参数说明:
// 参数1:指定产生代理对象的类加载器,需要将其指定为和目标对象同一个类加载器
// 参数2:指定目标对象的实现接口
// 即要给目标对象提供一组什么接口。若提供了一组接口给它,那么该代理对象就默认实现了该接口,这样就能调用这组接口中的方法
// 参数3:指定InvocationHandler对象。即动态代理对象在调用方法时,会关联到哪个InvocationHandler对象
...
// 仅贴出核心代码
// 1. 通过为Proxy类指定类加载器对象 & 一组interface,从而创建动态代理类
// >>关注3
Class cl = getProxyClass(loader, interfaces);
// 2. 通过反射机制获取动态代理类的构造函数,其参数类型是调用处理器接口类型
Constructor cons = cl.getConstructor(constructorParams);
// 3. 通过动态代理类的构造函数创建代理类实例(传入调用处理器对象)
return (Object) cons.newInstance(new Object[] { h });
// 特别注意
// 1. 动态代理类继承 Proxy 类 & 并实现了在Proxy.newProxyInstance()中提供的一系列接口(接口数组)// 2. Proxy 类中有一个映射表
// 映射关系为:(<ClassLoader>,(<Interfaces>,<ProxyClass>) )
// 即:1级key = 类加载器,根据1级key 得到 2级key = 接口数组
// 因此:1类加载器对象 + 1接口数组 = 确定了一个代理类实例...
// 回到调用关注2的原处
}
<-- 关注3:getProxyClass()源码分析 -->
// 作用:创建动态代理类
public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces) throws IllegalArgumentException {
...
// 仅贴出关键代码
<-- 1. 将目标类所实现的接口加载到内存中 -->
// 遍历目标类所实现的接口
for (int i = 0; i < interfaces.length; i++) {
// 获取目标类实现的接口名称
String interfaceName = interfaces[i].getName();
Class interfaceClass = null;
try {
// 加载目标类实现的接口到内存中
interfaceClass = Class.forName(interfaceName, false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != interfaces[i]) {
throw new IllegalArgumentException(
interfaces[i] + " is not visible from class loader");
}
}
<-- 2. 生成动态代理类 -->
// 根据传入的接口 & 代理对象 创建动态代理类的字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
// 根据动态代理类的字节码 生成 动态代理类
proxyClass = defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
}
// 最终返回动态代理类
return proxyClass;
}
// 回到调用关注3的原处
总结:
-
通过调用处理器类对象的.newProxyInstance()创建动态代理类 及其实例对象(需传入目标类对象)
-
具体过程如下:
-
通过 为Proy类指定类加载器对象 & 一组接口,从而创建动态代理类的字节码;再根据类字节码创建动态代理类
-
通过反射机制获取动态代理类的构造函数(参数类型 = 调用处理器接口类型)
-
通过动态代理类的构造函数 创建 代理类实例(传入调用处理器对象)
-
关注二:通过调用动态代理对象方法从而调用目标对象方法
在关注1中的 DynamicProxy.newProxyInstance()生成了一个动态代理类及其实例,该动态代理类记为 :$Proxy0
下面我们直接看该类实现及其 buybuybuy():
<-- 动态代理类 $Proxy0 实现-->
// 继承:Java 动态代理机制的主类:java.lang.reflect.Proxy
// 实现:与目标对象一样的接口(即上文例子的Subject接口)
public final class $Proxy0 extends Proxy implements Subject {
// 构造函数
public ProxySubject(InvocationHandler invocationhandler){
super(invocationhandler);
}
// buybuybuy()是目标对象实现接口(Subject)中的方法
// 即$Proxy0类必须实现
// 所以在使用动态代理类对象时,才可以调用目标对象的同名方法(即上文的buybuybuy())
public final void buybuybuy(){
try {
super.h.invoke(this, m3, null);
// 该方法的逻辑实际上是调用了父类Proxy类的h参数的invoke()
// h参数即在Proxy.newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h)传入的第3个参数InvocationHandler对象
// 即调用了调用处理器的InvocationHandler.invoke()
// 而复写的invoke()利用反射机制:Object result=method.invoke(proxied,args)
// 从而调用目标对象的的方法 ->>关注4
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
<-- 关注4:调用处理器 类复写的invoke() -->
// 即步骤1中实现的类:DynamicProxy
// 内容很多都分析过了,直接跳到复写的invoke()中
public class DynamicProxy implements InvocationHandler {
private Object ProxyObject;
public Object newProxyInstance(Object ProxyObject){
this.ProxyObject =ProxyObject;
return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
ProxyObject.getClass().getInterfaces(),this);
}
// 复写InvocationHandler接口的invoke()
// 动态代理对象调用目标对象的任何方法前,都会调用调用处理器类的invoke()
@Override
public Object invoke(Object proxy, Method method, Object[] args)
// 参数说明:
// 参数1:动态代理对象(即哪个动态代理对象调用了method()
// 参数2:目标对象被调用的方法
// 参数3:指定被调用方法的参数
throws Throwable {
System.out.println("代购出门了");
Object result = null;
// 通过Java反射机制调用目标对象方法
result = method.invoke(ProxyObject, args);
return result;
}
}
总结:
-
动态代理类实现了与目标类一样的接口,并实现了需要目标类对象需要调用的方法
-
该方法的实现逻辑 = 调用父类 Proxy类的 h.invoke()
其中h参数 = 在创建动态代理实例中newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h)传入的第3个参数InvocationHandler对象
-
在 InvocationHandler.invoke() 中通过反射机制,从而调用目标类对象的方法
6、总结