概述
由于某些原因我们不能直接访问“目标”对象,需要通过“代理”对象来访问目标对象。代理对象此时就充当了一个“中介”的角色。
举个例子:书店与出版社,二者是代理与被代理的关系。
- 书店可以卖书,卖书同时还可以搞优惠,打折送优惠券。
- 出版社只能卖书,且委托书店代理。
代理模式中的角色
- 抽象主题类 subject:一般为接口或者抽象类。内部定义了真实主题与代理类所需实现的业务。
- 真实主题类 RealSubject:实现了抽象主题定义的具体业务,是代理对象所代表的真实类。
- 代理类Proxy :提供了与真实主题相同的接口,其内部含有对真实主题的引用,可以访问、控制、扩展真实主题的功能。
因此代理的大致实现如下:
1、创建接口(被代理类的功能抽象出来的)
2、代理类与被代理类实现同一接口(是不是想起了装饰者模式,静态代理与装饰者就是像)
3、代理类中进行功能代理,在代理这个功能前后还可以做些代理类特有的工作
代理分类
Java中的代理按照代理类生成的时机可分为静态代理和动态代理。静态代理的代理类在代码编译期间就生成了,而动态代理则是在代码运行期间生成,存在于内存中。
动态代理又分jdk动态代理和CGLIB动态代理。前者为jdk提供的api后者是一个三方库。
静态代理
先拿书店与出版社的栗子演练下静态代理~
1、创建接口
书店与出版社共同的目标都是把书卖出去,我们抽象业务,抽取个卖书的接口。
/**
* Create by SunnyDay on 2019/04/14
*/
public interface Subject {
void sailBook();
}
2、代理类与被代理类实现同一接口
被代理类:
/**
* Create by SunnyDay on 2019/04/14
* 出版社,真实主题,被代理的类。
*/
public class Press implements Subject {
@Override
public void sailBook() {
System.out.println("卖书ing");
}
}
代理类:
/**
* Create by SunnyDay on 2019/04/14
* 代理类
*/
public class ProxySubject implements Subject {
private Subject subject; // 注意引用的赋值在class内部(对比装饰者思考)
public ProxySubject() {
}
/**
* 代理卖书功能,自己还做点功能。
*/
@Override
public void sailBook() {
subject = new Press();
discount();
subject.sailBook();
give();
}
/**
* 打折
* */
private void discount() {
System.out.println("打折券一张");
}
/**
* 赠品
* */
private void give() {
System.out.println("买书赠品一个");
}
}
3、测试类
public class Test {
public static void main(String[] args) {
// 代理商卖书(客户直接与代理商沟通了,不与出版社沟通)
ProxySubject proxySubject = new ProxySubject();
proxySubject.sailBook();
}
}
log:
打折券一张
卖书ing
买书赠品一个
可见ProxySubject就是代理商,Test类可以当做客户,客户直接与代理商进行沟通。
4、UML类图
通过类图看这几个角色关系就一目了然了。核心就在代理类中,代理类持有被代理类press的引用,这样就可操作press的sailBook方法了,并且可在操作press#sailBook的前后做其他的事情。
动态代理
动态代理的书写步骤不像我们前面总结的那几步那么死板,前面那个书写步骤书写上更适合静态代理。
为啥是这样呢?因为动态代理的代理类的字节码是在程序运行期间由JVM根据反射等机制动态的生成的,代理类和被代理类的关系是在程序运行时确定。所以不存在代理类的java源文件。
相对静态代理来说,写法上虽看着奇怪,但代理的核心步骤思想是不变的“代理类持有被代理类引用,对被代理类进行代理” 这点后续我们分析代码可留意下。
1、jdk动态代理-代码实现
好了先直接上代码,跑起来再说,新建Handler类:
/**
* Create by SunnyDay on 2019/04/14
* 工具类:需要实现JDK#InvocationHandler接口
*/
public class PressProxyHandler implements InvocationHandler {
private Subject subject;
public PressProxyHandler() {}
/**
* @param proxy 代理对象,一般我们这里不用。
* @param method 目标对象业务方法的封装。 被代理对象的哪个方法被代理,这里就是对应的方法对象封装。
* @param args 目标对象业务方法的方法参数。
* @return 方法返回值
* ps: 最好了解点反射的知识点。
* */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
subject = new Press();
Object result;
discount();
result = method.invoke(subject);//执行被代理的方法。这里需要个被代理对象。
give();
return result;
}
private void discount() {
System.out.println("今天的书八折");
}
private void give() {
System.out.println("买书送圆珠笔一支");
}
/**
* 获取代理对象
* */
public Subject getPressProxy(){
return (Subject) Proxy.newProxyInstance(Press.class.getClassLoader(),
Press.class.getInterfaces(),
this);
}
}
测试代码:
public class Test {
public static void main(String[] args) {
// 客户从代理商那卖书
PressProxyHandler handler = new PressProxyHandler();
Subject press = handler.getPressProxy(); // 代理类代码期间动态生成
press.sailBook();
}
}
log:
今天的书八折
卖书ing
买书送圆珠笔一支
2、jdk动态代理-重要方法分析
想要初步理解上述的写法我们最好提前了解下java的反射、jvm的类加载机制。
好了言归正传 上述代码中有两个方法需要说明下
- InvocationHandler#invoke
- Proxy#newProxyInstance
(1)Proxy#newProxyInstance
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)throws IllegalArgumentException
ClassLoader loader: 类加载器,用于加载生成的代理类。 这里类加载器可通过被代理类来获取。
(需要了解一些类加载的知识)
Class<?>[] interfaces: 代理类实现的接口字节码对象。由于目标类与代理类都实现了同接口(可能多个相同的),
因此也可通过目标类来获取。
InvocationHandler h: 代理对象的调用处理程序。内部核心有个回调方法,代理类调用代理方法时,这个回调方法就会
被执行.
(2)InvocationHandler#invoke
/**
* @param proxy 代理对象,一般我们这里不用。
*
* @param method 目标对象业务方法的封装。 被代理对象的哪个方法被代理,这里就是对应的方法对象封装。
*
* @param args 目标对象业务方法的方法参数。
*
* @return 方法返回值
*
* ps: 最好了解点反射的知识点。
* */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
3、jdk 动态代理-代理类查看
注意上述的InvocationHandler并不是代理类,真正的代理类是在程序运行期间动态生成的,存在运行期。那么我们如何看到呢?这里需要借助一个阿里的jar包工具:arthas
(1)保持程序运行
public class Test {
public static void main(String[] args) {
PressProxyHandler handler = new PressProxyHandler();
Subject press = handler.getPressProxy();
press.sailBook();
System.out.println("代理类:"+press.getClass());
while (true){}
}
}
log
代理类:class com.sun.proxy.$Proxy0
程序一直运行,则代理类一直存在。
(2) 运行arthas-boot.jar 包
通过终端进入arthas-boot.jar所在目录,然后执行jar 命令执行jar包,执行jad命令获取代码:
public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public final void sailBook() {
try {
this.h.invoke(this, m3, null);
return;
}
catch (Error | RuntimeException throwable) {
throw throwable;
}
catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public $Proxy0(InvocationHandler invocationHandler) {
super(invocationHandler);
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("pattern_proxy.static_proxy.Subject").getMethod("sailBook", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
return;
}
catch (NoSuchMethodException noSuchMethodException) {
throw new NoSuchMethodError(noSuchMethodException.getMessage());
}
catch (ClassNotFoundException classNotFoundException) {
throw new NoClassDefFoundError(classNotFoundException.getMessage());
}
}
public final boolean equals(Object object) {
try {
return (Boolean)this.h.invoke(this, m1, new Object[]{object});
}
catch (Error | RuntimeException throwable) {
throw throwable;
}
catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final String toString() {
try {
return (String)this.h.invoke(this, m2, null);
}
catch (Error | RuntimeException throwable) {
throw throwable;
}
catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final int hashCode() {
try {
return (Integer)this.h.invoke(this, m0, null);
}
catch (Error | RuntimeException throwable) {
throw throwable;
}
catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
}
(3)简化代码&分析代码流程
正真的代理类终于被看到了,但是看着不利于代码的分析,我们可以简化下,去除些无关的代码:
- hashCode 去除
- toString 去除
- equals 去除
- try catch块去除
public final class $Proxy0 extends Proxy implements Subject {
private static Method m3;
static {
m3 = Class.forName("pattern_proxy.static_proxy.Subject").getMethod("sailBook", new Class[0]);
}
public $Proxy0(InvocationHandler invocationHandler) {
super(invocationHandler);
}
public final void sailBook() {
this.h.invoke(this, m3, null);
}
}
// 父类Proxy有个核心成员,为了方便直接也一并摘来观看:
public class Proxy implements java.io.Serializable {
...
// protected 类型的成员InvocationHandler类。
protected InvocationHandler h;
...
}
这个代理类很简单:
1、继承了系统api Proxy类,实现了我们定义的接口。(到这是否可回忆起步骤:代理类与被代理类实现统一接口)
2、通过反射获取接口的方法对象
3、$Proxy0 对象创建时,需要外部提供个InvocationHandler实现类对象。4、代理类$Proxy0 实现接口方法。(到这是否回忆起步骤:对被代理类进行代理)
注意,代理类的具体实现是委托给InvocationHandler#invoke方法来实现的。这里是具体的代理细节。
好了代理类剖析个差不多了接下来结合Test类分析一波:
4、cglib动态代理
通过上面的栗子可以知道jdk动态代理只能对 实现接口的类提供代理,而CGLIB是一个功能强大,高性能的代码生成包。它为没有实现接口的类提供代理,为JDK的动态代理提供了很好的补充。
通常可以使用Java的动态代理创建代理,但当要代理的类没有实现接口或者为了更好的性能,CGLIB是一个好的选择。
(1)目标类
/**
* Create by SunnyDay 2022/10/24 21:58:47
**/
public class NovelPress {
public void sailBook() {
System.out.println("小说出版社卖书");
}
}
(2) 代理帮助类
/**
* Create by SunnyDay 2022/10/24 22:04:50
* 工具类
**/
public class ProxyHelper {
private NovelPress mNovelPress;
public ProxyHelper() {}
/**
* 获取 NovelPress 类的代理类对象。
* 为啥返回值是NovelPress类型?因为cglib中代理类是目标类的子类。(就是这样设计的,就如jdk的动态代理只能对接口实现类进行代理一样)
*/
public NovelPress getNovelProxyObject() {
mNovelPress = new NovelPress();
Enhancer enhancer = new Enhancer(); // cglib 使用这个类
enhancer.setSuperclass(NovelPress.class);
enhancer.setCallback(new MethodInterceptor() {
/**
* 通过代理类调用代理方法时,这个函数就会被回调。
* @param o 目标对象
* @param method 目标方法对象
* @param objects 目标方法参数
* */
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("今天小说8折");
mNovelPress.sailBook();
System.out.println("买小说送圆珠笔一只");
return null;
}
});
return (NovelPress) enhancer.create();
}
}
(3)测试
public class Test {
public static void main(String[] args) {
// test cglib
NovelPress novelPressProxyObject = new ProxyHelper().getNovelProxyObject();
novelPressProxyObject.sailBook();
}
}
log:
今天小说8折
小说出版社卖书
买小说送圆珠笔一只
小结
1、三种对比
-
jdk与cglib
cglib底层采用的ASM字节码生成框架,cglib不能为目标类的final方法进行代理,因为cglib生成的代理类是目标类的子类。jdk底层是反射,会消耗一些性能,jdk动态代理只能对接口进行代理,因为jdk生成的代理类继承了Proxy,java不支持多继承。
二者效率对比上就不说了,因为jdk不同版本有过针对性优化我们只需遵循对接口就用JDK动态代理,无接口就用CGLIB动态代理
-
动态代理与静态代理
动态代理与静态代理相比最大的好处所有的接口方法都被放在InvocationHandler#invoke方法中处理。
试想假如接口中有多个方法需要被代理时,我们需要再静态代理类的每个实现方法中写代理代码。
接口增加新方法,不仅目标类要实现此方法,所有的静态代理类也要实现此方法,增加了代码维护复杂度。
2、代理优点
- 可保护目标对象
- 可拓展目标对象
- 一定程度上降低系统耦合(将客户端与目标对象分离)
3、代理缺点
- 增加系统负责度(特别是动态代理实现麻烦,不易理解)
4、使用场景
- 远程代理:可实现远程调用RPC思想。本地服务与远程服务都实现网络通信接口
- 防火墙代理
- 保护代理:控制对象访问。