代理模式笔记

代理模式：

为另一个对象提供一个替身或占位符以控制对这个对象的访问

远程代理：

远程代理可以作为另一个JVM上对象的本地代表。调用代理的方法，会被代理利用网络转发到远程执行，并且结果会通过网络返回给代理，再由代理将结果转给客户。

例子：

通过JAVA RMI来实现远程访问，并通过远程代理完成控制，目前例子暂缺。

虚拟代理：

虚拟代理作为创建开销大的对象的代表。虚拟代理经常直到我们真正需要一个对象的时候才创建它。当对象在创建前和创建中时，由虚拟代理来扮演对象的替身。对象创建后，代理就会将请求直接委托给对象。

例子：

swing程序，显示网络图片时，如果没有加载完成则使用代理显示图片暂无。目前例子暂缺。

动态代理：

java在java.lang.reflect包中有自己的代理支持，利用这个包你可以在运行时动态地创建一个代理类，实现一个或多个接口，并将方法的调用转发到你所指定的类。因为实际的代理类是在运行时创建的，我们称这个Java技术为：动态代理。

动态代理之所以被称为动态，是因为运行时才将它的类创建出来。代码开始执行时，还没有proxy类，它是根据需要从你传入的接口集创建的。

例子：

实体类：

public interface PersonBean {
	
	String getName();
	String getGender();
	String getInterests();
	int getHotOrNotRating();
	
	void setName(String name);
	void setGender(String gender);
	void setInterests(String interensts);
	void setHotOrNotRating(int rating);
	
}

实体类实现：

public class PersonBeanImpl implements PersonBean {
	
	String name;
	String gender;
	String interests;
	int rating;
	int ratingCount = 0;

	@Override
	public String getName() {
		return name;
	}

	@Override
	public String getGender() {
		return gender;
	}

	@Override
	public String getInterests() {
		return interests;
	}

	@Override
	public int getHotOrNotRating() {
		if(ratingCount == 0 ){
			return 0;
		}
		return (rating/ratingCount);
	}

	@Override
	public void setName(String name) {
		this.name = name;
	}

	@Override
	public void setGender(String gender) {
		this.gender = gender;
	}

	@Override
	public void setInterests(String interensts) {
		this.interests = interensts;
	}

	@Override
	public void setHotOrNotRating(int rating) {
		this.rating += rating;
		ratingCount++;
	}

}

调用处理器：

总共2个处理器，实现了2个代理。

OwnerInvocationHandler

public class OwnerInvocationHandler implements InvocationHandler {

	PersonBean person;
	
	public OwnerInvocationHandler(PersonBean person){
		this.person = person;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		try{
			if(method.getName().startsWith("get")){
				return method.invoke(person, args);
			} else if(method.getName().equals("setHotOrNotRating")){
				throw new IllegalAccessException();
			}else if(method.getName().startsWith("set")){
				return method.invoke(person, args);
			}
		}catch(InvocationTargetException e){
			e.printStackTrace();
		}
		return null;
	}

}

NonOwnerInvocationHandler

public class NonOwnerInvocationHandler implements InvocationHandler {

	PersonBean person;
	
	public NonOwnerInvocationHandler(PersonBean person){
		this.person = person;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		
		try{
			if(method.getName().startsWith("get")){
				return method.invoke(person, args);
			} else if(method.getName().equals("setHotOrNotRating")){
				return method.invoke(person, args);
			}else if(method.getName().startsWith("set")){
				throw new IllegalAccessException();
			}
		}catch(InvocationTargetException e){
			e.printStackTrace();
		}
		return null;
	}
}

获取代理的代码段（该代码段在之后的主函数中实现）：

PersonBean getOwnerProxy(PersonBean person) {
		return (PersonBean) Proxy.newProxyInstance(person.getClass()
				.getClassLoader(), person.getClass().getInterfaces(),
				new OwnerInvocationHandler(person));
	}
	
	PersonBean getNonOwnerProxy(PersonBean person){
		return (PersonBean) Proxy.newProxyInstance(person.getClass()
				.getClassLoader(), person.getClass().getInterfaces(),
				new NonOwnerInvocationHandler(person));
	}

