1 從靜態代理到動態代理
舉個例子，有些人到了適婚年齡，會被父母催婚。而現在在各種壓力之下，很多人都選擇晚婚晚育。於是著急的父母就開始到處為子女相親，比子女自己還著急。下面來看程式碼實現。建立頂層介面IPerson的程式碼如下。
public interface IPerson {
void findLove();
}
兒子張三要找物件，實現ZhangSan類。
public class ZhangSan implements IPerson {
public void findLove() {
System.out.println("兒子張三提出要求");
}
}
父親張老三要幫兒子張三相親，實現ZhangLaosan類。
public class ZhangLaosan implements IPerson {
private ZhangSan zhangsan;
public ZhangLaosan(ZhangSan zhangsan) {
this.zhangsan = zhangsan;
}
public void findLove() {
System.out.println("張老三開始物色");
zhangsan.findLove();
System.out.println("開始交往");
}
}
來看客戶端測試程式碼。
public class Test {
public static void main(String[] args) {
ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan());
zhangLaosan.findLove();
}
}
執行結果如下圖所示。
但是，上面的場景有個弊端，就是自己的父親只會幫自己的子女去物色物件，別人家的孩子是不會管的。但社會上這項業務發展成了一個產業，出現了媒婆、婚介所等，還有各種各樣的定製套餐。如果還使用靜態代理成本就太高了，需要一個更加通用的解決方案，滿足任何單身人士找物件的需求。這就由靜態代理升級到了動態代理。採用動態代理基本上只要是人（IPerson）就可以提供相親服務。動態代理的底層實現一般不用我們親自去實現，已經有很多現成的API。在Java生態中，目前普遍使用的是JDK自帶的代理和CGLib提供的類庫。首先基於JDK的動態代理支援來升級一下程式碼。
首先建立媒婆（婚介所）類JdkMeipo。
public class JdkMeipo implements InvocationHandler {
private IPerson target;
public IPerson getInstance(IPerson target){
this.target = target;
Class<?> clazz = target.getClass();
return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(this.target,args);
after();
return result;
}
private void after() {
System.out.println("雙方同意，開始交往");
}
private void before() {
System.out.println("我是媒婆，已經收集到你的需求，開始物色");
}
}
然後建立一個類ZhaoLiu。
public class ZhaoLiu implements IPerson {
public void findLove() {
System.out.println("符合趙六的要求");
}
public void buyInsure() {
}
}
最後客戶端測試程式碼如下。
public static void main(String[] args) {
JdkMeipo jdkMeipo = new JdkMeipo();
IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu());
zhaoliu.findLove();
}
執行結果如下圖所示。
2 三層架構中的靜態代理
小夥伴們可能會覺得還是不知道如何將代理模式應用到業務場景中，我們來看一個實際的業務場景。在分散式業務場景中，通常會對資料庫進行分庫分表，分庫分表之後使用Java操作時就可能需要配置多個資料來源，我們通過設定資料來源路由來動態切換資料來源。首先建立Order訂單類。
public class Order {
private Object orderInfo;
private Long createTime;
private String id;
public Object getOrderInfo() {
return orderInfo;
}
public void setOrderInfo(Object orderInfo) {
this.orderInfo = orderInfo;
}
public Long getCreateTime() {
return createTime;
}
public void setCreateTime(Long createTime) {
this.createTime = createTime;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
建立OrderDao持久層操作類。
public class OrderDao {
public int insert(Order order){
System.out.println("OrderDao建立Order成功!");
return 1;
}
}
建立IOrderService介面。
public interface IOrderService {
int createOrder(Order order);
}
建立OrderService實現類。
public class OrderService implements IOrderService {
private OrderDao orderDao;
public OrderService(){
//如果使用Spring，則應該是自動注入的
//為了使用方便，我們在構造方法中直接將orderDao初始化
orderDao = new OrderDao();
}
@Override
public int createOrder(Order order) {
System.out.println("OrderService呼叫orderDao建立訂單");
return orderDao.insert(order);
}
}
然後使用靜態代理，主要完成的功能是：根據訂單建立時間自動按年進行分庫。根據開閉原則，我們修改原來寫好的程式碼邏輯，通過代理物件來完成。建立資料來源路由物件，使用ThreadLocal的單例實現DynamicDataSourceEntry類。
//動態切換資料來源
public class DynamicDataSourceEntry {
//預設資料來源
public final static String DEFAULT_SOURCE = null;
private final static ThreadLocal<String> local = new ThreadLocal<String>();
private DynamicDataSourceEntry(){}
//清空資料來源
public static void clear() {
local.remove();
}
//獲取當前正在使用的資料來源名字
public static String get() {
return local.get();
}
//還原當前切換的資料來源
public static void restore() {
local.set(DEFAULT_SOURCE);
}
//設定已知名字的資料來源
public static void set(String source) {
local.set(source);
}
//根據年份動態設定資料來源
public static void set(int year) {
local.set("DB_" + year);
}
}
建立切換資料來源的代理類OrderServiceSaticProxy。
public class OrderServiceStaticProxy implements IOrderService {
private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
private IOrderService orderService;
public OrderServiceStaticProxy(IOrderService orderService){
this.orderService = orderService;
}
public int createOrder(Order order) {
before();
Long time = order.getCreateTime();
Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
System.out.println("靜態代理類自動分配到【DB_" + dbRouter + "】資料來源處理資料");
DynamicDataSourceEntry.set(dbRouter);
orderService.createOrder(order);
after();
return 0;
}
private void before(){
System.out.println("Proxy before method.");
}
private void after(){
System.out.println("Proxy after method.");
}
}
來看客戶端測試程式碼。
public static void main(String[] args) {
try {
Order order = new Order();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
Date date = sdf.parse("2017/02/01");
order.setCreateTime(date.getTime());
IOrderService orderService = new OrderServiceStaticProxy(new OrderService());
orderService.createOrder(order);
}catch (Exception e){
e.printStackTrace();;
}
}
執行結果如下圖所示。
由上圖可知，結果符合預期。再來回顧一下類圖，看是否與我們最先畫的一致，如下圖所示。
動態代理和靜態代理的基本思路是一致的，只不過動態代理的功能更強大，隨著業務的擴充套件，適應性更強。
3 使用動態代理實現無感知切換資料來源
在理解了上面的案例後，再來看資料來源動態路由業務，幫助小夥伴們加深對動態代理的印象。建立動態代理的類OrderServiceDynamicProxy，程式碼如下。
public class OrderServiceDynamicProxy implements InvocationHandler {
private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
private Object target;
public Object getInstance(Object target){
this.target = target;
Class<?> clazz = target.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before(args[0]);
Object object = method.invoke(target,args);
after();
return object;
}
private void before(Object target){
try {
System.out.println("Proxy before method.");
Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);
Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
System.out.println("靜態代理類自動分配到【DB_" + dbRouter + "】資料來源處理資料");
DynamicDataSourceEntry.set(dbRouter);
}catch (Exception e){
e.printStackTrace();
}
}
private void after(){
System.out.println("Proxy after method.");
}
}
編寫客戶端測試程式碼如下。
public static void main(String[] args) {
try {
Order order = new Order();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
Date date = sdf.parse("2018/02/01");
order.setCreateTime(date.getTime());
IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy().
getInstance(new OrderService());
orderService.createOrder(order);
}catch (Exception e){
e.printStackTrace();
}
}
由上面程式碼可以看出，依然能夠達到相同的執行效果。但是，使用動態代理實現之後，不僅能實現Order的資料來源動態路由，還可以實現其他任何類的資料來源路由。當然，有一個比較重要的約定，必須實現getCreateTime()方法，因為路由規則是根據時間來運算的。可以通過介面規範達到約束的目的，在此不再舉例。
4 手寫JDK動態代理核心原理
不僅知其然，還得知其所以然。既然JDK動態代理的功能如此強大，那麼它是如何實現的呢？現在來探究一下原理，並模仿JDK動態代理手寫一個屬於自己的動態代理。
我們都知道JDK動態代理採用位元組重組，重新生成物件來替代原始物件，以達到動態代理的目的。JDK動態代理生成物件的步驟如下。
（1）獲取被代理物件的引用，並且獲取它的所有介面，反射獲取。
（2）JDK動態代理類重新生成一個新的類，同時新的類要實現被代理類實現的所有介面。
（3）動態生成Java程式碼，新加的業務邏輯方法由一定的邏輯程式碼呼叫（在程式碼中體現）。
（4）編譯新生成的Java程式碼.class檔案。
（5）重新載入到JVM中執行。
以上過程就叫作位元組碼重組。JDK中有一個規範，在ClassPath下只要是$開頭的.class檔案，一般都是自動生成的。那麼有沒有辦法看到代替後的物件的“真容”呢？做一個這樣的測試，將記憶體中的物件位元組碼通過檔案流輸出到一個新的.class檔案，然後使用反編譯工具檢視原始碼。
public static void main(String[] args) {
try {
IPerson obj = (IPerson)new JdkMeipo().getInstance(new Zhangsan());
obj.findLove();
//通過反編譯工具檢視原始碼
byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{IPerson.class});
FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
os.write(bytes);
os.close();
} catch (Exception e) {
e.printStackTrace();
}
}
執行以上程式碼，可以在E盤找到一個$Proxy0.class檔案。使用Jad反編譯，得到$Proxy0.jad檔案，開啟檔案看到如下內容。
import com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements IPerson {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m4;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void findLove() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void buyInsure() throws {
try {
super.h.invoke(this, m4, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals",
new Class[]{Class.forName("java.lang.Object")});
m3 = Class.forName("com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson")
.getMethod("findLove", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m4 = Class.forName("com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson")
.getMethod("buyInsure", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
我們發現，$Proxy0繼承了Proxy類，同時實現了Person介面，而且重寫了findLove()等方法。在靜態程式碼塊中用反射查詢到了目標物件的所有方法，而且儲存了所有方法的引用，重寫的方法用反射呼叫目標物件的方法。小夥伴們此時一定會好奇：這些程式碼是從哪裡來的？其實是JDK自動生成的。現在我們不依賴JDK，自己來動態生成原始碼、動態完成編譯，然後替代目標物件並執行。
建立GPInvocationHandler介面。
public interface GPInvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
建立GPProxy類。
/**
* 用來生成原始碼的工具類
* Created by Tom.
*/
public class GPProxy {
public static final String ln = "\r\n";
public static Object newProxyInstance(GPClassLoader classLoader, Class<?> [] interfaces,
GPInvocationHandler h){
try {
//1.動態生成原始碼.java檔案
String src = generateSrc(interfaces);
//2.Java檔案輸出磁碟
String filePath = GPProxy.class.getResource("").getPath();
File f = new File(filePath + "$Proxy0.java");
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//3.把生成的.java檔案編譯成.class檔案
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);
Iterable iterable = manage.getJavaFileObjects(f);
JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);
task.call();
manage.close();
//4.編譯生成的.class檔案載入到JVM中
Class proxyClass = classLoader.findClass("$Proxy0");
Constructor c = proxyClass.getConstructor(GPInvocationHandler.class);
f.delete();
//5.返回位元組碼重組以後的新的代理物件
return c.newInstance(h);
}catch (Exception e){
e.printStackTrace();
}
return null;
}
private static String generateSrc(Class<?>[] interfaces){
StringBuffer sb = new StringBuffer();
sb.append(GPProxy.class.getPackage() + ";" + ln);
sb.append("import " + interfaces[0].getName() + ";" + ln);
sb.append("import java.lang.reflect.*;" + ln);
sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
sb.append("GPInvocationHandler h;" + ln);
sb.append("public $Proxy0(GPInvocationHandler h) { " + ln);
sb.append("this.h = h;");
sb.append("}" + ln);
for (Method m : interfaces[0].getMethods()){
Class<?>[] params = m.getParameterTypes();
StringBuffer paramNames = new StringBuffer();
StringBuffer paramValues = new StringBuffer();
StringBuffer paramClasses = new StringBuffer();
for (int i = 0; i < params.length; i++) {
Class clazz = params[i];
String type = clazz.getName();
String paramName = toLowerFirstCase(clazz.getSimpleName());
paramNames.append(type + " " + paramName);
paramValues.append(paramName);
paramClasses.append(clazz.getName() + ".class");
if(i > 0 && i < params.length-1){
paramNames.append(",");
paramClasses.append(",");
paramValues.append(",");
}
}
sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln);
sb.append("try{" + ln);
sb.append("Method m = " + interfaces[0].getName() + ".class. getMethod(\"" + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln);
sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})",m.getReturnType()) + ";" + ln);
sb.append("}catch(Error _ex) { }");
sb.append("catch(Throwable e){" + ln);
sb.append("throw new UndeclaredThrowableException(e);" + ln);
sb.append("}");
sb.append(getReturnEmptyCode(m.getReturnType()));
sb.append("}");
}
sb.append("}" + ln);
return sb.toString();
}
private static Map<Class,Class> mappings = new HashMap<Class, Class>();
static {
mappings.put(int.class,Integer.class);
}
private static String getReturnEmptyCode(Class<?> returnClass){
if(mappings.containsKey(returnClass)){
return "return 0;";
}else if(returnClass == void.class){
return "";
}else {
return "return null;";
}
}
private static String getCaseCode(String code,Class<?> returnClass){
if(mappings.containsKey(returnClass)){
return "((" + mappings.get(returnClass).getName() + ")" + code + ")." + returnClass.getSimpleName() + "Value()";
}
return code;
}
private static boolean hasReturnValue(Class<?> clazz){
return clazz != void.class;
}
private static String toLowerFirstCase(String src){
char [] chars = src.toCharArray();
chars[0] += 32;
return String.valueOf(chars);
}
}
建立GPClassLoader類。
public class GPClassLoader extends ClassLoader {
private File classPathFile;
public GPClassLoader(){
String classPath = GPClassLoader.class.getResource("").getPath();
this.classPathFile = new File(classPath);
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String className = GPClassLoader.class.getPackage().getName() + "." + name;
if(classPathFile != null){
File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
if(classFile.exists()){
FileInputStream in = null;
ByteArrayOutputStream out = null;
try{
in = new FileInputStream(classFile);
out = new ByteArrayOutputStream();
byte [] buff = new byte[1024];
int len;
while ((len = in.read(buff)) != -1){
out.write(buff,0,len);
}
return defineClass(className,out.toByteArray(),0,out.size());
}catch (Exception e){
e.printStackTrace();
}
}
}
return null;
}
}
建立GPMeipo類。
public class GpMeipo implements GPInvocationHandler {
private IPerson target;
public IPerson getInstance(IPerson target){
this.target = target;
Class<?> clazz = target.getClass();
return (IPerson) GPProxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(this.target,args);
after();
return result;
}
private void after() {
System.out.println("雙方同意，開始交往");
}
private void before() {
System.out.println("我是媒婆，已經收集到你的需求，開始物色");
}
}
客戶端測試程式碼如下。
public static void main(String[] args) {
GpMeipo gpMeipo = new GpMeipo();
IPerson zhangsan = gpMeipo.getInstance(new Zhangsan());
zhangsan.findLove();
}
至此，手寫JDK動態代理就完成了。小夥伴們是不是又多了一個面試用的“撒手鐗”呢？
5 CGLib動態代理API原理分析
簡單看一下CGLib動態代理的使用，還是以媒婆為例，建立CglibMeipo類。
public class CGlibMeipo implements MethodInterceptor {
public Object getInstance(Class<?> clazz) throws Exception{
//相當於JDK中的Proxy類，是完成代理的工具類
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
Object obj = methodProxy.invokeSuper(o,objects);
after();
return obj;
}
private void before(){
System.out.println("我是媒婆，我要給你找物件，現在已經確認你的需求");
System.out.println("開始物色");
}
private void after(){
System.out.println("雙方同意，準備辦婚事");
}
}
建立單身客戶類Customer。
public class Customer {
public void findLove(){
System.out.println("符合要求");
}
}
這裡有一個小細節，CGLib動態代理的目標物件不需要實現任何介面，它是通過動態繼承目標物件實現動態代理的，客戶端測試程式碼如下。
public static void main(String[] args) {
try {
//JDK採用讀取介面的資訊
//CGLib覆蓋父類方法
//目的都是生成一個新的類，去實現增強程式碼邏輯的功能
//JDK Proxy對於使用者而言，必須要有一個介面實現，目標類相對來說複雜
//CGLib可以代理任意一個普通的類，沒有任何要求
//CGLib生成代理的邏輯更復雜，呼叫效率更高，生成一個包含了所有邏輯的FastClass，不再需 要反射呼叫
//JDK Proxy生成代理的邏輯簡單，執行效率相對要低，每次都要反射動態呼叫
//CGLib有一個缺點，CGLib不能代理final的方法
Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
System.out.println(obj);
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
CGLib動態代理的實現原理又是怎樣的呢？我們可以在客戶端測試程式碼中加上一句程式碼，將CGLib動態代理後的.class檔案寫入磁碟，然後反編譯來一探究竟，程式碼如下。
public static void main(String[] args) {
try {
//使用CGLib的代理類可以將記憶體中的.class檔案寫入本地磁碟
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E://cglib_proxy_class/");
Customer obj = (Customer)new CglibMeipo().getInstance(Customer.class);
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
重新執行程式碼，我們會發現在E://cglib_proxy_class目錄下多了三個.class檔案，如下圖所示。
通過除錯跟蹤發現，Customer$$EnhancerByCGLIB$$3feeb52a.class就是CGLib動態代理生成的代理類，繼承了Customer類。
package com.tom.pattern.proxy.dynamicproxy.cglibproxy;
import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.*;
public class Customer$$EnhancerByCGLIB$$3feeb52a extends Customer
implements Factory
{
...
final void CGLIB$findLove$0()
{
super.findLove();
}
public final void findLove()
{
CGLIB$CALLBACK_0;
if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
JVM INSTR pop ;
CGLIB$BIND_CALLBACKS(this);
CGLIB$CALLBACK_0;
_L2:
JVM INSTR dup ;
JVM INSTR ifnull 37;
goto _L3 _L4
_L3:
break MISSING_BLOCK_LABEL_21;
_L4:
break MISSING_BLOCK_LABEL_37;
this;
CGLIB$findLove$0$Method;
CGLIB$emptyArgs;
CGLIB$findLove$0$Proxy;
intercept();
return;
super.findLove();
return;
}
...
}
我們重寫了Customer類的所有方法，通過代理類的原始碼可以看到，代理類會獲得所有從父類繼承來的方法，並且會有MethodProxy與之對應，比如Method CGLIB$findLove$0$Method、MethodProxy CGLIB$findLove$0$Proxy等方法在代理類的findLove()方法中都有呼叫。
//代理方法（methodProxy.invokeSuper()方法會呼叫）
final void CGLIB$findLove$0()
{
super.findLove();
}
//被代理方法（methodProxy.invoke()方法會呼叫
//這就是為什麼在攔截器中呼叫methodProxy.invoke會發生死迴圈，一直在呼叫攔截器）
public final void findLove()
{
...
//呼叫攔截器
intercept();
return;
super.findLove();
return;
}
呼叫過程為：代理物件呼叫this.findLove()方法→呼叫攔截器→methodProxy.invokeSuper()→ CGLIB$findLove$0→被代理物件findLove()方法。
此時，我們發現MethodInterceptor攔截器就是由MethodProxy的invokeSuper()方法呼叫代理方法的，因此，MethodProxy類中的程式碼非常關鍵，我們分析它具體做了什麼。
package net.sf.cglib.proxy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import net.sf.cglib.core.AbstractClassGenerator;
import net.sf.cglib.core.CodeGenerationException;
import net.sf.cglib.core.GeneratorStrategy;
import net.sf.cglib.core.NamingPolicy;
import net.sf.cglib.core.Signature;
import net.sf.cglib.reflect.FastClass;
import net.sf.cglib.reflect.FastClass.Generator;
public class MethodProxy {
private Signature sig1;
private Signature sig2;
private MethodProxy.CreateInfo createInfo;
private final Object initLock = new Object();
private volatile MethodProxy.FastClassInfo fastClassInfo;
public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
MethodProxy proxy = new MethodProxy();
proxy.sig1 = new Signature(name1, desc);
proxy.sig2 = new Signature(name2, desc);
proxy.createInfo = new MethodProxy.CreateInfo(c1, c2);
return proxy;
}
...
private static class CreateInfo {
Class c1;
Class c2;
NamingPolicy namingPolicy;
GeneratorStrategy strategy;
boolean attemptLoad;
public CreateInfo(Class c1, Class c2) {
this.c1 = c1;
this.c2 = c2;
AbstractClassGenerator fromEnhancer = AbstractClassGenerator.getCurrent();
if(fromEnhancer != null) {
this.namingPolicy = fromEnhancer.getNamingPolicy();
this.strategy = fromEnhancer.getStrategy();
this.attemptLoad = fromEnhancer.getAttemptLoad();
}
}
}
...
}
繼續看invokeSuper()方法。
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
try {
this.init();
MethodProxy.FastClassInfo fci = this.fastClassInfo;
return fci.f2.invoke(fci.i2, obj, args);
} catch (InvocationTargetException var4) {
throw var4.getTargetException();
}
}
...
private static class FastClassInfo {
FastClass f1;
FastClass f2;
int i1;
int i2;
private FastClassInfo() {
}
}
上面程式碼呼叫獲取代理類對應的FastClass，並執行代理方法。還記得之前生成的三個.class檔案嗎？Customer$$EnhancerByCGLIB$$3feeb52a$$FastClassByCGLIB$$6aad62f1.class就是代理類的FastClass，Customer$$FastClassByCGLIB$$2669574a.class就是被代理類的FastClass。
CGLib動態代理執行代理方法的效率之所以比JDK高，是因為CGlib採用了FastClass機制，它的原理簡單來說就是：為代理類和被代理類各生成一個類，這個類會為代理類或被代理類的方法分配一個index（int型別）；這個index被當作一個入參，FastClass可以直接定位要呼叫的方法並直接進行呼叫，省去了反射呼叫，因此呼叫效率比JDK代理通過反射呼叫高。下面我們來反編譯一個FastClass。
public int getIndex(Signature signature)
{
String s = signature.toString();
s;
s.hashCode();
JVM INSTR lookupswitch 11: default 223
…
JVM INSTR pop ;
return -1;
}
//部分程式碼省略
//根據index直接定位執行方法
public Object invoke(int i, Object obj, Object aobj[])
throws InvocationTargetException
{
(Customer)obj;
i;
JVM INSTR tableswitch 0 10: default 161
goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8 _L9 _L10 _L11 _L12
_L2:
eat();
return null;
_L3:
findLove();
return null;
…
throw new IllegalArgumentException("Cannot find matching method/constructor");
}
FastClass並不是跟代理類一起生成的，而是在第一次執行MethodProxy的invoke()或invokeSuper()方法時生成的，並被放在了快取中。
//MethodProxy的invoke()或invokeSuper()方法都呼叫了init()方法
private void init() {
if(this.fastClassInfo == null) {
Object var1 = this.initLock;
synchronized(this.initLock) {
if(this.fastClassInfo == null) {
MethodProxy.CreateInfo ci = this.createInfo;
MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo();
//如果在快取中，則取出；如果沒在快取中，則生成新的FastClass
fci.f1 = helper(ci, ci.c1);
fci.f2 = helper(ci, ci.c2);
fci.i1 = fci.f1.getIndex(this.sig1);//獲取方法的index
fci.i2 = fci.f2.getIndex(this.sig2);
this.fastClassInfo = fci;
}
}
}
}
至此，我們基本清楚了CGLib動態代理的原理，對程式碼細節感興趣的小夥伴們可以自行深入研究。
6 CGLib和JDK Proxy對比分析
（1）JDK動態代理實現了被代理物件的介面，CGLib動態代理繼承了被代理物件。
（2）JDK動態代理和CGLib動態代理都在執行期生成位元組碼，JDK動態代理直接寫Class位元組碼，CGLib動態代理使用ASM框架寫Class位元組碼。CGLib動態代理實現更復雜，生成代理類比JDK動態代理效率低。
（3）JDK動態代理呼叫代理方法是通過反射機制呼叫的，CGLib動態代理是通過FastClass機制直接呼叫方法的，CGLib動態代理的執行效率更高。
本文為“Tom彈架構”原創，轉載請註明出處。技術在於分享，我分享我快樂！
如果本文對您有幫助，歡迎關注和點贊；如果您有任何建議也可留言評論或私信，您的支援是我堅持創作的動力。關注微信公眾號『 Tom彈架構 』可獲取更多技術乾貨！