设计模式之-----代理模式

今天学习了代理模式，一开始一头雾水的，感觉完全就是给自己填麻烦，一个好好的类，直接调用就成，为什么还要费半天劲去用代理呢？看了看公司的工程之后，就明白它存在的意义了，举个例子来说，比如你想买个房子，你第一时间会做什么？我想你一定会上网搜一搜，房子的价格，位置，周围物业等信息，对么？这个时候，网上的这些资料就可以看做是一个代理，如果没有这些代理，我们就只能一个一个的去实地考察，那样会累死的。。

看好之后，你决定要买房了，可是一大堆乱七八糟的手续要办，自己还要上班，没空，怎么办？这时候就要找个中介来处理这件事情了，你只需要把钱和身份证给中介，中介过几天之后会把房子的钥匙和房产证交到你的手上，你只需要等着就ok，是不是很方便呢？这个时候，中介就充当了一个代理的角色，你买房的手续不需要你去处理，你只要给钱，拎包入住即可，可能有许多的人需要这样的中介，那么，把这些相同的，过程复杂的，全部让代理来处理，这就是代理的作用。当系统越来越大时，代理的作用就尤为突出了。

从大体上来说，有静态代理和动态代理之分，细分的话就多了，在这不一一列举。

先来一个实例，更好的理解一下代理

包结构如下：

这里用的一个例子就是我们日常生活中的“相亲”，一个男的找媒婆去女方家说媒。

首先是静态代理

首先建立接口，是让男人继承的，将男人想说的话，通过媒婆告诉女方

package com.proxy.sta.intf;public interface IMarried {public void marry();}

之后是男人类

package com.proxy.sta.sub;import com.proxy.sta.intf.IMarried;public class Man implements IMarried{public void marry() {System.out.println("我想找个女朋友");}}

然后是媒婆类，这个媒婆就是充当了代理的作用

package com.proxy.sta.pro;import com.proxy.sta.intf.IMarried;import com.proxy.sta.sub.Man;public class Match implements IMarried{private IMarried married ;public Match(){if(married == null){married = new Man();}}public void marry() {before();this.married.marry();after();}private void before(){System.out.println("我是媒婆");}private void after(){System.out.println("我的话传到了，我走了啊");}}

然后就是测试类了，测试类的角色相当于女方，媒婆到了女方这里，将话带到

package com.proxy.sta.main;import com.proxy.sta.intf.IMarried;import com.proxy.sta.pro.Match;public class TestStaticProxy {public static void main(String[] args) {IMarried married = new Match();married.marry();}}

看到了没？测试类很简单，女方只与媒婆发生了接触，main方法中完全没有使用到男人。

测试结果

在这里要注意的问题就是，随着业务的增多，静态代理的代码可能会出现指数型增长，这可不是我们想要的，不过，在一般业务很简单的情况下，使用静态代理也不失为一个好方法。

说完了静态代理，下边就来说说动态代理，顾名思义，动态，就是在运行时才增加的，比如我们熟悉的spring等框架中，就使用了很多的动态代理。

还是上边的那个例子，我们现在用动态代理来实现。

接口和男人类都是一样的，这里我就不在写了，上边有，主要的区别就是代理类，代码如下

package com.proxy.dynamic.pro;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class DynamicMatch implements InvocationHandler {private Object obj;public DynamicMatch(Object obj) {this.obj = obj;}public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {Object result = null;before();result = method.invoke(this.obj, args);after();return result;}private void before(){System.out.println("我是媒婆");}private void after(){System.out.println("我的话传到了，我走了啊");}public static Object factory(Object obj) {Class cls = obj.getClass();return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), new DynamicMatch(obj));}}

要注意，这个代理类要实现InvocationHandler接口，这个接口只有一个方法，就是invoke，其实我也是刚刚接触这个，要说它有什么用，我还真是用文字表达不出来，希望有朋友能帮我解释一下。。现在我只能是自己知道它怎么用，具体为什么我还真不知道。。

不过，大致的意思就是当访问接口中的方法时，它会自动调用invoke方法，然后执行

下面是测试类

package com.proxy.dynamic.main;import com.proxy.dynamic.intf.IMarried;import com.proxy.dynamic.pro.DynamicMatch;import com.proxy.dynamic.sub.Man;public class TestDynamicProxy {public static void main(String[] args) throws Exception {IMarried proxy = (IMarried) DynamicMatch.factory(new Man());proxy.marry();}}

很显然，结果和上边一样。

动态代理的好处是相对较灵活，代码数量不会出现爆炸式增长，而是定的控制在一定范围内。

给我的感觉，代理模式就和spring的AOP有些相似之处。。今天就学到这里了，明天继续！！