代理模式

代理模式（Proxy Pattern），一个类代表另一个类的功能。例如，购买火车票不一定要去火车站买，可以通过 12306 网站或者去火车票代售点买。又如找女朋友、找保姆、找工作等都可以通过找中介完成。

意图：为其他对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

何时使用：想在访问一个类时做一些控制。

如何解决：增加中间层。

关键代码：实现与被代理类组合。

优点： 1、职责清晰。 2、高扩展性。 3、智能化。

缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

使用场景：按职责来划分，通常有以下使用场景： 1、远程代理。 2、虚拟代理。 3、Copy-on-Write 代理。 4、保护（Protect or Access）代理。 5、Cache代理。 6、防火墙（Firewall）代理。 7、同步化（Synchronization）代理。 8、智能引用（Smart Reference）代理。

注意事项： 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

代理模式的主要角色如下：

1.抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。

2.真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。

3.代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

其结构图如图：

代理模式

 

实现：

/**
 * 
 * @ClassName: TrainTicket
 * @Description: 抽象主题：火车票
 * @author: ljx
 * @date: 2019年2月28日 下午4:35:15
 */
public interface TrainTicket {
	public void buyTrainTicket();
}
/**
 * 
 * @ClassName: RealTrainTicket
 * @Description: 真实主题：购买火车票
 * @author: ljx
 * @date: 2019年2月28日 下午4:41:08
 */
public class RealTrainTicket implements TrainTicket {

	@Override
	public void buyTrainTicket() {
		System.out.println("购买火车票");
	}

}
/**
 * 
 * @ClassName: ProxyTrainTicket
 * @Description: 代理
 * @author: ljx
 * @date: 2019年2月28日 下午4:41:48
 */
public class ProxyTrainTicket implements TrainTicket{

	private RealTrainTicket realTrainTicket;
	
	public ProxyTrainTicket(RealTrainTicket realTrainTicket) {
		this.realTrainTicket = realTrainTicket;
	}
	
	@Override
	public void buyTrainTicket() {
		proxy12306Start();
		realTrainTicket.buyTrainTicket();
		proxy12306End();
	}
	
	public void proxy12306Start(){
		System.out.println("12306代购票开始");
	}
	
	public void proxy12306End(){
		System.out.println("12306代购票结束");
	}
	
}
//测试
public class ProxyTest {
	public static void main(String[] args) {
		TrainTicket t = new ProxyTrainTicket(new RealTrainTicket());
		t.buyTrainTicket();
	}
}

结果：

12306代购票开始

购买火车票

12306代购票结束

在前面介绍的代理模式中，代理类中包含了对真实主题的引用，这种方式存在两个缺点。

1.真实主题与代理主题一一对应，增加真实主题也要增加代理。

2.设计代理以前真实主题必须事先存在，不太灵活。采用动态代理模式可以解决以上问题，如 SpringAOP，其结构图如图所示：

动态代理模式

只需改动一下代码即可实现

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 
 * @ClassName: DynamicProxyTrainTicketManager
 * @Description: 动态代理
 * @author: ljx
 * @date: 2019年2月28日 下午5:10:49
 */
public class DynamicProxyTrainTicketManager implements InvocationHandler {

	public Object trainTicket;
	
	public Object newProxyTrainTicket(Object trainTicket){
		this.trainTicket = trainTicket;
		// 第一个参数，目标对象 的装载器
        // 第二个参数，目标接口已实现的所有接口，而这些是动态代理类要实现的接口列表
        // 第三个参数， 调用实现了InvocationHandler的对象生成动态代理实例，当你一调用代理，代理就会调用InvocationHandler的invoke方法
		return Proxy.newProxyInstance(
				trainTicket.getClass().getClassLoader(),
				trainTicket.getClass().getInterfaces(), 
				this);
	}
	
	/**
     * 反射，这样你可以在不知道具体的类的情况下，根据配置的参数去调用一个类的方法。在灵活编程的时候非常有用。
     */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//代购火车票开始
		proxy12306Start();
		Object object = null;
		try {
			object = method.invoke(proxy, args);
			//执行成功，购票结束
			proxy12306End();
		} catch (Exception e) {
			 System.out.println("error-->>" + e.getMessage());
			 System.out.println("error-->>" + method.getName());
		}
		return object;
	}

	public void proxy12306Start(){
		System.out.println("12306代购票开始");
	}
	
	public void proxy12306End(){
		System.out.println("12306代购票结束");
	}
}

/**
 * 
 * @ClassName: ProxDynamicText
 * @Description: 动态代理测试
 * @author: ljx
 * @date: 2019年2月28日 下午5:23:37
 */
public class ProxDynamicText {
	public static void main(String[] args) {
		DynamicProxyTrainTicketManager dttm = new DynamicProxyTrainTicketManager();
		//即使有多个不同的真实对象，也可以使用同一个代理
		TrainTicket t = (TrainTicket) dttm.newProxyTrainTicket(new RealTrainTicket());
		t.buyTrainTicket();
	}
}

优点：

1、一个动态代理类更加简单了，可以解决创建多个静态代理的麻烦，避免不断的重复多余的代码

2、调用目标代码时，会在方法“运行时”动态的加入，决定你是什么类型，才调谁，灵活

缺点：

1、系统灵活了，但是相比而言，效率降低了，比静态代理慢一点

2、动态代理比静态代理在代码的可读性上差了一点，不太容易理解

3、JDK动态代理只能对实现了接口的类进行代理

总结

各有各的好，具体情况具体讨论

... ...，欢迎指正！