Java代理模式详解及案例分析：静态代理/动态代理

标题：Java代理模式详解及案例分析：静态代理/动态代理

我们以几个问题，来开始我们今天的学习，如果下面几个问题，你都能说出个一二，那么恭喜你，你已经掌握了这方面的知识。

1，什么是代理模式？

2，Java中，静态代理与动态代理的区别？

3，Spring使用的是JDK的动态代理，还是CGLIB的动态代理？

4，JDK的动态代理的实现原理？

5，JDK的动态代理与CGLIB的动态代理的实现上，有何不同？

6，你知道的，还有其他动态代理技术吗？请简述实现原理。

OK，言归正传。



    Java的代理模式分为：静态代理和动态代理。首先我们需要搞清楚，什么是代理模式？注意，我们这里说的是JDK的代理模式。代理模式中，代

理类和委托类具有相同的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间

通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，

来提供特定的服务。

    说白了，JDK的代理模式，提供了另一种生成对象的方式。从程序结构上来说，JDK的代理模式，把代理类作为对象，代理代理类完成基本的功能，

并且增加了其他行为，我们可以在代理类执行之前（后），插入一段代码，完成其他的附加功能。我们可以把这种模式，看做是对生成对象的一种控制，

或者说是一种管理。Spring管理bean使用的就是动态代理。

    代理模式是23种设计模式之一，我们来回顾一下23种设计模式：

Factory（工厂模式）  

Builder（建造模式）  

Factory Method（工厂方法模式）  

Prototype（原始模型模式）  

Singleton（单例模式）  

Facade（门面模式）  

Adapter（适配器模式）  

Bridge（桥梁模式）  

Composite（合成模式）  

Decorator（装饰模式）  

Flyweight（享元模式）  

Proxy（代理模式）  

Command（命令模式）  

Interpreter（解释器模式）  

Visitor（访问者模式）  

Iterator（迭代子模式）  

Mediator（调停者模式）  

Memento（备忘录模式）  

Observer（观察者模式）  

State（状态模式）  

Strategy（策略模式）  

Template Method（模板方法模式）  

Chain Of Responsibleity（责任链模式）

    按照代理的创建时期，代理类可以分为：静态代理和动态代理。静态代理指的是，由程序员创建或特定工具自动生成源代码，再对其进行编译。

在程序运行前，代理类的.class文件就已经存在了。动态代理指的是，在程序运行时，运用反射机制动态生成源代码，再对其进行编译。

    只看概念，比较抽象，我们下面来看一下代码示例。我们先来看一下静态代理的组成要素：

* 一个接口

* 一个接口实现类
* 一个代理类，也实现了接口，是增强版的实现类

/**
* @description 代理模式 之 静态代理 -- StaticProxyInterface接口
* @description 一个接口
*/
public interface StaticProxyInterface {
public void queryInfo();
}

/**
* @description 代理模式 之 静态代理 -- StaticProxyImpl实现类
* @description StaticProxyImpl，在代理模式中，叫做委托类，包含业务逻辑
* @description 一个接口实现类
*/
public class StaticProxyImpl implements StaticProxyInterface{
public void queryInfo() {
System.out.println("代理模式 之 静态代理 -- StaticProxyImpl实现类   查看信息...");
}
}

/**
* @description 代理模式 之 静态代理 -- StaticProxy代理类
* @description StaticProxy，在代理模式中，叫做代理类，增强StaticProxyImpl实现类
* @description 一个代理类，也实现了接口，是增强版的实现类
*/
public class StaticProxy  implements StaticProxyInterface{

private StaticProxyImpl staticProxyImpl;
public StaticProxy(StaticProxyImpl staticProxyImpl){
this.staticProxyImpl = staticProxyImpl;
}
public void queryInfo() {
// 事务处理之前，可以执行一段代码
System.out.println("事务处理之前...");
// 调用委托类的方法
staticProxyImpl.queryInfo();
// 事务处理之后，可以执行一段代码
System.out.println("事务处理之后...");
}
}

