Java学习自我总结——代理

首先先定义几个名词：

1.委托类（被代理类）；2.中间类；3.代理类；

其次，明确代理的概念：代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式；即通过代理对象访问目标对象，这样做的好处是：可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能，不要随意去修改别人已经写好的代码或者方法。

现在我们一起来看一下

静态代理：

静态代理的前提条件是委托类和代理类继承自同一个父类，或者实现了相同的接口，所以我们先定义一个接口Seller：

public interface Seller {
	void sell();
	String advertise(String advertisement);	
}

然后由Vendor和Agent作为Selller接口的具体实现类，

public class Vendor implements Seller{
	@Override
	public void sell() {
		// TODO Auto-generated method stub
		System.out.println("The Vendor is selling.");
	}
	@Override
	public String advertise(String advertise) {
		// TODO Auto-generated method stub
		return "The advertisement is "+advertise;
	}
}

public class Agent implements Seller{
	private Vendor vendor = new Vendor();
	@Override
	public void sell() {
		// TODO Auto-generated method stub
		vendor.sell();
	}
	@Override
	public String advertise(String advertise) {
		// TODO Auto-generated method stub
		return vendor.advertise(advertise);
	}
}

作为代理类的Agent只要持有对Vendor类的一个引用就可以实现Vendor类的方法，这时候我们考虑对Vendor类增加一些功能，比如说在sell()的前后分别输出一个字符串，这时候我们就可以通过对代理类的修改来实现新功能，而不需要在委托类里面进行修改：

public class Agent implements Seller{
	private Vendor vendor;
	@Override
	public void sell() {
		// TODO Auto-generated method stub
		System.out.println("We are preparing for the selling.");
		vendor.sell();
		System.out.println("The selling is done.");
	}
	@Override
	public String advertise(String advertise) {
		// TODO Auto-generated method stub
		return vendor.advertise(advertise);
	}
}

我们再写一个简单的测试类来测试一下：

public class AgentTest {
	public static void main(String[] args) {
		Agent agent = new Agent();
		agent.sell();
	}
}

测试结果：

这就实现了委托类和代理类之间的解耦，在不修改委托类的前提下，做一些功能上的改变。

动态代理：

相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。想要实现动态代理首先需要一个实现了InvocationHandler的中间类：

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

public class MiddleProxy implements InvocationHandler {
	private Object object;
	public MiddleProxy(Object object) {
		super();
		this.object = object;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("Before the selling.");
		Object result = method.invoke(object, args);
		System.out.println("after the selling.");
		return result;
	}
}

仔细的看一下代码，我们可以发现，在中间类中我们仍然持有一个object的引用，通过invoke()方法反射调用了Object类的方法method，很明显对于委托类和中间类来说，这两个类是一种静态代理的关系。

然后我们再写一个测试的代理类来看一下动态代理的具体实现：

import java.lang.reflect.Proxy;

public class MiddleProxyTest {

	public static void main(String[] args) {
		MiddleProxy proxy = new MiddleProxy(new Vendor());
		Seller seller = new Vendor();
		System.out.println("不使用代理方式：");
		seller.sell();
		System.out.println("使用代理方式：");
		//获取类加载器
		ClassLoader loader = seller.getClass().getClassLoader();
		//获取代理对象
		//Proxy.newProxyInstance(loader, interfaces, proxy)
		//参数分别为：loader是类加载器，interfaces是实现的接口，
		//proxy是InvocationHandler的具体实现类
		seller = (Seller) Proxy.newProxyInstance(loader, new Class[] {Seller.class}, proxy);
		seller.sell();
	}
}

在这个代理类中我们先生成了一个Vendor的非代理对象，再通过Proxy.newProxyInstance()方法生成了一个代理对象，对这两个对象调用sell()方法做一个对比，运行结果如下：

从运行行结果中可以看出来，seller.sell()转到了invoke()的调用，最后转到了Vendor委托类的sell()方法，在不修改Vendor类的情况下实现了方法功能的改变。

Q&A

Q1:使用静态代理就可以实现解耦，在不修改Vendor类的情况下改变方法功能，为什么还需要使用Proxy动态代理？

A:对于简单的类和方法来说，静态代理就已经绰绰有余了，但是随着业务量的增大，比如说每个类都会有的get&set方法，你会发现为每个方法或者类写一个静态代理的工作量有多么的庞大，幸好我们有动态代理简化了这些模板化的工作。

Q2:代理的优点有哪些？

A:这是一个总结性的答案，在上面一系列的范例之后，如果你还没有总结出代理的优点，那么我这个笔记就会显得很烂：

优点一：可以隐藏委托类的实现;

优点二：可以实现解耦，在不修改委托类代码的情况下能够做一些功能的改变。