请选择 进入手机版 | 继续访问电脑版
 找回密码
 立即注册

QQ登录

只需要一步,快速开始

搜索
开启左侧

Java代理设计模式(Proxy)的四种具体实现:静态代理和动态代理

马上注册,分享更多源码,享用更多功能,让你轻松玩转云大陆。

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
面试问题:Java里的代理设计模式(Proxy Design Pattern)一共有几种实现方式?这个题目很像孔乙己问“茴香豆的茴字有哪几种写法?”
161533edy214fu18db8uyd.jpg


所谓代理模式,是指客户端(Client)并不直接调用实际的对象(下图右下角的RealSubject),而是通过调用代理(Proxy),来间接的调用实际的对象。
代理模式的使用场合,一般是由于客户端不想直接访问实际对象,或者访问实际的对象存在技术上的障碍,因而通过代理对象作为桥梁,来完成间接访问。
161533vssz2gpf0hpyf9z9.jpg


实现方式一:静态代理

开发一个接口IDeveloper,该接口包含一个方法writeCode,写代码。
public interface IDeveloper {
public void writeCode();
}
创建一个Developer类,实现该接口。
public class Developer implements IDeveloper{
tprivate String name;
tpublic Developer(String name){
ttthis.name = name;
t}
t@Override
tpublic void writeCode() {
ttSystem.out.println("Developer " + name + " writes code");
t}
}
测试代码:创建一个Developer实例,名叫Jerry,去写代码!
public class DeveloperTest {
tpublic static void main(String[] args) {
ttIDeveloper jerry = new Developer("Jerry");
ttjerry.writeCode();
t}
}
现在问题来了。Jerry的项目经理对Jerry光写代码,而不维护任何的文档很不满。假设哪天Jerry休假去了,其他的程序员来接替Jerry的工作,对着陌生的代码一脸问号。经全组讨论决定,每个开发人员写代码时,必须同步更新文档。
为了强迫每个程序员在开发时记着写文档,而又不影响大家写代码这个动作本身, 我们不修改原来的Developer类,而是创建了一个新的类,同样实现IDeveloper接口。这个新类DeveloperProxy内部维护了一个成员变量,指向原始的IDeveloper实例:
public class DeveloperProxy implements IDeveloper{
tprivate IDeveloper developer;
tpublic DeveloperProxy(IDeveloper developer){
ttthis.developer = developer;
t}
t@Override
tpublic void writeCode() {
ttSystem.out.println("Write documentation...");
ttthis.developer.writeCode();
t}
}
这个代理类实现的writeCode方法里,在调用实际程序员writeCode方法之前,加上一个写文档的调用,这样就确保了程序员写代码时都伴随着文档更新。
测试代码:
161533dd8srsg8mv59cn1x.jpg


静态代理方式的优点

1. 易于理解和实现
2. 代理类和真实类的关系是编译期静态决定的,和下文马上要介绍的动态代理比较起来,执行时没有任何额外开销。
静态代理方式的缺点

每一个真实类都需要一个创建新的代理类。还是以上述文档更新为例,假设老板对测试工程师也提出了新的要求,让测试工程师每次测出bug时,也要及时更新对应的测试文档。那么采用静态代理的方式,测试工程师的实现类ITester也得创建一个对应的ITesterProxy类。
public interface ITester {
tpublic void doTesting();
}
Original tester implementation class:
public class Tester implements ITester {
tprivate String name;
tpublic Tester(String name){
ttthis.name = name;
t}
t@Override
tpublic void doTesting() {
ttSystem.out.println("Tester " + name + " is testing code");
t}
}
public class TesterProxy implements ITester{
tprivate ITester tester;
tpublic TesterProxy(ITester tester){
ttthis.tester = tester;
t}
t@Override
tpublic void doTesting() {
ttSystem.out.println("Tester is preparing test documentation...");
tttester.doTesting();
t}
}
正是因为有了静态代码方式的这个缺点,才诞生了Java的动态代理实现方式。
Java动态代理实现方式一:InvocationHandler

InvocationHandler的原理我曾经专门写文章介绍过:Java动态代理之InvocationHandler最简单的入门教程
通过InvocationHandler, 我可以用一个EnginnerProxy代理类来同时代理Developer和Tester的行为。
public class EnginnerProxy implements InvocationHandler {
tObject obj;
tpublic Object bind(Object obj)
t{
ttthis.obj = obj;
ttreturn Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
tt.getClass().getInterfaces(), this);
t}
t@Override
tpublic Object invoke(Object proxy, Method method, Object[] args)
tthrows Throwable
t{
ttSystem.out.println("Enginner writes document");
ttObject res = method.invoke(obj, args);
ttreturn res;
t}
}
真实类的writeCode和doTesting方法在动态代理类里通过反射的方式进行执行。
测试输出:
161533s32zxex9xe9xb1t3.jpg