/**
* @description 代理模式 之 静态代理
* @description 测试类StaticProxyTest
* @description 什么是静态代理：静态代理指的是，由程序员创建或特定工具自动生成源代码，再对其进行编译。
* 在程序运行前，代理类的.class文件就已经存在了。
* @description 静态代理组成要素:
* 1,一个接口
* 2，一个接口实现类
* 3，一个代理类，也实现接口，是增强版的接口实现类
*/
public class StaticProxyTest {
public static void main(String[] args){
StaticProxyImpl staticProxyImpl = new StaticProxyImpl();
StaticProxy staticProxy = new StaticProxy(staticProxyImpl);
staticProxy.queryInfo();
}
/*
*     静态代理的一个缺点就是：我们需要为每一个接口生成一个代理类，也就是一个接口必然要对应一个代理类。这样
* 必然会生成很多的代理类，并且这些代理类的代码有很多重复的部分。解决这一问题，最好的办法就是通过一个代理类
* 完成全部的代理功能，此时就要使用动态代理。
*/
}

    动态代理又可以分为2种：JDK的动态代理和CGLIB的动态代理，JDK的动态代理依赖具体的接口，需要绑定接口，如果一个类没有实现接口，

则不能使用JDK的动态代理。CGLIB的动态代理不依赖具体的接口，功能更加强大。下面我们分别进行说明，JDK的动态代理的关键是

InvocationHandler接口，先来看JDK的动态代理：

/**
* @description 代理模式 之 JDK的动态代理 -- DynamicProxyInterface接口
* @description 一个接口
*/
public interface DynamicProxyInterface {
public void queryInfo();
}

/**
* @description 代理模式 之 JDK的动态代理 -- DynamicProxyImpl实现类
* @description DynamicProxyImpl，在代理模式中，叫做委托类，包含业务逻辑
* @description 一个接口实现类
*/
public class DynamicProxyImpl implements DynamicProxyInterface {

public void queryInfo() {
// TODO Auto-generated method stub
System.out.println("代理模式 之 JDK的动态代理 -- DynamicProxyImpl实现类   查看信息...");
}
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @description 代理模式 之 JDK的动态代理 -- DynamicProxy代理类
* @description DynamicProxy，在代理模式中，叫做代理类，增强DynamicProxyImpl实现类
* @description 一个代理类，实现了InvocationHandler接口
* @description JDK的动态代理 与 静态代理的区别就在这个代理类，静态代理类直接实现接口，而JDK的动态代理类不
* 直接实现具体的接口，而是实现了JDK提供的InvocationHandler接口。
*/
public class DynamicProxy implements InvocationHandler {
// 目标实现类，也就是某个接口的实现类，这里的target_interface_implements，可以看做是一种抽象
private Object target_interface_implements;
// 带参数构造方法，把目标实现类的对象作为参数传递进去，这里不是覆盖具体某个实现类的构造方法，而是抽象出来一个方法
public Object dynamicBindImplToProxyClass(Object target_interface_implements){
this.target_interface_implements = target_interface_implements;
// 取得代理对象
return Proxy.newProxyInstance(target_interface_implements.getClass().getClassLoader(),
target_interface_implements.getClass().getInterfaces(), this);
// JDK的动态代理依赖具体的接口，需要绑定接口，如果一个类没有实现接口，则不能使用JDK的动态代理
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
Object result = null;
// 事务处理之前，可以执行一段代码
System.out.println("事务处理之前...");
// 执行方法
result = method.invoke(target_interface_implements, args);
// 事务处理之后，可以执行一段代码
System.out.println("事务处理之后...");
return result;
}
}

package com.ebank.action;
/**
* @description 代理模式 之 JDK的动态代理
* @description 测试类DynamicProxyTest
* @description 动态代理指的是，在程序运行时，运用反射机制动态生成源代码，再对其进行编译。
* @description JDK的动态代理组成要素:
* 1,一个接口
* 2，一个接口实现类
* 3，一个代理类，实现了InvocationHandler接口
*/
public class DynamicProxyTest {
public static void main(String[] args){
DynamicProxy dynamicProxy = new DynamicProxy();
DynamicProxyInterface dynamicProxyForImpl = (DynamicProxyInterface) dynamicProxy.dynamicBindImplToProxyClass(new DynamicProxyImpl());
dynamicProxyForImpl.queryInfo();
}
/*
*    JDK的动态代理依靠具体的接口，如果有些类并没有实现，则不能使用JDK的动态代理，这时候就需要
* 使用CGLIB的动态代理
* // JDK的动态代理的关键是InvocationHandler接口
*/
}