测试配对服务：

public class MatchMakingTestDrive {

	public static void main(String[] args) {
		MatchMakingTestDrive test = new MatchMakingTestDrive();
		test.drive();
	}

	public void drive() {
		PersonBean joe = getJoe();
		PersonBean ownerProxy = getOwnerProxy(joe);
		System.out.println("Name is " + ownerProxy.getName());
		ownerProxy.setInterests("bowling,Go");
		System.out.println("Interest set from owner proxy");
		try{
			ownerProxy.setHotOrNotRating(10);
		}catch(Exception e){
			System.out.println("Can't set rating from owner proxy");
		}
		System.out.println("Rating is " + ownerProxy.getHotOrNotRating());
		
		
		PersonBean nonProxy = getNonOwnerProxy(joe);
		System.out.println("Name is " + nonProxy.getName());
		try{
			nonProxy.setInterests("bowling,Go");
			System.out.println("Interest set from non owner proxy");
		}catch(Exception e){
			System.out.println("Can't set interest from no owner proxy");
		}
		try{
			nonProxy.setHotOrNotRating(10);
		}catch(Exception e){
			System.out.println("Can't set rating from no owner proxy");
		}
		System.out.println("Rating is " + nonProxy.getHotOrNotRating());
		
	}

	PersonBean getJoe() {
		PersonBean pb = new PersonBeanImpl();
		pb.setGender("man");
		pb.setHotOrNotRating(0);
		pb.setInterests("Math, Computer");
		pb.setName("Joe John");
		return pb;
	}

	PersonBean getOwnerProxy(PersonBean person) {
		return (PersonBean) Proxy.newProxyInstance(person.getClass()
				.getClassLoader(), person.getClass().getInterfaces(),
				new OwnerInvocationHandler(person));
	}
	
	PersonBean getNonOwnerProxy(PersonBean person){
		return (PersonBean) Proxy.newProxyInstance(person.getClass()
				.getClassLoader(), person.getClass().getInterfaces(),
				new NonOwnerInvocationHandler(person));
	}

}

结果：

Name is Joe John
Interest set from owner proxy
Can't set rating from owner proxy
Rating is 0
Name is Joe John
Can't set interest from no owner proxy
Rating is 5

其他代理：

防火墙代理：常出没于公司的防火墙系统。控制网络资源的访问，保护主题免于“坏客户”的侵害。

智能引用代理： 当主题被引用时，进行额外的动作，例如计算一个对象被引用的次数。

缓存代理： 常出没于Web服务器代理，以及内容管理与出版系统。为开销大的运算结果提供暂时存储：它也允许多个客户共享结果，以减少计算或网络延迟。

同步代理：被发现出没于javaspaces，为分散式环境内的潜在对象集合提供同步访问控制。在多线程情况下为主题提供安全的访问。

复杂隐藏代理：用来隐藏一个雷的复杂集合的复杂度，并进行访问控制。有时候也称为外观代理，这不难理解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口。

写入时复制代理：用来控制对象的复制，方法是延迟对象的复制，知道客户真的需要为止。这是虚拟代理的变体。

总结：

- 代理模式为另一个对象提供代表，以便控制客户对对象的访问，管理访问的方式有许多种。

- 远程代理管理客户和远程对象之间的交互。

- 虚拟代理控制访问实例化开销大的对象。

- 保护代理基于调用者控制对对象方法的访问。

- 代理模式有许多变体，例如缓存代理、同步代理、防火墙代理和写入时复制代理

- 代理在结构上类似装饰者，但是目的不同。

- 装饰者模式为对象加上行为，而代理则是控制访问。

- Java内置的代理支持，可以根据需要建立动态代理，并将所有调用非配到所选的处理器。

- 就和其他的包装着一样，代理会造成你的设计中类的数目的增加。