代理Proxy初探
Proxy,也就是“代理”了。
意思就是。你不用去做,别人取代你去处理。比方说:租房。你仅仅要找到“我爱我家”中介,把全部的事情交给他们去代劳,
“我爱我家”此时就是你的Proxy。
它在程序开发中起到了非常关键的数据,比方传说中的 AOP(面向切面编程)。就是针对代理的一种应用。
此外,在设计模式中,另一个“代理模式”。在公司里要上外网,要在浏览器里设置一个 HTTP 代理。
wocao。代理无处不在啊,不搞明确,岂不是非常没面子?
凡是都要由浅入深,学习也不例外。先来一个 Hello World 吧:
public interface Hello { void say(String name); }
这是一个 Hello 接口,不用解释了,大家都懂的。
赶紧上实现类吧:
public class HelloImpl implements Hello{ @Override public void say(String name) { System.out.println("Hello! " + name); } }
wocao!这简直就是 So easy 嘛。可是有个问题:假设要在 println() 方法前面和后面分别须要处理一些逻辑,怎么做呢?把这些逻辑写死在 say() 方法里面吗?肯定不够优雅啦,菜鸟一般这样干。作为一名资深的程序猿。我坚决不能这样做!
我要用代理。写一个 HelloProxy 类,让它去调用 HelloImpl 的 say() 方法,在调用的前后分别进行逻辑处理不即可了吗?赶紧搞一个吧:
public class HelloProxy implements Hello{ private HelloImpl helloImpl; public HelloProxy(){} public HelloProxy(HelloImpl helloImpl){ this.helloImpl = helloImpl; } @Override public void say(String name) { before(); helloImpl.say(name); after(); } private void before() { System.out.println("Before"); } private void after() { System.out.println("After"); } }
我将 HelloProxy 类实现了 Hello 接口(和 HelloImpl 实现同样的接口),而且在构造方法中 new 出一个 HelloImpl 类的实例。
这样一来,我就能够在 HelloProxy 的 say() 方法里面去调用 HelloImpl 的 say() 方法了。
更重要的是。我还能够在调用的前后分别加上 before() 与 after() 方法,在这两个方法里去实现那些前后逻辑。
用一个 main 方法来測试一下吧:
public class StaticClient { public static void main(String[] args) { Hello helloProxy = new HelloProxy(new HelloImpl()); helloProxy.say("Jack"); } }
执行后,打印出:
Before
Hello! Jack
After
轻而易举,我就写出了这么优雅的代码(暗自小嗨了一把)。
不久后,我在一本设计模式的书上看到,原来我写的这个 HelloProxy 就是所谓的“代理模式”啊!
我仅仅能说,自己和 GoF(四人帮)的距离有接近了一点。
于是我疯狂的使用“代理模式”,项目中到处都有 XxxProxy 的声影。直到有一天。架构师看到了我的代码,他惊呆了!他对我说:“你怎么这么喜欢用静态代理呢?你就不会用动态代理吗?给我全都重构了!”。
我表面上点了点头,说:“好的!
”。事实上我根本都不知道什么是“静态代理”,什么又是“动态代理”。我继续翻开我那本垫桌脚的设计模式。深入得研究了一番,最后我才明确,原来我一直用的都是“静态代理”啊,怪不得架构师说我到处都是 XxxProxy 类了。
我好恨我自己!一定要将这些垃圾 Proxy 都重构为“动态代理”。
于是我就是用 JDK 给我们提供的动态代理方案,写了一个 DynamicProxy:
public class DynamicProxy implements InvocationHandler { private Object target; public DynamicProxy(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(); Object result = method.invoke(target, args); after(); return result; } private void before() { System.out.println("Before"); } private void after() { System.out.println("After"); } }
在 DynamicProxy 类中。我定义了一个 Object 类型的 target 变量,它就是被代理的目标对象,通过构造函数来初始化(如今流行叫“注入”了,我认为叫“射入”也不错哦。构造函数初始化叫“正着射”。所以 reflect 方式就叫“反着射”,简称“反射”)。
言归正传。DynamicProxy 实现了 InvocationHandler 接口。那么必须实现该接口的 invoke 方法,參数不做解释,望文生义吧,是 JRE 给我们“射”进来的。在该方法中。直接通过反射去 invoke method,在调用前后分别处理 before 与 after,最后将 result 返回。
写一个 main() 方法看看实际怎么用吧:
public class DynamicClient { public static void main(String[] args) { Hello hello = new HelloImpl(); DynamicProxy dynamicProxy = new DynamicProxy(new HelloImpl()); Hello helloProxy = (Hello) Proxy.newProxyInstance( hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), dynamicProxy ); helloProxy.say("Jack"); } }
没错,意思就是,用我写的这个通用的 DynamicProxy 类去包装 HelloImpl 实例,然后再调用 JDK 给我们提供的 Proxy 类的工厂方法 newProxyInstance() 去动态地创建一个 Hello 接口的代理类。最后调用这个代理类的 say() 方法。
执行一下,结果和曾经一样。动态代理成功了。
事实上,动态代理就是帮我们自己主动生成 XxxProxy 类的法宝啊。
要注意的是。Proxy.newProxyInstance() 方法的參数实在是让我“无语吐槽”。
參数1:ClassLoader
參数2:该实现类的全部接口
參数3:动态代理对象
调用完了还要来一个强制类型转换一下。
wocao!
这一坨 shi 一定要想办法封装一下,避免再次发生到处都是 Proxy.newProxyInstance(),这样架构师又要骂我了。
于是我将这个 DynamicProxy 重构了:
public class DynamicProxy implements InvocationHandler { private Object target; public DynamicProxy(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(); Object result = method.invoke(target, args); after(); return result; } @SuppressWarnings("unchecked") public <T> T getProxy() { return (T) Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), this ); } private void before() { System.out.println("Before"); } private void after() { System.out.println("After"); } }
我在 DynamicProxy 里加入了一个 getProxy() 方法,无需传入不论什么參数。将刚才所说的那一坨 shi。放在这种方法中,而且该方法返回一个泛型类型,就不会强制类型转换了。方法头上加那个 @SuppressWarnings("unchecked") 注解表示忽略编译时的警告(由于 Proxy.newProxyInstance() 方法返回的是一个 Object,这里我强制转换为 T 了,这是向下转型,IDE 中就会有警告,编译时也会出现提示,非常烦)。
好了,这下子使用 DynamicProxy 就简单了吧:
public class DynamicClient { public static void main(String[] args) { DynamicProxy dynamicProxy = new DynamicProxy(new HelloImpl()); Hello helloProxy = dynamicProxy.getProxy(); helloProxy.say("Jack"); } }
确实简单用 2 行代理就去掉了前面的 7 行代码(省了 5 行),架构师看到了这种代码肯定会表扬我!
经过一番代码重构后。我提交了全部的代码。架构师看到了。没有吱声…… 可我总算学会了动态代理。
用了这个 DynamicProxy 以后,我认为它还是很爽的,爽的地方是,接口变了。这个动态代理类不用动。而静态代理就不一样了。接口变了。实现类还要动。代理类也要动。
但我也发现动态代理并非“万灵丹”,它也有搞不定的时候,比方说,我要代理一个没有不论什么接口的类,它就没有勇武之地了!这就是 JDK 给我们提供的动态代理。让我不知道该说什么了。
于是我又開始调研,是否能代理没有接口的类呢?最终让我找到了这颗“银弹”!
那就是 CGLib 这个类库。尽管它看起来不太起眼,但 Spring、Hibernate 这样牛逼的开源框架都用到了它。它就是一个在执行期间动态生成字节码的工具,也就是动态生成代理类了。
说起来好高深。实际用起来一点都不难。我再搞一个 CGLibProxy 吧:
public class CglibProxy implements MethodInterceptor, Serializable { private static final long serialVersionUID = 1L; private void doBefore() { System.out.println("before method invoke"); } private void doAfter() { System.out.println("after method invoke"); } public Object getProxy(Object target) { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(target.getClass()); enhancer.setCallback(this); enhancer.setClassLoader(target.getClass().getClassLoader()); return enhancer.create(); } public Object getProxy(Class<? extends Object> clazz){ Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(clazz); enhancer.setCallback(this); enhancer.setInterfaces(new Class[] { Serializable.class }); return enhancer.create(); } public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { try { // 调用之前 doBefore(); // 调用原始对象的方法 Object result = proxy.invokeSuper(obj, args); // 调用之后 doAfter(); return result; } catch (Throwable e) { throw e; } } }
须要实现 CGLib 给我们提供的 MethodInterceptor 实现类。并填充 intercept() 方法。方法中最后一个 MethodProxy 类型的參数 proxy,值得注意!CGLib 给我们提供的是方法级别的代理。也能够理解为对方法的拦截(这不就是传说中的“方法拦截器”吗?)。
这个功能对于我们这群屌丝程序猿而言,如同雪中送炭啊,此乃神器也!我们直接调用 proxy 的 invokeSuper() 方法。将被代理的对象 obj 以及方法參数 args 传入当中就可以。
与 DynamicProxy 类似,我在 CGlibProxy 中也加入了一个泛型的 getProxy() 方法。便于我们能够高速地获取自己主动生成的代理对象。还是用一个 main() 方法来描写叙述吧:
public class CglibClient { public static void main(String[] args) { CglibProxy cglib = new CglibProxy(); HelloImpl proxy = (HelloImpl)cglib.getProxy(new HelloImpl()); proxy.say("Somnus"); System.out.println("*****************************************************************"); HelloImpl proxy2 = (HelloImpl)cglib.getProxy(HelloImpl.class); proxy2.say("Somnus"); } }
仍然通过 2 行代码就能够返回代理对象了,与 JDK 动态代理不同的是,这里不须要不论什么的接口信息,对谁都能够生成动态代理对象(无论它是“屌丝”还是“高富帅”)。说它是神器,过分吗?
我一向都是以追求完美而著称。2 行代码返回代理对象,我认为还是有些多余,我不想总是去 new 这个 CGLibProxy 对象,最好 new 一次,以后随时拿随时用。
于是我想到了“单例模式”:
public class CglibProxy implements MethodInterceptor { private static CglibProxy instance = newCglibProxy(); private CglbProxy() { } public static CglibProxy getInstance() { return instance; } ... }
我加了以上几行代码,就搞定了!
须要说明的是:这里有一个 private 的构造方法,就是为了限制外界不能再去 new 它了,换句话说,我在这里把它给“阉”了。
用一个 main() 方法来证明我的简单主义思想:
public static void main(String[] args) { HelloImpl helloImpl = CglibProxy.getInstance().getProxy(HelloImpl.class); helloImpl.say("Jack"); }
没错吧?仅仅需 1 行代码就能够获代替理对象了!
总结一下,我们今天谈到了无代理、静态代理、JDK 动态代理、CGLib 动态代理,事实上代理的世界远不止这么小,还有非常多实际的应用场景。本文一開始谈
到的 AOP 是一个最为典型的案例,所以有必要再进行继续下去。
posted on 2017-04-10 17:02 gavanwanggw 阅读(177) 评论(0) 编辑 收藏 举报