代理模式是Java常见的设计模式之一。所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。
代理模式的定义：
为其他对象提供一种代理，以控制对这个对象的访问；
为其他对象提供一种代理以控制对这个对象的访问。代理对象起到中介作用，可去掉功能服务或增加额外的服务。
代理模式的分类：
远程代理模式：为不同地理的对象提供局域网代表对象（例子：通过远程代理可以监控各个店铺，使之可以直观的了解店里的情况）
虚拟代理：根据需要将资源消耗很大的对象进行延迟，真正需要的时候进行创建
保护代理：控制用户的访问权限
智能引用代理：提供对目标对象提供额外的服务（火车票代售处）
为什么要采用这种间接的形式来调用对象呢？一般是因为客户端不想直接访问实际的对象，或者访问实际的对象存在困难，因此通过一个代理对象来完成间接的访问。
在现实生活中，这种情形非常的常见，比如请一个律师代理来打官司。
下面例子的代码可以访问源码。欢迎star,欢迎fork
代理模式的UML图
从UML图中，可以看出代理类与真正实现的类都是继承了抽象的主题类，这样的好处在于代理类可以与实际的类有相同的方法，可以保证客户端使用的透明性。
代理模式的实现
代理模式可以有两种实现的方式，一种是静态代理类，另一种是各大框架都喜欢的动态代理。下面我们主要讲解一下这两种代理模式
静态代理
我们先看针对上面UML实现的例子，再看静态代理的特点。
Subject接口的实现
public interface Subject {
void visit();
}
实现了Subject接口的两个类：
public class RealSubject implements Subject {
private String name = "byhieg";
@Override
public void visit() {
System.out.println(name);
}
}
public class ProxySubject implements Subject{
private Subject subject;
public ProxySubject(Subject subject) {
this.subject = subject;
}
@Override
public void visit() {
subject.visit();
}
}
具体的调用如下：
public class Client {
public static void main(String[] args) {
ProxySubject subject = new ProxySubject(new RealSubject());
subject.visit();
}
}
通过上面的代理代码，我们可以看出代理模式的特点，代理类接受一个Subject接口的对象，任何实现该接口的对象，都可以通过代理类进行代理，增加了通用性。但是也有缺点，每一个代理类都必须实现一遍委托类（也就是realsubject）的接口，如果接口增加方法，则代理类也必须跟着修改。其次，代理类每一个接口对象对应一个委托对象，如果委托对象非常多，则静态代理类就非常臃肿，难以胜任。
动态代理
动态代理有别于静态代理，是根据代理的对象，动态创建代理类。这样，就可以避免静态代理中代理类接口过多的问题。动态代理是实现方式，是通过反射来实现的，借助Java自带的java.lang.reflect.Proxy,通过固定的规则生成。
其步骤如下：
编写一个委托类的接口，即静态代理的（Subject接口）
实现一个真正的委托类，即静态代理的（RealSubject类）
创建一个动态代理类，实现InvocationHandler接口，并重写该invoke方法
在测试类中，生成动态代理的对象。
第一二步骤，和静态代理一样，不过说了。第三步，代码如下：
public class DynamicProxy implements InvocationHandler {
private Object object;
public DynamicProxy(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = method.invoke(object, args);
return result;
}
}
第四步，创建动态代理的对象
Subject realSubject = new RealSubject();
DynamicProxy proxy = new DynamicProxy(realSubject);
ClassLoader classLoader = realSubject.getClass().getClassLoader();
Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new Class[]{Subject.class}, proxy);
subject.visit();
创建动态代理的对象，需要借助Proxy.newProxyInstance。该方法的三个参数分别是：
ClassLoader loader表示当前使用到的appClassloader。
Class<?>[] interfaces表示目标对象实现的一组接口。
InvocationHandler h表示当前的InvocationHandler实现实例对象。
关于动态代理的使用，我们就介绍到这里。关于动态代理的实现、借助非JDK库实现动态代理、以及他们的优缺点放到以后再介绍。
2018-11-29
静态代理的一些缺陷：
①代理类和被代理类实现了相同的接口，导致代码的重复，如果接口增加一个方法，那么除了被代理类需要实现这个方法外，代理类也要实现这个方法，增加了代码维护的难度。
②代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。
动态代理定义：
在程序运行期间根据需要动态创建代理类及其实例来完成具体的功能。（动态代理主要分为JDK动态代理和cglib动态代理两大类）。
动态代理Proxy.newProxyInstance()方法源码分析：
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
//首先，传入的处理器不能为空
Objects.requireNonNull(h);
//拷贝一份代理类的接口
final Class<?>[] intfs = interfaces.clone();
//安全检查，不太明白 - -
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
*/
//查询（在缓存中已经有）或生成指定的代理类的class对象。
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
* 用已经设置好的处理器调用其构造方法
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
//这里生成代理对象
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
JDK动态代理和CGLIB代理：
jdk代理的类必须实现某些接口，cglib的代理通过子类的方式实现代理