通过InvocationHandler实现动态代理的局限性
假设有个产品经理类(ProductOwner) 没有实现任何接口。
public class ProductOwner {
tprivate String name;
tpublic ProductOwner(String name){
ttthis.name = name;
t}
tpublic void defineBackLog(){
ttSystem.out.println("PO: " + name + " defines Backlog.");
t}
}
我们依然采取EnginnerProxy代理类去代理它,编译时不会出错。运行时会发生什么事?
ProductOwner po = new ProductOwner("Ross");
ProductOwner poProxy = (ProductOwner) new EnginnerProxy().bind(po);
poProxy.defineBackLog();
运行时报错。所以局限性就是:假如被代理的类未实现任何接口,那么不能采用通过InvocationHandler动态代理的方式去代理它的行为。
161534n6lxkkfiis9iy9lf.jpg


Java动态代理实现方式二:CGLIB

CGLIB是一个Java字节码生成库,提供了易用的API对Java字节码进行创建和修改。关于这个开源库的更多细节,请移步至CGLIB在github上的仓库:https://github.com/cglib/cglib
我们现在尝试用CGLIB来代理之前采用InvocationHandler没有成功代理的ProductOwner类(该类未实现任何接口)。
现在我改为使用CGLIB API来创建代理类:
public class EnginnerCGLibProxy {
tObject obj;
tpublic Object bind(final Object target)
t{
ttthis.obj = target;
ttEnhancer enhancer = new Enhancer();
ttenhancer.setSuperclass(obj.getClass());
ttenhancer.setCallback(new MethodInterceptor() {
ttt@Override
tttpublic Object intercept(Object obj, Method method, Object[] args,
tttMethodProxy proxy) throws Throwable
ttt{
ttttSystem.out.println("Enginner 2 writes document");
ttttObject res = method.invoke(target, args);
ttttreturn res;
ttt}
tt}
tt);
ttreturn enhancer.create();
t}
}
测试代码:
ProductOwner ross = new ProductOwner("Ross");
ProductOwner rossProxy = (ProductOwner) new EnginnerCGLibProxy().bind(ross);
rossProxy.defineBackLog();
尽管ProductOwner未实现任何代码,但它也成功被代理了:
161534henwfnsrfjwwrenj.jpg


用CGLIB实现Java动态代理的局限性

假如我们了解了CGLIB创建代理类的原理,那么其局限性也就一目了然。我们现在做个实验,将ProductOwner类加上final修饰符,使其不可被继承:
161534tthhzmq6pchcimuc.jpg


再次执行测试代码,这次就报错了: Cannot subclass final class XXXX。
所以通过CGLIB成功创建的动态代理,实际是被代理类的一个子类。那么假如被代理类被标记成final,也就无法通过CGLIB去创建动态代理。
Java动态代理实现方式三:通过编译期提供的API动态创建代理类
假设我们确实需要给一个既是final,又未实现任何接口的ProductOwner类创建动态代码。除了InvocationHandler和CGLIB外,我们还有最后一招:
我直接把一个代理类的源代码用字符串拼出来,然后基于这个字符串调用JDK的Compiler(编译期)API,动态的创建一个新的.java文件,然后动态编译这个.java文件,这样也能得到一个新的代理类。
161534mf42jazudff4w42j.jpg


测试成功:
161535sspmvmmyq6toqmeq.jpg


我拼好了代码类的源代码,动态创建了代理类的.java文件,能够在Eclipse里打开这个用代码创建的.java文件,
161535pkxtcgzczekxfyx6.jpg


161535thcchzo9nsrrxpxe.jpg


下图是如何动态创建ProductPwnerSCProxy.java文件:
161536u1iht7ziwrbttt9r.jpg


下图是如何用JavaCompiler API动态编译前一步动态创建出的.java文件,生成.class文件:
161536gqochx3s6fmg4hdr.jpg


下图是如何用类加载器加载编译好的.class文件到内存:
161536db080140mzxaox74.jpg


假如您想试试这篇文章介绍的这四种代理模式(Proxy Design Pattern), 请参考我的github仓库,全部代码都在上面。感谢阅读。
https://github.com/i042416/JavaTwoPlusTwoEquals5/tree/master/src/proxy
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

  • 0 关注
  • 0 粉丝
  • 7 帖子
广告招商