设计模式：代理模式（Proxy）

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



代理模式中的角色：

抽象主题角色（Subject）：声明了目标对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。

具体主题角色（RealSubject)：也称为委托角色或者被代理角色。定义了代理对象所代表的目标对象。

代理主题角色（Proxy)：也叫委托类、代理类。代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象。

 代理模式又分为静态代理和动态代理。静态代理是由程序猿创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。动态代理是在程序运行时，通过运用反射机制动态的创建而成。

静态代理

案例：

1 Subject

public interface Subject
{
void operate();
}

2 RealSubject

public class RealSubject implements Subject
{
@Override
public void operate()
{
System.out.println("RealSubject");
}
}

3 Proxy

public class Proxy implements Subject
{
private Subject subject = null;

@Override
public void operate()
{
if(subject == null)
subject = new RealSubject();
System.out.print("I'm Proxy, I'm invoking...");
this.subject.operate();
}
}

4 测试代码

Subject subject = new Proxy();
subject.operate();

输出：I’m Proxy, I’m invoking…RealSubject

 从上面例子可以看出代理对象将客户端的调用为派给目标对象，在调用目标对象的方法之前和之后都可以执行特定的操作。

动态代理

 动态代理是指在运行时，动态生成代理类。即，代理类的字节码将在运行时生成并载入当前的ClassLoader。与静态代理类想比，动态类有诸多好处。首先，不需要为真是主题写一个形式上完全一样的封装类，假如主题接口中的方法很多，为每一个接口写一个代理方法也是非常烦人的事，如果接口有变动，则真实主题和代理类都要修改，不利于系统维护；其次，使用一些动态代理的生成方法甚至可以在运行时指定代理类的执行逻辑，从而大大提升系统的灵活性。

Jdk动态代理

 Jdk的动态代理是基于接口的。现在想要为RealSubject这个类创建一个动态代理对象，Jdk主要会做一下工作：

获取RealSubject上的所有接口列表

确定要生成的代理类的类名，默认为：com.sun.proxy.$ProxyXXXX；

根据需要实现的接口信息，在代码中动态创建该Proxy类的字节码；

将对应的字节码转换为对于的class对象；

创建InvocationHandler实例handler,用来处理Proxy所有方法的调用；

Proxy的class对象以创建的handler对象为参数，实例化一个proxy对象；

 Jdk通过java.lang.reflect.Proxy包来支持动态代理，在Java中要创建一个代理对象，必须调用Proxy类的静态方法newProxyInstance，该方法的原型如下：

Object Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) throws IllegalArgumentException

 其中：

loader，表示类加载器，对于不同来源（系统库或网络等）的类需要不同的类加载器来加载，这是Java安全模型的一部分。可以使用null来使用默认的加载器；

interfaces，表示接口或对象的数组，它就是前述代理对象和真实对象都必须共有的父类或者接口；

handler，表示调用处理器，它必须是实现了InvocationHandler接口的对象，其作用是定义代理对象中需要执行的具体操作。

 InvocationHandler之于Proxy，就如Runnable之于Thread。InvocationHandler接口中只有一个方法invoke，它的作用就跟Runnable中的run方法类似，定义了代理对象在执行真实对象的方法时所希望执行的动作。其原型如下：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

 其中：

proxy，表示执行这个方法的代理对象；

method，表示真实对象实际需要执行的方法（关于Method类参见Java的反射机制）；

args，表示真实对象实际执行方法时所需的参数。

 在实际的编程中，需要优先定义一个实现InvocationHandler接口的调用处理器对象，然后将它作为创建代理类实例的参数。（抑或在调用newProxyInstance方法时使用匿名内部类。）这样就得到了代理对象。

 真实对象本身的实例化在调用处理器对象内部完成，实例化时需要的参数也应该及时传入调用处理器对象中。这样一来就完成了代理对象对真实对象的包装，而代理对象需要执行的额外操作也在invoke方法中处理。

 其后，在客户端中，如果需要使用真实对象时，就可以用代理对象来替代它了（有时需要类型强制转化）。

案例：（修改代理类Proxy）

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

public class ProxyHandler implements InvocationHandler
{
Object obj = null;

public Object newProxyInstance(Object realObj){
this.obj = realObj;
Class<?> classType = this.obj.getClass();
return Proxy.newProxyInstance(classType.getClassLoader(), classType.getInterfaces(), this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
System.out.print("I'm Proxy, I'm invoking...");
method.invoke(obj, args);
System.out.println("invoke end!");
return null;
}
}

测试代码：

Subject subject = (Subject) new ProxyHandler().newProxyInstance(new RealSubject());
subject.operate();

输出结果：

I'm Proxy, I'm invoking...RealSubject
invoke end!