    接下来我们来分析一下JDK的动态代理的实现原理，JDK实现的动态代理，我们可以狭义的理解为，通过实现InvocationHandler接口，而实现的

动态代理。JDK的动态代理的实现需要依赖接口。拿上面的JDK的动态代理的示例代码来说，DynamicProxyImpl这个类，必须要实现某个接口，才

能借助InvocationHandler来实现动态代理，因为Proxy.newProxyInstance()这个方法中，需要传入代理类的接口作为参数。在示例中，我们的

DynamicProxyImpl类实现了DynamicProxyInterface接口。我们实现首先来看InvocationHandler接口的源代码：

package java.lang.reflect;
public interface InvocationHandler {
/**
* Processes a method invocation on a proxy instance and returns the result.  This method will be invoked on an invocation
* handler when a method is invoked on a proxy instance that it is associated with.
* Processes ： 处理，加工，审核
* @param   proxy--the proxy instance that the method was invoked on
*
* @param   method--the Method instance corresponding to the interface method invoked on the proxy instance.  The declaring
* class of the Method object will be the interface that the method was declared in, which may be a
* superinterface of the proxy interface that the proxy class inherits the method through.
*
* @param   args--an array of objects containing the values of the arguments passed in the method invocation on the proxy
* instance, or null if interface method takes no arguments.Arguments of primitive types are wrapped in instances of the
* appropriate primitive wrapper class, such as Integer or Boolean.
* primitive ： 简单的，这里个人理解为基本的，primitive type 意为基本数据类型
* @return  the value to return from the method invocation on the proxy instance.  If the declared return type of the interface
* method is a primitive type, then the value returned by this method must be an instance of the corresponding primitive
* wrapper class; otherwise, it must be a type assignable to the declared return type.  If the value returned by this method is
* null and the interface method's return type is primitive, then a NullPointerException will be
* thrown by the method invocation on the proxy instance.  If the value returned by this method is otherwise not compatible with
* the interface method's declared return type as described above, a ClassCastException will be thrown by the method
* invocation on the proxy instance.
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

    然后，我们来看CGLIB的动态代理，CGLIB的动态代理的关键是MethodInterceptor接口，这个接口位于：net.sf.cglib.proxy.MethodInterceptor

/**
* @description 代理模式 之 CGLIB的动态代理 -- CglibDynamicProxyImpl类
* @description CglibDynamicProxyImpl，在代理模式中，叫做委托类，包含业务逻辑
* @description 一个没有实现接口的类
*/
public class CglibDynamicProxyImpl {
public void queryInfo() {
// TODO Auto-generated method stub
System.out.println("代理模式 之 CGLIB的动态代理 -- CglibDynamicProxyImpl类   查看信息...");
}
}

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
* @description 代理模式 之 CGLIB的动态代理 -- CglibDynamicProxy代理类
* @description CglibDynamicProxy，在代理模式中，叫做代理类，增强DynamicProxyImpl实现类
* @description 一个代理类，实现了MethodInterceptor接口
* @description CGLIB的动态代理 与 静态代理的区别就在这个代理类，静态代理类直接实现接口，而CGLIB的动态代理类不
* 直接实现具体的接口，而是实现了MethodInterceptor接口。
*/
public class CglibDynamicProxy implements MethodInterceptor {
// 目标实现类，也就是某个接口的实现类，这里的target_interface_implements，可以看做是一种抽象
private Object target_class;
// 创建代理对象
public Object getInstance(Object target_class){
this.target_class = target_class;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.target_class.getClass());
// 回调方法
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}
// 回调方法
public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy proxy) throws Throwable {
// 事务处理之前，可以执行一段代码
System.out.println("事务处理之前...");
// 执行方法
proxy.invokeSuper(arg0, arg2);
// 事务处理之后，可以执行一段代码
System.out.println("事务处理之后...");
return null;
}
}

