代理模式
代理模式的定义很简单：给某一对象提供一个代理对象，并由代理对象控制对原对象的引用。
代理模式的结构
有些情况下，一个客户不想或者不能够直接引用一个对象，可以通过代理对象在客户端和目标对象之间起到中介作用。代理模式中的角色有：
1、抽象对象角色
声明了目标对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象
2、目标对象角色
定义了代理对象所代表的目标对象
3、代理对象角色
代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象
静态代理示例
这里模拟的是作为访问网站的场景，以新浪网举例。我们通常访问新浪网，几乎所有的Web项目尤其是新浪这种大型网站，是不可能采用集中式的架构的，使用的一定是分布式的架构，分布式架构对于用户来说，我们发起链接的时候，链接指向的并不是最终的应用服务器，而是代理服务器比如Nginx，用以做负载均衡。
所以，我们的例子，简化来说就是用户访问新浪网-->代理服务器-->最终服务器。先定义一个服务器接口Server，简单定义一个方法，用于获取页面标题：
/**
* 服务器接口，用于获取网站数据
*/
public interface Server { /**
* 根据url获取页面标题
*/
public String getPageTitle(String url); }
我们访问的是新浪网，所以写一个SinaServer，传入url，获取页面标题：
/**
* 新浪服务器
*/
public class SinaServer implements Server { @Override
public String getPageTitle(String url) {
if ("http://www.sina.com.cn/".equals(url)) {
return "新浪首页";
} else if ("http://http://sports.sina.com.cn/".equals(url)) {
return "新浪体育_新浪网";
} return "无页面标题";
} }
这里写得比较简单，就做了一个if..else if判断，大家理解意思就好。写到这里，我们说明两点：
- 如果不使用代理，那么用户访问相当于就是直接new SinaServer()出来并且调用getPageTitle(String url)方法即可
- 由于分布式架构的存在，因此我们这里要写一个NginxProxy，作为一个代理，到时候用户直接访问的是NginxProxy而不是和SinaServer打交道，由NginxProxy负责和最终的SinaServer打交道
因此，我们写一个NginxProxy：
/**
* Nginx代理
*/
public class NginxProxy implements Server { /**
* 新浪服务器列表
*/
private static final List<String> SINA_SERVER_ADDRESSES = Lists.newArrayList("192.168.1.1", "192.168.1.2", "192.168.1.3"); private Server server; public NginxProxy(Server server) {
this.server = server;
} @Override
public String getPageTitle(String url) {
// 这里就简单传了一个url，正常请求传入的是Request，使用UUID模拟请求原始Ip
String remoteIp = UUID.randomUUID().toString();
// 路由选择算法这里简单定义为对remoteIp的Hash值的绝对值取模
int index = Math.abs(remoteIp.hashCode()) % SINA_SERVER_ADDRESSES.size();
// 选择新浪服务器Ip
String realSinaIp = SINA_SERVER_ADDRESSES.get(index); return "【页面标题：" + server.getPageTitle(url) + "】,【来源Ip：" + realSinaIp + "】";
} }
这里同样为了简单起见，服务器列表写死几个ip，同时由于只传一个url而不是具体的Request，每次随机一个UUID，对UUID的HashCode绝对值取模，模拟这次请求被路由到哪台服务器上。
调用方这么写：
/**
* 静态代理测试
*/
public class StaticProxyTest { @Test
public void testStaticProxy() {
Server sinaServer = new SinaServer();
Server nginxProxy = new NginxProxy(sinaServer);
System.out.println(nginxProxy.getPageTitle("http://www.sina.com.cn/"));
} }
第8行表示的是要访问的是新浪服务器，第9行表示的是用户实际访问的是Nginx代理而不是真实的新浪服务器，由于新浪服务器和代理服务器实际上都是服务器，因此他们可以使用相同的接口Server。
程序最终运行的结果为：
【页面标题：新浪首页】,【来源Ip：192.168.1.2】
当然，多运行几次，来源Ip一定是会变的，这就是一个静态代理的例子，即用户不和最终目标对象角色（SinaServer）打交道，而是和代理对象角色（NginxProxy）打交道，由代理对象角色（NginxProxy）控制用户的访问。
静态代理的缺点
静态代理的特点是静态代理的代理类是程序员创建的，在程序运行之前静态代理的.class文件已经存在了。
从静态代理模式的代码来看，静态代理模式确实有一个代理对象来控制实际对象的引用，并通过代理对象来使用实际对象。这种模式在代理量较小的时候还可以，但是代理量一大起来，就存在着两个比较大的缺点：
1、静态代理的内容，即NginxProxy的路由选择这几行代码，只能服务于Server接口而不能服务于其他接口，如果其它接口想用这几行代码，比如新增一个静态代理类。久而久之，由于静态代理的内容无法复用，必然造成静态代理类的不断庞大
2、Server接口里面如果新增了一个方法，比如getPageData(String url)方法，实际对象实现了这个方法，代理对象也必须新增方法getPageData(String url)，去给getPageData(String url)增加代理内容（假如需要的话）
利用JDK中的代理类Proxy实现动态代理的示例
由于静态代理的局限性，所以产生了动态代理的概念。
上面的例子我们采用动态代理的方式，动态代理的核心就是将公共的逻辑抽象到InvocationHandler中。关于动态代理，JDK本身提供了支持，因此实现一下InvocationHandler接口：
/**
* Nginx InvocationHandler
*/
public class NginxInvocationHandler implements InvocationHandler { /**
* 新浪服务器列表
*/
private static final List<String> SINA_SERVER_ADDRESSES = Lists.newArrayList("192.168.1.1", "192.168.1.2", "192.168.1.3"); private Object object; public NginxInvocationHandler(Object object) {
this.object = object;
} @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String remoteIp = UUID.randomUUID().toString();
int index = Math.abs(remoteIp.hashCode()) % SINA_SERVER_ADDRESSES.size();
String realSinaIp = SINA_SERVER_ADDRESSES.get(index); StringBuilder sb = new StringBuilder();
sb.append("【页面标题：");
sb.append(method.invoke(object, args));
sb.append("】,【来源Ip：");
sb.append(realSinaIp);
sb.append("】");
return sb.toString();
} }
这里就将选择服务器的逻辑抽象成为了公共的代码了，因为调用的是Object里面的method，Object是所有类的超类，因此并不限定非要是Sever，A、B、C都是可以的，因此这个NginxInvocationHandler可以灵活地被各个地方给复用。
调用的时候这么写：
/**
* 动态代理测试
*/
public class DynamicProxyTest { @Test
public void testDynamicProxy() {
Server sinaServer = new SinaServer();
InvocationHandler invocationHandler = new NginxInvocationHandler(sinaServer);
Server proxy = (Server)Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{Server.class}, invocationHandler); System.out.println(proxy.getPageTitle("http://www.sina.com.cn/"));
} }
Proxy本身也是JDK提供给开发者的，使用Proxy的newProxyInstance方法可以产生对目标接口的一个代理，至于代理的内容，即InvocatoinHandler的实现。
看一下运行结构，和静态代理是一样的：
【页面标题：新浪首页】,【来源Ip：192.168.1.2】
动态代理写法本身有点不好理解，需要开发者多实践，多思考，才能真正明白动态代理的含义及其实际应用。
动态代理的优点
1、最直观的，类少了很多
2、代理内容也就是InvocationHandler接口的实现类可以复用，可以给A接口用、也可以给B接口用，A接口用了InvocationHandler接口实现类A的代理，不想用了，可以方便地换成InvocationHandler接口实现B的代理
3、最重要的，用了动态代理，就可以在不修改原来代码的基础上，就在原来代码的基础上做操作，这就是AOP即面向切面编程
动态代理的缺点
动态代理有一个最大的缺点，就是它只能针对接口生成代理，不能只针对某一个类生成代理，比方说我们在调用Proxy的newProxyInstance方法的时候，第二个参数传某个具体类的getClass()，那么会报错：
Exception in thread "main" java.lang.IllegalArgumentException: proxy.DynamicHelloWorldImpl is not an interface
这是因为java.lang.reflect.Proxy的newProxyInstance方法会判断传入的Class是不是一个接口：
...
/*
* Verify that the Class object actually represents an
* interface.
*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
...
而实际使用中，我们为某一个单独的类实现一个代理也很正常，这种情况下，我们就可以考虑使用CGLIB（一种字节码增强技术）来为某一个类实现代理了。