 动态代理模式通过使用反射，可以在运行期决定加载哪个类，避免了一个类对应一个代理的问题；同时，通过统一的invoke方法，统一了代理类对原函数的处理过程，使用动态代理很大程度上减少了重复的代码，降低了维护的复杂性和成本。

稍微修改一下代码：

1 Subject

public interface Subject
{
String operate1();
String operate2();
String operate3();
String operate4();
String operate5();
}

2 RealSubject

public class RealSubject1 implements Subject
{
@Override
public String operate1()
{
return "RealSubject-operate1()";
}

@Override
public String operate2()
{
return "RealSubject-operate2()";
}

@Override
public String operate3()
{
return "RealSubject-operate3()";
}

@Override
public String operate4()
{
return "RealSubject-operate4()";
}

@Override
public String operate5()
{
return "RealSubject-operate5()";
}
}

public class RealSubject2 implements Subject
{
@Override
public String operate1()
{
return "RealSubject2-operate1()";
}

@Override
public String operate2()
{
return "RealSubject2-operate2()";
}

@Override
public String operate3()
{
return "RealSubject2-operate3()";
}

@Override
public String operate4()
{
return "RealSubject2-operate4()";
}

@Override
public String operate5()
{
return "RealSubject2-operate5()";
}
}

3 Proxy

public class ProxyHandler implements InvocationHandler
{
Object obj = null;

public Object newProxyInstance(Object realObj){
this.obj = realObj;
Class<?> classType = this.obj.getClass();
return Proxy.newProxyInstance(classType.getClassLoader(), classType.getInterfaces(), this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
System.out.print("I'm Proxy, I'm invoking...");
Object object = method.invoke(obj, args);
System.out.println(object);
return object;
}
}

4 测试代码

Subject object = new RealSubject();
Subject subject = (Subject) new ProxyHandler().newProxyInstance(new RealSubject());
Subject subject2 = (Subject) new ProxyHandler().newProxyInstance(new RealSubject2());
subject.operate2();
subject2.operate4();

输出：

I'm Proxy, I'm invoking...RealSubject-operate2()
I'm Proxy, I'm invoking...RealSubject2-operate4()

 这下可以明显的看到动态代理相比于静态代理的优势了吧。

 当在代码阶段规定了静态代理关系，Proxy类通过编译器编译成class文件，当系统运行时，此class已经存在了。这种静态的代理模式固然在访问无法访问的资源，增强现有接口的业务功能方面有很大的优点，但是大量使用这种静态代理，会是我们系统内的类的规模增大，并且不易维护；并且由于Proxy和RealSubject的功能本质上是相同的，Proxy只是起到了中介的左右，这种代理在系统中的存在，导致系统结构比较臃肿和松散。

CGLIB动态代理

 生成动态代理的方法很多，不止jdk自带的动态代理这一种，还有CGLIB,Javassist或者ASM。Jdk的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用jdk代理，这就要用到CGLIB代理了。CGLIB是针对类来实现的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

 CGLIB创建某个类A的动态代理类的模式是：

查找A上的所有非final的public类型的方法定义

将这些方法的定义转换成字节码

将组成的字节码转换成相应的代理的class对象

实现MethodInterceptor接口，用来处理对代理类上所有方法的请求（这个接口和Jdk动态代理InvocationHandler的功能和角色是一样的）

修改上面的案例（需要用到cglib-nodep-2.2.jar和asm.jar两个jar包，可以在这里下载，免费的哦）：

1 真实代理角色RealSubject

public class RealSubjectCglib
{
public String operate(){
return "RealSubjectCglib";
}
}

2 代理类

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class ProxyCglib implements MethodInterceptor
{
private Object target;

public Object getInstance(Object target)
{
this.target = target;
//Cglib中的加强器，用来创建动态代理
Enhancer enhancer = new Enhancer();
//设置要创建动态代理的类
enhancer.setSuperclass(this.target.getClass());
//设置回调，这里相当于是对于代理类上所有方法的调用，都会调用Callback，而Callback则需要实现intercept()方法进行拦截
enhancer.setCallback(this);
Object obj = enhancer.create();
return obj;
}

@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable
{
System.out.print("I'm Proxy, I'm invoking...");
Object object = proxy.invokeSuper(obj, args);
System.out.println(object);
return object;
}
}

测试代码：

ProxyCglib proxy = new ProxyCglib();
RealSubjectCglib cglib = (RealSubjectCglib)proxy.getInstance(new RealSubjectCglib());
cglib.operate();

输出结果：I’m Proxy, I’m invoking…RealSubjectCglib

代理模式的应用形式

1. 远程代理：即为一个对象在不同的地址空间提供局部代表，这样可以隐藏一个对象存在于不同地址空间的事实；

2. 虚拟代理：即根据需要创建开销很大的对象，通过它来存放实例化需要很长时间的真实对象；

3. 安全代理：用来控制真实对象访问时的权限；

4. 智能指引：即当调用真实对象时，代理处理另外一些事。



装饰模式和代理模式的区别

装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话 说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。

外观模式和代理模式的区别

代理与外观的主要区别在于，代理对象代表一个单一对象而外观对象代表一个子系统，代理的客户对象无法直接访问对象，由代理提供单独的目标对象的访问，而通常外观对象提供对子系统各元件功能的简化的共同层次的调用接口。代理是一种原来对象的代表，其他需要与这个对象打交道的操作都是和这个代表交涉的。

适配器模式和代理模式的区别

适配器模式改变所考虑的对象的接口，代理模式不能改变所代理对象的接口。

参考资料

1. 《23种设计模式》

2. 《细数JDK里的设计模式》

3. 《Java代理模式》

4. 《Java动态代理机制详解（JDK 和CGLIB，Javassist，ASM）》