说说 JAVA 代理模式
事例
小张是一个普普通通的码农,每天勤勤恳恳地码代码。某天中午小张刚要去吃饭,一个电话打到了他的手机上。“是XX公司的小张吗?我是YY公司的王AA”。“哦,是王总啊,有什么事情吗?”。沟通过后,小张弄明白了,原来客户有个需求,刚好负责这方面开发的是小张,客户就直接找到了他。不过小张却没有答应客户的请求,而是让客户找产品经理小李沟通。
是小张着急去吃面而甩锅吗?并不是,只是为了使故事可以套到代理模式上。我们先看一下代理模式的定义: * 为其他对象提供一种代理,以控制对这个对象的访问。(Provide a surrogate or placeholder for another object to control access to it)
对照定义,码农小张可以映射为其他对象,产品经理小李为小张的代理。我们通过JAVA代码,表述上面事例。
静态代理
1.抽象角色
基于面向对象的思想,首先定义一个码农接口,它有一个实现用户需求的方法。
1
2
3
4
5
|
public interface ICoder {
public void implDemands(String demandName);
}
|
2.真实角色
我们假设小张是JAVA程序员,定义一个JAVA码农类,他通过JAA语言实现需求。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class JavaCoder implements ICoder{
private String name;
public JavaCoder(String name){
this .name = name;
}
@Override
public void implDemands(String demandName) {
System.out.println(name + " implemented demand:" + demandName + " in JAVA!" );
}
}
|
3.代理角色
委屈一下产品经理,将其命名为码农代理类,同时让他实现ICoder接口。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class CoderProxy implements ICoder{
private ICoder coder;
public CoderProxy(ICoder coder){
this .coder = coder;
}
@Override
public void implDemands(String demandName) {
coder.implDemands(demandName);
}
}
|
上面一个接口,两个类,就实现了代理模式。Are you kidding me?这么简单?是的,就是这么简单。 我们通过一个场景类,模拟用户找产品经理增加需求。
1
2
3
4
5
6
7
8
9
10
11
|
public class Customer {
public static void main(String args[]){
//定义一个java码农
ICoder coder = new JavaCoder( "Zhang" );
//定义一个产品经理
ICoder proxy = new CoderProxy(coder);
//让产品经理实现一个需求
proxy.implDemands();
}
}
|
运行程序,结果如下:
1
|
Zhang implemented demand:Add user manageMent in JAVA!
|
产品经理充当了程序员的代理,客户把需求告诉产品经理,并不需要和程序员接触。看到这里,有些机智的程序员发现了问题。你看,产品经理就把客户的需求转达了一下,怪不得我看产品经理这么不爽。
产品经理当然不只是转达用户需求,他还有很多事情可以做。比如,该项目决定不接受新增功能的需求了,对修CoderProxy类做一些修改:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class CoderProxy implements ICoder{
private ICoder coder;
public CoderProxy(ICoder coder){
this .coder = coder;
}
@Override
public void implDemands(String demandName) {
if (demandName.startsWith( "Add" )){
System.out.println( "No longer receive 'Add' demand" );
return ;
}
coder.implDemands(demandName);
}
}
|
这样,当客户再有增加功能的需求时,产品经理就直接回绝了,程序员无需再对这部分需求做过滤。
总结
我们对上面的事例做一个简单的抽象:
代理模式包含如下角色:
- Subject:抽象主题角色。可以是接口,也可以是抽象类。
- RealSubject:真实主题角色。业务逻辑的具体执行者。
- ProxySubject:代理主题角色。内部含有RealSubject的引用,负责对真实角色的调用,并在真实主题角色处理前后做预处理和善后工作。
代理模式优点:
- 职责清晰 真实角色只需关注业务逻辑的实现,非业务逻辑部分,后期通过代理类完成即可。
- 高扩展性 不管真实角色如何变化,由于接口是固定的,代理类无需做任何改动。
动态代理
前面讲的主要是静态代理。那么什么是动态代理呢?
假设有这么一个需求,在方法执行前和执行完成后,打印系统时间。这很简单嘛,非业务逻辑,只要在代理类调用真实角色的方法前、后输出时间就可以了。像上例,只有一个implDemands方法,这样实现没有问题。但如果真实角色有10个方法,那么我们要写10遍完全相同的代码。有点追求的码农,肯定会对这种方法感到非常不爽。有些机智的小伙伴可能想到了用AOP解决这个问题。非常正确。莫非AOP和动态代理有什么关系?没错!AOP用的恰恰是动态代理。
代理类在程序运行时创建的代理方式被称为动态代理。也就是说,代理类并不需要在Java代码中定义,而是在运行时动态生成的。相比于静态代理, 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理,而不用修改每个代理类的函数。对于上例打印时间的需求,通过使用动态代理,我们可以做一个“统一指示”,对所有代理类的方法进行统一处理,而不用逐一修改每个方法。下面我们来具体介绍下如何使用动态代理方式实现我们的需求。
与静态代理相比,抽象角色、真实角色都没有变化。变化的只有代理类。因此,抽象角色、真实角色,参考ICoder和JavaCodr。
在使用动态代理时,我们需要定义一个位于代理类与委托类之间的中介类,也叫动态代理类,这个类被要求实现InvocationHandler接口:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class CoderDynamicProxy implements InvocationHandler{
//被代理的实例
private ICoder coder;
public CoderDynamicProxy(ICoder _coder){
this .coder = _coder;
}
//调用被代理的方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(System.currentTimeMillis());
Object result = method.invoke(coder, args);
System.out.println(System.currentTimeMillis());
return result;
}
}
|
当我们调用代理类对象的方法时,这个“调用”会转送到中介类的invoke方法中,参数method标识了我们具体调用的是代理类的哪个方法,args为这个方法的参数。
我们通过一个场景类,模拟用户找产品经理更改需求。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class DynamicClient {
public static void main(String args[]){
//要代理的真实对象
ICoder coder = new JavaCoder( "Zhang" );
//创建中介类实例
InvocationHandler handler = new CoderDynamicProxy(coder);
//获取类加载器
ClassLoader cl = coder.getClass().getClassLoader();
//动态产生一个代理类
ICoder proxy = (ICoder) Proxy.newProxyInstance(cl, coder.getClass().getInterfaces(), handler);
//通过代理类,执行doSomething方法;
proxy.implDemands( "Modify user management" );
}
}
|
执行结果如下:
1
2
3
|
1501728574978
Zhang implemented demand:Modify user management in JAVA!
1501728574979
|
通过上述代码,就实现了,在执行委托类的所有方法前、后打印时间。还是那个熟悉的小张,但我们并没有创建代理类,也没有时间ICoder接口。这就是动态代理。
总结
总结一下,一个典型的动态代理可分为以下四个步骤:
- 创建抽象角色
- 创建真实角色
- 通过实现InvocationHandler接口创建中介类
- 通过场景类,动态生成代理类
如果只是想用动态代理,看到这里就够了。但如果想知道为什么通过proxy对象,就能够执行中介类的invoke方法,以及生成的proxy对象是什么样的,可以继续往下看。
源码分析(JDK7)
看到这里的小伙伴,都是有追求的程序员。上面的场景类中,通过
1
2
|
//动态产生一个代理类
ICoder proxy = (ICoder) Proxy.newProxyInstance(cl, coder.getClass().getInterfaces(), handler);
|
动态产生了一个代理类。那么这个代理类是如何产生的呢?我们通过代码一窥究竟。
Proxy类的newProxyInstance方法,主要业务逻辑如下:
1
2
3
4
5
6
|
//生成代理类class,并加载到jvm中
Class<?> cl = getProxyClass0(loader, interfaces);
//获取代理类参数为InvocationHandler的构造函数
final Constructor<?> cons = cl.getConstructor(constructorParams);
//生成代理类,并返回
return newInstance(cons, ih);
|
上面代码做了三件事:
- 根据传入的参数interfaces动态生成一个类,它实现interfaces中的接口,该例中即ICoder接口的implDemands方法。假设动态生成的类为$Proxy0。
- 通过传入的classloder,将刚生成的$Proxy0类加载到jvm中。
- 利用中介类,调用$Proxy0的$Proxy0(InvocationHandler)构造函数,创建$Proxy0类的实例,其InvocationHandler属性,为我们创建的中介类。
上面的核心,就在于getProxyClass0方法:
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);
}
|
在Proxy类中有个属性proxyClassCache,这是一个WeakCache类型的静态变量。它指示了类加载器和代理类之间的映射。所以proxyClassCache的get方法用于根据类加载器来获取Proxy类,如果已经存在则直接从cache中返回,如果没有则创建一个映射并更新cache表。
我们跟一下代理类的创建流程:
调用Factory类的get方法,而它又调用了ProxyClassFactory类的apply方法,最终找到下面一行代码:
1
2
|
//Generate the specified proxy class.
byte [] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
|
就是它,生成了代理类。
查看动态生成的代理类
通过上面的分析,我们已经知道Proxy类动态创建代理类的流程。那创建出来的代理类到底是什么样子的呢?我们可以通过下面的代码,手动生成:
1
2
3
4
5
6
7
8
9
10
11
|
public class CodeUtil {
public static void main(String[] args) throws IOException {
byte [] classFile = ProxyGenerator.generateProxyClass( "TestProxyGen" , JavaCoder. class .getInterfaces());
File file = new File( "D:/aaa/TestProxyGen.class" );
FileOutputStream fos = new FileOutputStream(file);
fos.write(classFile);
fos.flush();
fos.close();
}
}
|
通过反编译工具查看生成的class文件:
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import model.proxy.ICoder;
public final class TestProxyGen extends Proxy
implements ICoder
{
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;
public TestProxyGen(InvocationHandler paramInvocationHandler)
throws
{
super (paramInvocationHandler);
}
public final boolean equals(Object paramObject)
throws
{
try
{
return ((Boolean) this .h.invoke( this , m1, new Object[] { paramObject })).booleanValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final int hashCode()
throws
{
try
{
return ((Integer) this .h.invoke( this , m0, null )).intValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final void implDemands(String paramString)
throws
{
try
{
this .h.invoke( this , m3, new Object[] { paramString });
return ;
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final String toString()
throws
{
try
{
return (String) this .h.invoke( this , m2, null );
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
static
{
try
{
m1 = Class.forName( "java.lang.Object" ).getMethod( "equals" , new Class[] { Class.forName( "java.lang.Object" ) });
m0 = Class.forName( "java.lang.Object" ).getMethod( "hashCode" , new Class[ 0 ]);
m3 = Class.forName( "model.proxy.ICoder" ).getMethod( "implDemands" , new Class[] { Class.forName( "java.lang.String" ) });
m2 = Class.forName( "java.lang.Object" ).getMethod( "toString" , new Class[ 0 ]);
return ;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
}
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
|
这样,我们就理解,为什么调用代理类的implDemands方法,回去执行中介类的invoke方法了。
from: http://www.importnew.com/26116.html
说说 JAVA 代理模式相关推荐
- java代理模式_Java代理
java代理模式 本文是我们名为" 高级Java "的学院课程的一部分. 本课程旨在帮助您最有效地使用Java. 它讨论了高级主题,包括对象创建,并发,序列化,反射等. 它将指导您 ...
- java代理模式(java代理模式和适配器模式)
Java设计模式的中介者模式是怎样的? 如果对象之间的关系原本一目了然,中介对象的加入便是"画蛇添足". 来看下中介者模式的组成部分吧. 1) 抽象中介者(Mediator)角色: ...
- java代理模式总结
Java代理模式根据代理类生成时间的不同,可以分为静态代理和动态代理,它如同中介机构,可以为目标类提供代理服务,以控制对对象的访问,目标类的任何方法在执行前都必须经过代理类,这样代理类就可以用来负责请 ...
- java代理模式实现
java代理模式实现 @(代理模式)[静态代理,动态代理,InvocationHandler] java的代理模式 分为两种,静态代理和动态代理,学习下什么是代理和静态动态代理的作用. java代理模 ...
- [Java] 代理模式 Proxy Mode
[Java] 代理模式 Proxy Mode 文章目录 [Java] 代理模式 Proxy Mode 1. 代理思想 2.java.lang.reflect.Proxy类 2.1 利用反射创建prox ...
- 浅谈自己对Java代理模式的理解--即为什么要用怎么用
首先,国际惯例,上Java代理模式的定义: Java代理模式:对其他对象提供一种代理以控制对这个对象的访问. 定义很简单,就一句话,怎么去理解,不急,先听一个小故事: 故事 ...
- 阿里十年资深程序员吐血总结之Java代理模式
阿里十年资深程序员吐血总结之Java代理模式 文章目录 阿里十年资深程序员吐血总结之Java代理模式 1.接口代理 2.类代理 3.动态代理都是通过反射实现的吗 4.jdk动态代理和cglib动态代理 ...
- Java代理模式汇编
文章目录 Java 代理模式实现方式,主流如下五种方法 Notes 静态代理实现 实现步骤 Cat接口 委托类 Lion 代理类角色(FeederProxy) 静态代理类测试 动态代理类(基于接口实现 ...
- Java代理模式/静态代理/动态代理
代理模式:即Proxy Pattern,常用的设计模式之一.代理模式的主要作用是为其他对象提供一种代理以控制对这个对象的访问. 代理概念 :为某个对象提供一个代理,以控制对这个对象的访问. 代理类和委 ...
最新文章
- python 数据库的Connection、Cursor两大对象
- 【MDCC技术大咖秀】Android内存优化之OOM
- python项目部署到docker_使用docker 部署python 项目
- ---------很简单的 一道 堆栈问题-------
- JavaScript-操作DOM对象-获得dom节点
- Linux的iptables常用配置范例(2)
- android自定义view流程,Android 自定义View--从源码理解View的绘制流程
- vsftpd创建虚拟用户,解决本地用户不安全问题,增强服务器安全性
- 超边际分析不能用计算机,一种基于超边际分析的分布式计算资源分配方法-Journalof.PDF...
- 【UOJ#310】【UNR#2】黎明前的巧克力(FWT)
- 蚂蚁金服“定损宝”现身AI顶级会议NeurIPS
- hbuilder 夜神模拟器 谷歌 联调
- 什么是OSINT?以及如何使用开源网络情报工具?
- Java内存马-Instrument
- 树莓派Pico开发板的C/C++开发环境搭建(VSCode+PlatformIO)
- Python作画玫瑰花
- 关于在校大学生的Edu教育邮箱能够薅到的羊毛
- Altium Designer学习总结(不定时更新)
- 又来了!10分钟实现微信 “炸屎“大作战
- 周鸿祎产品秘笈:小版本成就大产品
热门文章
- nginx 学习笔记(9) 配置HTTPS服务器--转载
- MVP介绍以及优化封装
- 【ETL】ETL----如何决定是否采用ETL工具
- CML 2020 | 显式引入对分类标签的描述,如何提高文本分类的效果?
- shujufenxi : baichi xiangzhuanqian
- Visual Studio 2013开发 mini-filter driver step by step (2) - 编译,部署,运行
- Quartz-SimpleTrigger解读
- Oracle-多表连接的三种方式解读
- android后台获取view,android – 如何获取当前显示在AdapterView中的项目?
- 【使用递归玩通关汉诺塔游戏】算法01-递归(斐波那契数列、汉罗塔问题)-java实现