/**
* @description 代理模式 之 CGLIB的动态代理
* @description 测试类CglibDynamicProxyTest
* @description 动态代理指的是，在程序运行时，运用反射机制动态生成源代码，再对其进行编译。
* @description CGLIB的动态代理组成要素:
* 1，一个类
* 2，一个代理类，实现了MethodInterceptor接口
*/
public class CglibDynamicProxyTest {

public static void main(String[] args){
CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy();
CglibDynamicProxyImpl cglibDynamicProxyImpl = (CglibDynamicProxyImpl) cglibDynamicProxy.getInstance(new CglibDynamicProxyImpl());
cglibDynamicProxyImpl.queryInfo();
}
// CGLIB的动态代理的关键是MethodInterceptor接口
}

    CGLIB实现的动态代理，要求委托类不能被final关键字修饰，因为在运行期间，通过Java的反射机制，会生成委托类的子类。我们都知道，一个

类，一旦被final关键字修饰，那么这个类就不能被继承。假如我们使用final关键字修饰了委托类，编译期间不会报错，但是程序运行时，会报错：

不能继承final类，如下：

Exception in thread "main" java.lang.IllegalArgumentException: Cannot subclass final class class com.yangcq.CglibDynamicProxyImpl
at net.sf.cglib.proxy.Enhancer.generateClass(Enhancer.java:446)
at net.sf.cglib.core.DefaultGeneratorStrategy.generate(DefaultGeneratorStrategy.java:25)
at net.sf.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:216)
at net.sf.cglib.proxy.Enhancer.createHelper(Enhancer.java:377)
at net.sf.cglib.proxy.Enhancer.create(Enhancer.java:285)
at com.ebank.action.CglibDynamicProxy.getInstance(CglibDynamicProxy.java:24)
at com.ebank.action.CglibDynamicProxyTest.main(CglibDynamicProxyTest.java:14)

    CGLIB的动态代理的实现原理是什么样的呢？CGLIB为我们提供了MethodInterceptor接口，我们不需要依赖某个接口，也就是说，即使代理类没有

实现任何接口，也是可以借助CGLIB来实现动态代理的。CGLIB是借助Java反射机制，在运行期间为代理类生成一个子类，通过子类，来完成父类的动

态代理。下面我们来看一下MethodInterceptor的源代码：

package net.sf.cglib.proxy;
import java.lang.reflect.Method;
public abstract interface MethodInterceptor extends Callback{
public abstract Object intercept(Object paramObject, Method paramMethod, Object[] paramArrayOfObject,
MethodProxy paramMethodProxy) throws Throwable;
}

    实现动态代理，我们需要关注一个关键的类：public class Proxy implements java.io.Serializable

Proxy的源代码

package java.lang.reflect;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import sun.misc.ProxyGenerator;
public class Proxy implements java.io.Serializable {

private static final long serialVersionUID = -2222568056686623797L;
private final static String proxyClassNamePrefix = "$Proxy";
private final static Class[] constructorParams = { InvocationHandler.class };
private static Map loaderToCache = new WeakHashMap();
private static Object pendingGenerationMarker = new Object();
private static long nextUniqueNumber = 0;
private static Object nextUniqueNumberLock = new Object();
private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap());
protected InvocationHandler h;
// 私有构造函数，不允许程序员通过构造函数来实例化Proxy，生成Proxy的实例，需要调用newProxyInstance方法
private Proxy() {
}
// 受保护的构造函数，这个函数也不允许程序员直接调用
protected Proxy(InvocationHandler h) {
this.h = h;
}

