代理
代理是英文Proxy翻译过来的。我们在生活中见到的代理，最常见的就是朋友圈中买面膜的同学了。他们从厂商拿货，然后在朋友圈中宣传，然后卖给熟人。
代理模式
以上上常见代理模式的UML示意图。
需要注意的有下面几点：
- 用户只关心接口功能，而不在乎谁提供了功能。上图中接口是Subject。
- 接口真正实现者是上图的RealSubject，但是它不与用户直接接触，而是通过代理。
- 代理就是上图中的Proxy，由于它实现了Subject接口，所有它能够直接与用户接触。
- 用户调用Proxy的时候，Proxy内部调用了RealSubject。所以，Proxy是中介者，它可以增加RealSubject操作。
如果难于理解的话，用事例说明好了。值得注意的是，代理可以分为静态代理和动态代理两种。先从静态代理讲起。
静态代理
我们平常去电影院看电影的时候，在电影开始阶段是不是经常放广告呢？
电影是电影公司委托给影院进行播放的，但是影院可以在播放电影的时候，产生一些自己的经济收益，比如卖爆米花、可乐等，然后在影片开始结束时播放一些广告。
现在用代码来进行模拟。
首先得有一个接口，通用的接口是代理模式实现的基础。这个接口我们命名为Movie，代表电影播放的能力。
public interface Movie {
void play();
}
然后，我们要有一个真正的实现这个Movie接口的类，和一个只是实现接口的代理类。
public class RealMovie implements Movie {
@Override
public void play() {
System.out.println("您正在观看电影 《肖申克的救赎》");
}
}
这个表示真正的影片。它实现了Movie接口，play()方法调用时，影片就开始播放。那么Proxy代理呢？
public class Cinema implements Movie {
RealMovie movie;
public Cinema(RealMovie movie) {
this.movie = movie;
}
@Override
public void play() {
guanggao(true);
movie.play();
guanggao(false);
}
public void guanggao(boolean isStart) {
if (isStart) {
System.out.println("电影马上开始了，爆米花、可乐、口香糖9.8折，快来买啊！");
} else {
System.out.println("电影马上结束了，爆米花、可乐、口香糖9.8折，买回家吃吧！");
}
}
}
Cinema就是Proxy代理对象，它有一个paly()方法。不过调用play()方法时，它进行了一些相关利益的处理，那就是广告。现在我们编写测试代码。
public class ProxyTest {
public static void main(String[] args) {
RealMovie realMovie = new RealMovie();
Movie movie = new Cinema(realMovie);
movie.play();
}
}
运行结果：
电影马上开始了，爆米花、可乐、口香糖9.8折，快来买啊！
您正在观看电影 《肖申克的救赎》
电影马上结束了，爆米花、可乐、口香糖9.8折，买回家吃吧！
现在可以看到，代理模式可以在不修改被代理对象的基础上，通过拓展代理类，进行一些功能的附加与增强。值得注意的时，代理和被代理类应该共同实现一个接口，或者是共同继承某各类。
上面介绍的是静态代理的内容，为什么叫做静态代理呢？因为它的类型是事先预定好的，比如上面代码中的Cinema这个类。下面介绍的内容就是动态代理。
动态代理
既然是代理，那么它与静态代理的功能和目的是没有区别的，唯一有区别的就是静态和动态的差别。
那么在动态代理中这个动态体现在什么地方？
上一节代码中Cinema类时代理，我们需要手动编写代码让Cinema实现Movie接口，而在动态代理中，我们可以让程序在运行的时候自动在内存中创建一个实现Movie接口的代理，而不需要去定义Cinema这个类。这就是它被称为动态的原因。
也许概念比较抽象。现在实例说明一下。
假设有一个大商场，商场有很多的柜台，有一个柜台卖茅台酒。我们进行代码的模拟。
public interface SellWine {
void maijiu();
}
SellWine是一个接口，可以理解它是卖酒的许可证。
public class MaotaiJiu implements SellWine{
@Override
public void maijiu() {
System.out.println("我卖得是茅台酒。");
}
}
然后创建一个类MaotaiJiu，是的，就是茅台酒的意思。
我们还需要一个柜台来卖酒：
public class GuitaiA implements InvocationHandler {
private Object pingpai;
public GuitaiA(Object pingpai) {
this.pingpai = pingpai;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("销售开始 柜台是：" + this.getClass().getSimpleName());
method.invoke(pingpai, args);
System.out.println("销售结束");
return null;
}
}
GuitaiA实现了InvocationHandler这个类，这个类是什么意思呢？不要慌张，待会儿解释。然后，我们就开始卖酒了。
public class Test {
public static void main(String[] args) {
MaotaiJiu maotaiJiu = new MaotaiJiu();
InvocationHandler jingshao1 = new GuitaiA(maotaiJiu);
SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
MaotaiJiu.class.getInterfaces(), jingshao1);
dynamicProxy.maijiu();
}
}
这里，我们有接触到了一个新的概念，没有关系，先别管，先看结果。
销售开始 柜台是：GuitaiA
我卖得是茅台酒。
销售结束
看到没有，我们并没有像静态代理那样为SellWine接口实现一个代理类，但最终它仍然实现了相同的功能，这其中的差别，就是之前讨论的动态代理所谓“动态”的原因。
动态代理语法
下面开始讲语法，语法非常简单。
动态代理涉及了一个非常重要的类Proxy。正是通过Proxy的静态方法newProxyInstance才会动态创建代理。
Proxy
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
下面讲解它的3个参数意义：
- loader自然是类加载器
- interfaces 代码要用来代理的接口
- h 一个InvocationHandler对象
初学者应该对于InvocationHandler很陌生，马上就讲到这一块。
InvocationHandler
InvocationHandler是一个接口，官方文档解释说，每个代理的实例都有一个与之关联的InvocationHandler实现类，如果代理的方法被调用，那么代理便会通知和转发内部的InvocationHandler实现类，由它去决定处理。
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable;
}
InvocationHandler内部只是一个invoke()方法，正是这个方法决定了怎么处理代理传递过来的方法调用。
- proxy 代理对象
- method 代理对象调用的方法
- args 调用的方法中的参数
因为，Proxy动态产生的代理会调用InvocationHandler实现类，所以InvocationHandler是实际执行者。
public class GuitaiA implements InvocationHandler {
private Object pingpai;
public GuitaiA(Object pingpai) {
this.pingpai = pingpai;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("销售开始 柜台是：" + this.getClass().getSimpleName());
method.invoke(pingpai, args);
System.out.println("销售结束");
return null;
}
}
GuitaiA 就是实际上卖酒的地方。
现在，加大难度，不仅卖茅台酒，还想买五粮液。
public class Wuliangye implements SellWine{
@Override
public void maijiu() {
System.out.println("我卖得是五粮液。");
}
}
Wuliangye 这个类也实现了SellWine这个接口，说明它也拥有卖酒的许可证，同样把它放到GuitaiA 上售卖。
public class Test2 {
public static void main(String[] args) {
MaotaiJiu maotaiJiu = new MaotaiJiu();
Wuliangye wuliangye = new Wuliangye();
InvocationHandler jingxiao1 = new GuitaiA(maotaiJiu);
InvocationHandler jingxiao2 = new GuitaiA(wuliangye);
SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(), MaotaiJiu.class.getInterfaces(), jingxiao1);
SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),MaotaiJiu.class.getInterfaces(), jingxiao2);
dynamicProxy.maijiu();
dynamicProxy1.maijiu();
}
}
结果：
销售开始 柜台是：GuitaiA
我卖得是茅台酒。
销售结束
销售开始 柜台是：GuitaiA
我卖得是五粮液。
销售结束
有人会问，dynamicProxy 和dynamicProxy1什么区别都没有？他们都是动态产生的代理，都是售货员，都拥有卖酒的技术证书。
现在扩大商场的经营，除了卖酒之外，还要卖烟。
首先，同样要创建一个接口，作为卖烟的许可证。
public interface SellCigarette {
void cell();
}
然后，卖什么烟呢？我是江苏人，那就买黄南京。
public class YellowNanJing implements SellCigarette{
@Override
public void cell() {
System.out.println("售卖的是正宗的黄南京，可以扫描条形码查证。");
}
}
然后再次测试验证：
public class Test3 {
public static void main(String[] args) {
MaotaiJiu maotaiJiu = new MaotaiJiu();
Wuliangye wuliangye = new Wuliangye();
YellowNanJing yellowNanJing = new YellowNanJing();
InvocationHandler jingxiao1 = new GuitaiA(maotaiJiu);
InvocationHandler jingxiao2 = new GuitaiA(wuliangye);
InvocationHandler jingxiao3 = new GuitaiA(yellowNanJing);
SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(), MaotaiJiu.class.getInterfaces(), jingxiao1);
SellWine dynamicProxy2 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(), MaotaiJiu.class.getInterfaces(), jingxiao2);
dynamicProxy1.maijiu();
dynamicProxy2.maijiu();
SellCigarette dynamicProxy3 = (SellCigarette) Proxy.newProxyInstance(YellowNanJing.class.getClassLoader(), YellowNanJing.class.getInterfaces(), jingxiao3);
dynamicProxy3.cell();
}
}
结果：
销售开始 柜台是：GuitaiA
我卖得是茅台酒。
销售结束
销售开始 柜台是：GuitaiA
我卖得是五粮液。
销售结束
销售开始 柜台是：GuitaiA
售卖的是正宗的黄南京，可以扫描条形码查证。
销售结束
结果符合预期。大家仔细观察一下代码，同样是通过Proxy.newProxyInstance()方法，却产生了SellWine 和 SellCigarette 两种接口的实现类代理，这就是动态代理的魔力。
动态代理的秘密
一定有人对于为什么Proxy能够动态产生不同接口类型的代理感兴趣，我的猜测肯定是通过传入进去的接口通过反射动态生成一个接口实例。
比如SellWine是一个接口，那么Proxy.newProxyInstance()内部肯定有new SellWine();这样相同作用的代码，不过它是通过反射机制创建的。那事实是不是这样子的呢？直接查看他们的源码就好了。需要说明的是，当前版本是1.8。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
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);
}
}
newProxyInstance 的确创建了一个实例，它是通过 cl 这个 Class 文件的构造方法反射生成。cl 由 getProxyClass0() 方法获取。
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
}
直接通过缓存获取，如果获取不到，注释说会通过 ProxyClassFactory 生成。
/**
* A factory function that generates, defines and returns the proxy class given
* the ClassLoader and array of interfaces.
*/
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// Proxy class 的前缀是 “$Proxy”，
private static final String proxyClassNamePrefix = "$Proxy";
// next number to use for generation of unique proxy class names
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
/*
* Verify that the class loader resolves the name of this
* interface to the same Class object.
*/
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
/*
* Verify that the Class object actually represents an
* interface.
*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
/*
* Verify that this interface is not a duplicate.
*/
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package. Verify that
* all non-public proxy interfaces are in the same package.
*/
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) {
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
* A ClassFormatError here means that (barring bugs in the
* proxy class generation code) there was some other
* invalid aspect of the arguments supplied to the proxy
* class creation (such as virtual machine limitations
* exceeded).
*/
throw new IllegalArgumentException(e.toString());
}
}
}
这个类的注释说，通过指定的 ClassLoader 和 接口数组 用工厂方法生成 proxy class。 然后这个 proxy class 的名字是：
// Proxy class 的前缀是 “$Proxy”，
private static final String proxyClassNamePrefix = "$Proxy";
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
所以，动态生成的代理类名称是包名+$Proxy+id序号。
生成的过程，核心代码如下：
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
以上没有深究。只要知道，动态创建代理这回事就好了。
现在我们还需要做一些验证，要检测一下动态生成的代理类的名字是不是包名+$Proxy+id序号。
public class Test4 {
public static void main(String[] args) {
MaotaiJiu maotaiJiu = new MaotaiJiu();
Wuliangye wuliangye = new Wuliangye();
YellowNanJing yellowNanJing = new YellowNanJing();
InvocationHandler jingxiao1 = new GuitaiA(maotaiJiu);
InvocationHandler jingxiao2 = new GuitaiA(wuliangye);
InvocationHandler jingxiao3 = new GuitaiA(yellowNanJing);
SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(), MaotaiJiu.class.getInterfaces(), jingxiao1);
SellWine dynamicProxy2 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(), MaotaiJiu.class.getInterfaces(), jingxiao2);
dynamicProxy1.maijiu();
dynamicProxy2.maijiu();
SellCigarette dynamicProxy3 = (SellCigarette) Proxy.newProxyInstance(YellowNanJing.class.getClassLoader(), YellowNanJing.class.getInterfaces(), jingxiao3);
dynamicProxy3.cell();
System.out.println("dynamicProxy1 class name:" + dynamicProxy1.getClass().getName());
System.out.println("dynamicProxy2 class name:" + dynamicProxy2.getClass().getName());
System.out.println("dynamicProxy3 class name:" + dynamicProxy3.getClass().getName());
}
}
结果
销售开始 柜台是：GuitaiA
我卖得是茅台酒。
销售结束
销售开始 柜台是：GuitaiA
我卖得是五粮液。
销售结束
销售开始 柜台是：GuitaiA
售卖的是正宗的黄南京，可以扫描条形码查证。
销售结束
dynamicProxy1 class name:com.sun.proxy.$Proxy0
dynamicProxy2 class name:com.sun.proxy.$Proxy0
dynamicProxy3 class name:com.sun.proxy.$Proxy1
SellWine接口的代理类名是：com.sun.proxy.$Proxy0
SellCigarette接口的代理类名是：com.sun.proxy.$Proxy1
这说明动态代理的 proxy class 与 Proxy这个类同一个包。
下面一张图让大家记住动态代理涉及到的角色。
红框中$Proxy0就是通过Proxy动态生成的。
$Proxy0实现了要代理的接口。
$Proxy0通过调用InvocationHandler来执行任务。
代理的作用
主要作用，还是在不修改被代理对象的源码上，进行功能的增强。
这在AOP面向切面编程领域经常见。
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
主要功能：日志记录，性能统计，安全控制，事务处理，异常处理等等。
总结
- 代理分为静态代理和动态代理两种。
- 静态代理，代理类需要自己编写代码写成。
- 动态代理，代理类通过Proxy.newInstance() 方法生成。
- 不管是静态代理还是动态代理，代理和被代理者都要实现两样接口，它们的实质是面向接口编程。
- 代理模式本质上的目的是增强现有代码的功能。
扫一扫
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
