資訊專欄INFORMATION COLUMN
摘要：代理模式從類型上來說，可以分為靜態代理和動態代理兩種類型。然而今天的重點是我們都知道牛逼轟轟的的實現的一種方式是使用的動態代理另一種是，大部分人也會用的動態代理，不過沒有研究過的動態代理到底是怎么實現的。
動態代理
代理模式是設計模式中非常重要的一種類型，而設計模式又是編程中非常重要的知識點，特別是在業務系統的重構中，更是有舉足輕重的地位。代理模式從類型上來說，可以分為靜態代理和動態代理兩種類型。
在解釋動態代理之前我們先理解一下靜態代理：
首先你要明白靜態代理的作用我們有一個字體提供類，有多種實現（從磁盤，從網絡，從系統）
public interface FontProvider {
Font getFont(String name);
}
public abstract class ProviderFactory {
public static FontProvider getFontProvider() {
return new FontProviderFromDisk();
}
}
public class Main() {
public static void main(String[] args) {
FontProvider fontProvider = ProviderFactory.getFontProvider();
Font font = fontProvider.getFont("微軟雅黑");
......
}
}
現在我們希望給他加上一個緩存功能，我們可以用靜態代理來完成
public class CachedFontProvider implements FontProvider {
private FontProvider fontProvider;
private Map cached;
public CachedFontProvider(FontProvider fontProvider) {
this.fontProvider = fontProvider;
}
public Font getFont(String name) {
Font font = cached.get(name);
if (font == null) {
font = fontProvider.getFont(name);
cached.put(name, font);
}
return font;
}
}
/* 對工廠類進行相應修改，代碼使用處不必進行任何修改。
這也是面向接口編程以及工廠模式的一個好處 */
public abstract class ProviderFactory {
public static FontProvider getFontProvider() {
return new CachedFontProvider(new FontProviderFromDisk());
}
}
當然，我們直接修改FontProviderFromDisk類也可以實現目的，但是我們還有FontProviderFromNet, FontProviderFromSystem等多種實現類，一一修改太過繁瑣且易出錯。況且將來還可能添加日志，權限檢查，異常處理等功能顯然用代理類更好一點。
然而今天的重點是：我們都知道牛逼轟轟的Spring AOP的實現的一種方式是使用JDK的動態代理（另一種是cglib），大部分人也會用jdk的動態代理，不過沒有研究過jdk的動態代理到底是怎么實現的。今天就來揭開他的神秘面紗；
1. 原理源碼剖析 首先我們先來講一下JDK動態代理的實現原理1.拿到被代理對象的引用，然后獲取他的接口
2.JDK代理重新生成一個類，同時實現我們給的代理對象所實現的接口
3.把被代理對象的引用拿到了
4.重新動態生成一個class字節碼
5.然后編譯
代碼很簡單了，就是實現
java.lang.reflect.InvocationHandler接口，并使用
java.lang.reflect.Proxy.newProxyInstance()方法生成代理對象
/**
* @author mark
* @date 2018/3/30
*/
public class JdkInvocationHandler implements InvocationHandler {
private ProductService target;
public Object getInstance(ProductService target){
this.target = target;
Class clazz = this.target.getClass();
// 參數1：被代理類的類加載器 參數2:被代理類的接口 參數3
return Proxy.newProxyInstance(clazz.getClassLoader(),
clazz.getInterfaces(),
this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String currentDate = simpleDateFormat.format(new Date());
System.out.println("日期【"+currentDate + "】添加了一款產品");
return method.invoke(this.target,args);
}
}
被代理接口和實現
/**
* 模仿產品Service
* @author mark
* @date 2018-03-30
*/
public interface ProductService {
/**
* 添加產品
* @param productName
*/
void addProduct(String productName);
}
/**
* @author mark
* @date 2018/3/30
*/
public class ProductServiceImpl implements ProductService{
public void addProduct(String productName) {
System.out.println("正在添加"+productName);
}
}
測試類
public class Test {
public static void main(String[] args) throws Exception {
ProductService productService = new ProductServiceImpl();
ProductService proxy = (ProductService) new JdkInvocationHandler().getInstance(productService);
proxy.addProduct("iphone");
// 這里我們將jdk生成的代理類輸出了出來，方便后面分析使用
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{productService.getClass()});
FileOutputStream os = new FileOutputStream("Proxy0.class");
os.write(bytes);
os.close();
}
}
結果輸出
日期【2018-03-30】添加了一款產品 正在添加iphone Process finished with exit code 0
上面我們實現動態動態代理的時候輸出了代理類的字節碼文件，現在來看一下字節碼文件反編譯過后的內容
import com.gwf.jdkproxy.ProductServiceImpl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
// 繼承了Proxy類
public final class $Proxy0 extends Proxy implements ProductServiceImpl {
private static Method m1;
private static Method m8;
private static Method m2;
private static Method m3;
private static Method m5;
private static Method m4;
private static Method m7;
private static Method m9;
private static Method m0;
private static Method m6;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
....
....
/**
* 這里是代理類實現的被代理對象的接口的相同方法
*/
public final void addProduct(String var1) throws {
try {
// super.h 對應的是父類的h變量，他就是Proxy.nexInstance方法中的InvocationHandler參數
// 所以這里實際上就是使用了我們自己寫的InvocationHandler實現類的invoke方法
super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final Class getClass() throws {
try {
return (Class)super.h.invoke(this, m7, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
....
....
// 在靜態構造塊中，代理類通過反射獲取了被代理類的詳細信息，比如各種方法
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m8 = Class.forName("com.gwf.jdkproxy.ProductServiceImpl").getMethod("notify");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.gwf.jdkproxy.ProductServiceImpl").getMethod("addProduct", Class.forName("java.lang.String"));
m5 = Class.forName("com.gwf.jdkproxy.ProductServiceImpl").getMethod("wait", Long.TYPE);
m4 = Class.forName("com.gwf.jdkproxy.ProductServiceImpl").getMethod("wait", Long.TYPE, Integer.TYPE);
m7 = Class.forName("com.gwf.jdkproxy.ProductServiceImpl").getMethod("getClass");
m9 = Class.forName("com.gwf.jdkproxy.ProductServiceImpl").getMethod("notifyAll");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
m6 = Class.forName("com.gwf.jdkproxy.ProductServiceImpl").getMethod("wait");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
補充一下上面代母注釋中的super.h
protected InvocationHandler h;
protected Proxy(InvocationHandler h) {
Objects.requireNonNull(h);
this.h = h;
}
// 這個方法是Proxy的newProxyInstance方法，主要就是生成了上面的動態字節碼文件
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 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() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
// 重點看這里，將我們傳來的InvocationHandler參數穿給了構造函數
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動態代理的內部實現過程，最后再次將上面的原理聲明一遍，強化記憶
1.拿到被代理對象的引用，然后獲取他的接口 (Proxy.getInstance方法)
2.JDK代理重新生成一個類，同時實現我們給的代理對象所實現的接口 （上面的反編譯文件中實現了同樣的接口）
3.把被代理對象的引用拿到了（上面被代理對象中在靜態代碼塊中通過反射獲取到的信息，以及我們實現的JdkInvocationHandler中的target）
4.重新動態生成一個class字節碼
5.然后編譯
（聲明：本代碼只用作實例，很多細節沒有考慮進去，比如，多接口的代理類，Object類的其他默認方法的代理，為確保原汁原味，一些模板引擎和commons工具類也沒有使用；覺得不足的老鐵們可以隨意完善，記得評論區留言完善方法哦）
我們使用jdk代理的類名和方法名定義，已經執行思路，但是所有的實現都自己來寫；
首先先定義出類結構
/**
* 自定義類加載器
* @author gaowenfeng
* @date 2018/3/30
*/
public class MyClassLoader extends ClassLoader {
/**
* 通過類名稱加載類字節碼文件到JVM中
* @param name 類名
* @return 類的Class獨享
* @throws ClassNotFoundException
*/
@Override
protected Class findClass(String name) throws ClassNotFoundException {
return super.findClass(name);
}
}
/**
* @desc 自己實現的代理類，用來生成字節碼文件，并動態加載到JVM中
* @author gaowenfeng
* @date 2018/3/30
*/
public class MyProxy {
/**
* 生成代理對象
* @param loader 類加載器，用于加載被代理類的類文件
* @param interfaces 被代理類的接口
* @param h 自定義的InvocationHandler接口,用于具體代理方法的執行
* @return 返回被代理后的代理對象
* @throws IllegalArgumentException
*/
public static Object newProxyInstance(MyClassLoader loader,
Class[] interfaces,
MyInvocationHandler h)
throws IllegalArgumentException{
/**
* 1.生成代理類的源代碼
* 2.將生成的源代碼輸出到磁盤，保存為.java文件
* 3.編譯源代碼，并生成.java文件
* 4.將class文件中的內容，動態加載到JVM中
* 5.返回被代理后的代理對象
*/
return null;
}
}
/**
* 自定義類加載器
* @author gaowenfeng
* @date 2018/3/30
*/
public class MyClassLoader extends ClassLoader {
/**
* 通過類名稱加載類字節碼文件到JVM中
* @param name 類名
* @return 類的Class獨享
* @throws ClassNotFoundException
*/
@Override
protected Class findClass(String name) throws ClassNotFoundException {
return super.findClass(name);
}
}
/**
* @author gaowenfeng
* @date 2018/3/30
*/
public class CustomInvocationHandler implements MyInvocationHandler {
private ProductService target;
public Object getInstance(ProductService target){
this.target = target;
Class clazz = this.target.getClass();
// 參數1：被代理類的類加載器 參數2:被代理類的接口 參數3
// 這里的MyClassLoader先用new的方式保證編譯不報錯，后面會修改
return MyProxy.newProxyInstance(new MyClassLoader(),
clazz.getInterfaces(),
this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String currentDate = simpleDateFormat.format(new Date());
System.out.println("日期【"+currentDate + "】添加了一款產品");
return method.invoke(this.target,args);
}
}
接下來我們來按照步驟一步一步的完善我們的類
生成代理類的源文件
* 生成代理類的源代碼
* @return
*/
private static String genSesource(Class interfaces){
StringBuilder src = new StringBuilder();
src.append("package com.gwf.custom;").append(ln)
.append("import java.lang.reflect.Method;").append(ln)
.append("public class $Proxy0 implements ").append(interfaces.getName()).append("{").append(ln)
.append("private MyInvocationHandler h;").append(ln)
.append("public $Proxy0(MyInvocationHandler h){").append(ln)
.append("this.h=h;").append(ln)
.append("}").append(ln);
for(Method method:interfaces.getMethods()){
src.append("public ").append(method.getReturnType()).append(" ").append(method.getName()).append("() {").append(ln)
.append("try {").append(ln)
.append("Method m = ").append(interfaces.getName()).append(".class.getMethod("").append(method.getName()).append("");").append(ln)
.append("this.h.invoke(this, m, new Object[]{});").append(ln)
.append("}catch (Throwable e){").append(ln)
.append("e.printStackTrace();").append(ln)
.append("}").append(ln)
.append("}").append(ln);
}
src.append("}");
return src.toString();
}
2.將源文件保存到本地
// 1.生成代理類的源代碼
String src = genSesource(interfaces);
// 2.將生成的源代碼輸出到磁盤，保存為.java文件
String path = MyProxy.class.getResource("").getPath();
File file = new File(path+"$Proxy0.java");
FileWriter fw = new FileWriter(file);
fw.write(src);
fw.close();
3.編譯源代碼，并生成.java文件
// 3.編譯源代碼，并生成.java文件
// 獲取java編譯器
JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
// 標注java文件管理器，用來獲取java字節碼文件
StandardJavaFileManager manager = javaCompiler.getStandardFileManager(null,null,null);
Iterable iterable = manager.getJavaFileObjects(file);
// 創建task，通過java字節碼文件將類信息加載到JVM中
JavaCompiler.CompilationTask task = javaCompiler.getTask(null,manager,null,null,null,iterable);
// 開始執行task
task.call();
// 關閉管理器
manager.close();
4.將class文件中的內容，動態加載到JVM中
public class MyClassLoader extends ClassLoader {
private String baseDir;
public MyClassLoader(){
this.baseDir = MyClassLoader.class.getResource("").getPath();
}
/**
* 通過類名稱加載類字節碼文件到JVM中
* @param name 類名
* @return 類的Class獨享
* @throws ClassNotFoundException
*/
@Override
protected Class findClass(String name) throws ClassNotFoundException {
// 獲取類名
String className = MyClassLoader.class.getPackage().getName()+"."+name;
if(null == baseDir) {
throw new ClassNotFoundException();
}
// 獲取類文件
File file = new File(baseDir,name+".class");
if(!file.exists()){
throw new ClassNotFoundException();
}
// 將類文件轉換為字節數組
try(
FileInputStream in = new FileInputStream(file);
ByteArrayOutputStream out = new ByteArrayOutputStream();
){
byte[] buffer = new byte[1024];
int len;
while ((len = in.read(buffer))!=-1){
out.write(buffer,0,len);
}
// 調用父類方法生成class實例
return defineClass(className,out.toByteArray(),0,out.size());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
5.返回被代理后的代理對象
Constructor c = proxyClass.getConstructor(MyInvocationHandler.class);
return c.newInstance(h);
最后看一下總體的MyProxy類 的 newProxyInstance方法
public static Object newProxyInstance(MyClassLoader loader,
Class interfaces,
MyInvocationHandler h)
throws IllegalArgumentException{
/**
* 1.生成代理類的源代碼
* 2.將生成的源代碼輸出到磁盤，保存為.java文件
* 3.編譯源代碼，并生成.java文件
* 4.將class文件中的內容，動態加載到JVM中
* 5.返回被代理后的代理對象
*/
try {
// 1.生成代理類的源代碼
String src = genSesource(interfaces);
// 2.將生成的源代碼輸出到磁盤，保存為.java文件
String path = MyProxy.class.getResource("").getPath();
File file = new File(path+"$Proxy0.java");
FileWriter fw = new FileWriter(file);
fw.write(src);
fw.close();
// 3.編譯源代碼，并生成.java文件
JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager manager = javaCompiler.getStandardFileManager(null,null,null);
Iterable iterable = manager.getJavaFileObjects(file);
JavaCompiler.CompilationTask task = javaCompiler.getTask(null,manager,null,null,null,iterable);
task.call();
manager.close();
// 4.將class文件中的內容，動態加載到JVM中
Class proxyClass = loader.findClass("$Proxy0");
// 5.返回被代理后的代理對象
Constructor c = proxyClass.getConstructor(MyInvocationHandler.class);
return c.newInstance(h);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
激動人心的時刻：測試運行
public class CustomClient {
public static void main(String[] args){
ProductService productService = new ProductServiceImpl();
ProductService proxy = (ProductService) new CustomInvocationHandler().getInstance(productService);
proxy.addProduct();
}
}
運行結果
日期【2018-03-30】添加了一款產品 正在添加iphone Process finished with exit code 0
總結：以上通過理解jdk動態代理的原理，自己手寫了一個動態代理，里面涉及到的重點主要是代理類字節碼的生成（這里采用通過反射強行生成源文件并編譯的方法，其實應該可以直接生成字節碼文件的，有興趣的同學可以嘗試）和將生成的類動態加載到JVM中（本次試驗由于測試，比較簡單，直接將類名硬編碼到了系統里，正常應該是自動加載），雖然還不完善，但是對于理解原理應該是有很多幫助了，歡迎同學們評論區留言評論給出更好的建議
文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。
轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/71753.html
摘要：總結動態代理的相關原理已經講解完畢，接下來讓我們回答以下幾個思考題。 【干貨點】 此處是【好好面試】系列文的第12篇文章。文章目標主要是通過原理剖析的方式解答Aop動態代理的面試熱點問題，通過一步步提出問題和了解原理的方式，我們可以記得更深更牢，進而解決被面試官卡住喉嚨的情況。問題如下 SpringBoot默認代理類型是什么 為什么不用靜態代理 JDK動態代理原理 CGLIB動態代理...
摘要：，，面向切面編程。，切點，切面匹配連接點的點，一般與切點表達式相關，就是切面如何切點。例子中，注解就是切點表達式，匹配對應的連接點，通知，指在切面的某個特定的連接點上執行的動作。，織入，將作用在的過程。因為源碼都是英文寫的。 之前《零基礎帶你看Spring源碼——IOC控制反轉》詳細講了Spring容器的初始化和加載的原理，后面《你真的完全了解Java動態代理嗎？看這篇就夠了》介紹了下...
摘要：思考之所以會選擇為切入點，是因為通過命名可以看出這是用來構建代理強化對象的地方，并且由于是先將目標類加載到內存中，之后通過修改字節碼生成目標類的子類，因此我猜測強化是在目標類實例化后觸發的時候進行的。 【干貨點】 此處是【好好面試】系列文的第11篇文章。看完該篇文章，你就可以了解Spring中Aop的相關使用和原理，并且能夠輕松解答Aop相關的面試問題。更重要的是，很多人其實一看源碼就...
摘要：與靜態代理對比，動態代理是在動態生成代理類，由代理類完成對具體方法的封裝，實現的功能。本文將分析中兩種動態代理的實現方式，和，比較它們的異同。那如何動態編譯呢你可以使用，這是一個封裝了的庫，幫助你方便地實現動態編譯源代碼。 發現Java面試很喜歡問Spring AOP怎么實現的之類的問題，所以寫一篇文章來整理一下。關于AOP和代理模式的概念這里并不做贅述，而是直奔主題，即AOP的實現方...
閱讀 3565·2021-09-24 09:48
閱讀 1087·2021-09-10 10:51
閱讀 3268·2019-08-30 13:03
閱讀 3315·2019-08-30 12:51
閱讀 1388·2019-08-30 11:22
閱讀 1052·2019-08-29 18:38
閱讀 2035·2019-08-29 16:41
閱讀 3183·2019-08-29 15:32