public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) throws IllegalArgumentException{
// 这行代码，可以说明，在Class类文件的数据结构中，接口interfaces占用2个字节，最大值65535
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
Class proxyClass = null;
String[] interfaceNames = new String[interfaces.length];
// Set是无序，不可重复的集合
Set interfaceSet = new HashSet();
for (int i = 0; i < interfaces.length; i++) {
String interfaceName = interfaces[i].getName();
Class interfaceClass = null;
try {
// 通过接口名称和类加载器，获得接口实现类
interfaceClass = Class.forName(interfaceName, false, loader);
}
catch (ClassNotFoundException e) {
}
if (interfaceClass != interfaces[i]) {
throw new IllegalArgumentException(interfaces[i] + " is not visible from class loader");
}
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(interfaceClass.getName() + " is not an interface");
}
if (interfaceSet.contains(interfaceClass)) {
throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());
}
interfaceSet.add(interfaceClass);
interfaceNames[i] = interfaceName;
}
Object key = Arrays.asList(interfaceNames);
Map cache;
synchronized (loaderToCache) {
cache = (Map) loaderToCache.get(loader);
if (cache == null) {
cache = new HashMap();
loaderToCache.put(loader, cache);
}
}
synchronized (cache) {
do {
Object value = cache.get(key);
if (value instanceof Reference) {
proxyClass = (Class) ((Reference) value).get();
}
if (proxyClass != null) {
return proxyClass;
}
else if (value == pendingGenerationMarker) {
try {
cache.wait();
}
catch (InterruptedException e) {
}
continue;
}
else {
cache.put(key, pendingGenerationMarker);
break;
}
} while (true);
}
try {
String proxyPkg = null;
for (int i = 0; i < interfaces.length; i++) {
int flags = interfaces[i].getModifiers();
if (!Modifier.isPublic(flags)) {
String name = interfaces[i].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) {
proxyPkg = "";
}
{
long num;
synchronized (nextUniqueNumberLock) {
num = nextUniqueNumber++;
}
String proxyName = proxyPkg + proxyClassNamePrefix + num;
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
try {
proxyClass = defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
}
catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
proxyClasses.put(proxyClass, null);
}
finally {
synchronized (cache) {
if (proxyClass != null) {
cache.put(key, new WeakReference(proxyClass));
}
else {
cache.remove(key);
}
cache.notifyAll();
}
}
return proxyClass;
}

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
throws IllegalArgumentException{
if (h == null) {
throw new NullPointerException();
}
// 获得代理类，需要传递2个参数，类加载器和接口
Class cl = getProxyClass(loader, interfaces);
try {
// 获得代理类的构造函数
Constructor cons = cl.getConstructor(constructorParams);
// 通过构造函数，生成实例对象
return (Object) cons.newInstance(new Object[] { h });
}
catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
}
catch (IllegalAccessException e) {
throw new InternalError(e.toString());
}
catch (InstantiationException e) {
throw new InternalError(e.toString());
}
catch (InvocationTargetException e) {
throw new InternalError(e.toString());
}
}

public static boolean isProxyClass(Class<?> cl) {
if (cl == null) {
throw new NullPointerException();
}
return proxyClasses.containsKey(cl);
}

public static InvocationHandler getInvocationHandler(Object proxy) throws IllegalArgumentException{
if (!isProxyClass(proxy.getClass())) {
throw new IllegalArgumentException("not a proxy instance");
}
Proxy p = (Proxy) proxy;
return p.h;
}
private static native Class defineClass0(ClassLoader loader, String name, byte[] b, int off, int len);
}

OK ，我们来回顾一下，开篇提出的几个问题：

1，什么是代理模式？

2，Java中，静态代理与动态代理的区别？

3，Spring使用的是JDK的动态代理，还是CGLIB的动态代理？

4，JDK的动态代理的实现原理？

5，JDK的动态代理与CGLIB的动态代理的实现上，有何不同？

6，你知道的，还有其他动态代理技术吗？请简述实现原理。