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

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

看好之后，你决定要买房了，可是一大堆乱七八糟的手续要办，自己还要上班，没空，怎么办？这时候就要找个中介来处理这件事情了，你只需要把钱和身份证给中介，中介过几天之后会把房子的钥匙和房产证交到你的手上，你只需要等着就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有些相似之处。。今天就学到这里了，明天继续！！