Ⅰ.AnnotatedElement

作為頂級介面，這個介面提供了獲取註解相關的功能，我們在方法，類，屬性，構造方法上都可以加註解，所以下面的Field，Method，Constructor都有實現這個介面，以下是我們經常用的兩個方法，jdk8以後,介面裡面可以通過default修飾方法實現了

Annotation[] getAnnotations();
//獲取目標對象(方法和屬性)上的所有註解
default <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass) {
Objects.requireNonNull(annotationClass);
// Loop over all directly-present annotations looking for a matching one
for (Annotation annotation : getDeclaredAnnotations()) {
if (annotationClass.equals(annotation.annotationType())) {
// More robust to do a dynamic cast at runtime instead
// of compile-time only.
return annotationClass.cast(annotation);
}
}
return null;
}

GenericDeclaration

提供了獲取泛型相關的功能，只有方法和構造方法上支持泛型，所以只有Method，Constructor實現了該介面

Ⅱ.Member

作為一個對象內部方法和屬性的聲明的抽象，包含了名稱，修飾符，所在的類,其中修飾符包含了 static final public private volatile 等，通過一個整數表示，每一個類型在二進位中佔一個位.

public Class<?> getDeclaringClass();
public String getName();
public int getModifiers();

以下為Modifier類部分代碼

public static final int PUBLIC = 0x00000001;
public static final int PRIVATE = 0x00000002;
public static final int PROTECTED = 0x00000004;
public static final int STATIC = 0x00000008;
public static final int FINAL = 0x00000010;
public static final int SYNCHRONIZED = 0x00000020;
public static final int VOLATILE = 0x00000040;
public static final int TRANSIENT = 0x00000080;
public static final int NATIVE = 0x00000100;
public static final int INTERFACE = 0x00000200;
public static final int ABSTRACT = 0x00000400;
public static final int STRICT = 0x00000800;
public static boolean isPublic(int mod) {
return (mod & PUBLIC) != 0;
}

Ⅲ.AccessibleObject

這是一個類，提供了許可權管理的功能，例如是否允許在反射中在外部調用一個private方法，獲取一個private屬性的值，所以method，constructor,field都繼承該類，下面這段代碼展示瞭如何在反射中訪問一個私有的成員變數，class對象的構造方法不允許對外.

private static void setAccessible0(AccessibleObject obj, Boolean flag)
throws SecurityException
{
if (obj instanceof Constructor && flag == true) {
Constructor<?> c = (Constructor<?>)obj;
if (c.getDeclaringClass() == Class.class) {
throw new SecurityException("Cannot make a java.lang.Class" +
" constructor accessible");
}
}
obj.override = flag;
}
Boolean override;
public Boolean isAccessible() {
return override;
}

以下為 Field裡面通過field.get(原始對象)獲取屬性值得實現,先通過override做校驗，如果沒有重載該許可權，則需要校驗訪問許可權

public Object get(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, obj, modifiers);
}
}
return getFieldAccessor(obj).get(obj);
}

下面我們看看如何通過反射修改Field裡面屬性的值

通過上面的代碼，我們可以看出jdk將Field屬性的讀取和寫入委託給FieldAccessor，那麼如何獲取FieldAccessor呢

class UnsafeFieldAccessorFactory {
UnsafeFieldAccessorFactory() {
}

static FieldAccessor newFieldAccessor(Field var0, boolean var1) {
Class var2 = var0.getType();
boolean var3 = Modifier.isStatic(var0.getModifiers());
boolean var4 = Modifier.isFinal(var0.getModifiers());
boolean var5 = Modifier.isVolatile(var0.getModifiers());
boolean var6 = var4 || var5;
boolean var7 = var4 && (var3 || !var1);

if (var3) {
UnsafeFieldAccessorImpl.unsafe.ensureClassInitialized(var0.getDeclaringClass());

return (FieldAccessor) ((!var6)
? ((var2 == Boolean.TYPE)
? new UnsafeStaticBooleanFieldAccessorImpl(var0)
: ((var2 == Byte.TYPE)
? new UnsafeStaticByteFieldAccessorImpl(var0)
: ((var2 == Short.TYPE)
? new UnsafeStaticShortFieldAccessorImpl(var0)
: ((var2 == Character.TYPE)
? new UnsafeStaticCharacterFieldAccessorImpl(var0)
: ((var2 == Integer.TYPE)
? new UnsafeStaticIntegerFieldAccessorImpl(var0)
: ((var2 == Long.TYPE)
? new UnsafeStaticLongFieldAccessorImpl(var0)
: ((var2 == Float.TYPE)
? new UnsafeStaticFloatFieldAccessorImpl(var0)
: ((var2 == Double.TYPE)
? new UnsafeStaticDoubleFieldAccessorImpl(var0)
: new UnsafeStaticObjectFieldAccessorImpl(var0)))))))))
: ((var2 == Boolean.TYPE)
? new UnsafeQualifiedStaticBooleanFieldAccessorImpl(var0, var7)
: ((var2 == Byte.TYPE)
? new UnsafeQualifiedStaticByteFieldAccessorImpl(var0, var7)
: ((var2 == Short.TYPE)
? new UnsafeQualifiedStaticShortFieldAccessorImpl(var0, var7)
: ((var2 == Character.TYPE)
? new UnsafeQualifiedStaticCharacterFieldAccessorImpl(var0, var7)
: ((var2 == Integer.TYPE)
? new UnsafeQualifiedStaticIntegerFieldAccessorImpl(var0, var7)
: ((var2 == Long.TYPE)
? new UnsafeQualifiedStaticLongFieldAccessorImpl(var0, var7)
: ((var2 == Float.TYPE)
? new UnsafeQualifiedStaticFloatFieldAccessorImpl(var0, var7)
: ((var2 == Double.TYPE)
? new UnsafeQualifiedStaticDoubleFieldAccessorImpl(var0, var7)
: new UnsafeQualifiedStaticObjectFieldAccessorImpl(var0, var7))))))))));
} else {
return (FieldAccessor) ((!var6)
? ((var2 == Boolean.TYPE)
? new UnsafeBooleanFieldAccessorImpl(var0)
: ((var2 == Byte.TYPE) ? new UnsafeByteFieldAccessorImpl(var0)
: ((var2 == Short.TYPE)
? new UnsafeShortFieldAccessorImpl(var0)
: ((var2 == Character.TYPE)
? new UnsafeCharacterFieldAccessorImpl(var0)
: ((var2 == Integer.TYPE)
? new UnsafeIntegerFieldAccessorImpl(var0)
: ((var2 == Long.TYPE) ? new UnsafeLongFieldAccessorImpl(var0)
: ((var2 == Float.TYPE)
? new UnsafeFloatFieldAccessorImpl(var0)
: ((var2 == Double.TYPE) ? new UnsafeDoubleFieldAccessorImpl(var0)
: new UnsafeObjectFieldAccessorImpl(var0)))))))))
: ((var2 == Boolean.TYPE)
? new UnsafeQualifiedBooleanFieldAccessorImpl(var0, var7)
: ((var2 == Byte.TYPE)
? new UnsafeQualifiedByteFieldAccessorImpl(var0, var7)
: ((var2 == Short.TYPE)
? new UnsafeQualifiedShortFieldAccessorImpl(var0, var7)
: ((var2 == Character.TYPE)
? new UnsafeQualifiedCharacterFieldAccessorImpl(var0, var7)
: ((var2 == Integer.TYPE)
? new UnsafeQualifiedIntegerFieldAccessorImpl(var0, var7)
: ((var2 == Long.TYPE)
? new UnsafeQualifiedLongFieldAccessorImpl(var0, var7)
: ((var2 == Float.TYPE)
? new UnsafeQualifiedFloatFieldAccessorImpl(var0, var7)
: ((var2 == Double.TYPE)
? new UnsafeQualifiedDoubleFieldAccessorImpl(var0, var7)
: new UnsafeQualifiedObjectFieldAccessorImpl(var0, var7))))))))));
}
}
}

以上代碼可以發現，通過工廠模式根據field屬性類型以及是否靜態來獲取，為什麼會有這樣的劃分呢

首先，jdk是通過UNSAFE類對堆內存中對象的屬性進行直接的讀取和寫入，要讀取和寫入首先需要確定屬性所在的位置，也就是相對對象起始位置的偏移量，而靜態屬性是針對類的不是每個對象實例一份，所以靜態屬性的偏移量需要單獨獲取

其實通過該偏移量我們可以大致推斷出一個實例內每個屬性在堆內存的相對位置，以及分別佔用多大的空間，有了位置信息，我們還需要這個欄位的類型，以方便執行器知道讀幾個位元組的數據，並且如何進行解析，目前提供了8大基礎類型（char vs Charector）和數組和普通引用類型。 java虛擬機為了保證每個對象所佔的空間都是8個位元組倍數,有時候為了避免兩個volatile欄位存放在同一個緩存行,所以有時候會再某些欄位上做空位填充

以下為UnSafe類的部分代碼

public final class Unsafe {
private static final Unsafe theUnsafe;
private Unsafe() {
}

@CallerSensitive
public static Unsafe getUnsafe() {
Class var0 = Reflection.getCallerClass();
if(!VM.isSystemDomainLoader(var0.getClassLoader())) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}

public native int getInt(Object var1, long var2);
public native void putInt(Object var1, long var2, int var4);
public native Object getObject(Object var1, long var2);
public native void putObject(Object var1, long var2, Object var4);
public native boolean getBoolean(Object var1, long var2);
public native void putBoolean(Object var1, long var2, boolean var4);
public native byte getByte(Object var1, long var2);

public native long objectFieldOffset(Field var1);
@Deprecated
public int fieldOffset(Field var1) {
return Modifier.isStatic(var1.getModifiers())?(int)this.staticFieldOffset(var1):(int)this.objectFieldOffset(var1);
}

然後我們在來看看通過反射來調用方法

同樣，jdk通過MethodAccessor來進行method的調用，java虛擬機提供了兩種模式來支持method的調用 一個是NativeMethodAccessorImpl 一個是通過ASM位元組碼直接動態生成一個類在invoke方法內部調用目標方法，由於是動態生成所以jdk中沒有其源碼，但jdk提供了DelegatingMethodAccessorImpl委派模式以方便在運行過程中可以動態切換位元組碼模式和native模式，我們可以看下生成MethodAccessor的代碼

class NativeMethodAccessorImpl extends MethodAccessorImpl {
private final Method method;
private DelegatingMethodAccessorImpl parent;
private int numInvocations;

NativeMethodAccessorImpl(Method var1) {
this.method = var1;
}

public Object invoke(Object var1, Object[] var2) throws IllegalArgumentException, InvocationTargetException {
if(++this.numInvocations > ReflectionFactory.inflationThreshold() && !ReflectUtil.isVMAnonymousClass(this.method.getDeclaringClass())) {
MethodAccessorImpl var3 = (MethodAccessorImpl)(new MethodAccessorGenerator()).generateMethod(this.method.getDeclaringClass(), this.method.getName(), this.method.getParameterTypes(), this.method.getReturnType(), this.method.getExceptionTypes(), this.method.getModifiers());
this.parent.setDelegate(var3);
}

return invoke0(this.method, var1, var2);
}

void setParent(DelegatingMethodAccessorImpl var1) {
this.parent = var1;
}

private static native Object invoke0(Method var0, Object var1, Object[] var2);
}

可以看到JDK內部通過numInvocations判斷如果該反射調用次數超過ReflectionFactory.inflationThreshold()則用位元組碼實現，如果小於該值則採用native實現，native的調用比位元組碼方式慢很多， 動態實現和本地實現相比執行效率要快20倍，因為動態實現無需經過JAVA,C++再到JAVA的轉換，之前在jdk6以前有個工具ReflectAsm就是採用這種方式提升執行效率，不過在jdk8以後，也提供了位元組碼方式，由於許多反射只需要執行一次，然而動態方式生成位元組碼十分耗時，所以jdk提供了一個閾值默認15，當某個反射的調用次數小於15的話就走本地實現，大於15則走動態模式，而這個閾值可以在jdk啟動參數裡面做配置

反射為什麼慢

經過以上優化，其實反射的效率並不慢，在某些情況下可能達到和直接調用基本相同的效率，但是在首次執行或者沒有緩存的情況下還是會有性能上的開銷，主要在以下方面

1. Class.forName();會調用本地方法，我們用到的method和field都會在此時載入進來，雖然會進行緩存，但是本地方法免不了有JAVA到C+=在到JAVA得轉換開銷
2. class.getMethod()，會遍歷該class所有的公用方法，如果沒匹配到還會遍歷父類的所有方法，並且getMethods()方法會返回結果的一份拷貝，所以該操作不僅消耗CPU還消耗堆內存，在熱點代碼中應該盡量避免，或者進行緩存
3. invoke參數是一個object數組，而object數組不支持java基礎類型，而自動裝箱也是很耗時的

反射的運用

Ⅰ.spring ioc

spring載入bean的流程基本都用到了反射機制

1. 獲取類的實例 通過構造方法getInstance（靜態變數初始化，屬性賦值，構造方法）
2. 如果實現了BeanNameAware介面，則用反射注入bean賦值給屬性
3. 如果實現了BeanFactoryAware介面，則設置 beanFactory
4. 如果實現了ApplicationContextAware，則設置ApplicationContext
5. 調用BeanPostProcesser的預先初始化方法
6. 如果實現了InitializingBean,調用AfterPropertySet方法
7. 調用定製的 init-method()方法 對應的直接 @PostConstruct
8. 調用BeanPostProcesser的後置初始化完畢的方法

Ⅱ.序列化

fastjson可以參考ObjectDeserializer的幾個實現 JavaBeanDeserializer和ASMJavaBeanDeserializer

動態代理

jdk提供了一個工具類來動態生成一個代理，允許在執行某一個方法時進行額外的處理

Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

class HWInvocationHandler implements InvocationHandler{
//目標對象
private Object target;
public HWInvocationHandler(Object target){
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("------插入前置通知代碼-------------");
//執行相應的目標方法
Object rs = method.invoke(target,args);
System.out.println("------插入後置處理代碼-------------");
return rs;
}
}

我們分析下這個方法的實現，首先生成的代理對象，需要實現參數裡面聲明的所有介面，介面的實現應給委託給InvocationHandler進行處理，invocationHandler裡面可以根據method聲明判斷是否需要做增強,所以所生成的代理類裡面必須能夠獲取到InvocationHandler,在我們無法知道代理類的具體類型的時候，我們可以通過反射從構造方法裏將InvocationHandler傳給代理類的實例 所以 總的來說生成代理對象需要兩步

1. 獲取代理類的class對象
2. 通過class對象獲取構造方法，通過反射生成代理類的實例，並將InvocationHandler傳人

@CallerSensitive
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;
}
});
}
//獲取代理類的實例,並且將invocationhandler傳人
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
...
}
}

下面我們在看下 getProxyClass0 如何獲取代理類的class對象，這裡idk通過WeakCache來緩存已經生成的class對象，因為生成該class通過位元組碼生成還是很耗時，同時為瞭解決之前由於動態代理生成太多class對象導致內存不足，所以這裡通過弱引用WeakReference來緩存所生成的代理對象class，當發生GC的時候如果該class對象沒有其他的強引用將會被直接回收 生成代理類的class在ProxyGenerator的generateProxyClass方法內實現，該方法返回一個byte[]數組，最後通過一個本地方法載入到虛擬機，所以可以看出生成該對象還是非常耗時的

//生成位元組碼數組
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());
}

private byte[] generateClassFile() {
this.addProxyMethod(hashCodeMethod, Object.class);
this.addProxyMethod(equalsMethod, Object.class);
this.addProxyMethod(toStringMethod, Object.class);
Class[] var1 = this.interfaces;
int var2 = var1.length;

int var3;
Class var4;
for(var3 = 0; var3 < var2; ++var3) {
var4 = var1[var3];
Method[] var5 = var4.getMethods();
int var6 = var5.length;

for(int var7 = 0; var7 < var6; ++var7) {
Method var8 = var5[var7];
this.addProxyMethod(var8, var4);
}
}

this.methods.add(this.generateConstructor());
...
}
//生成一個帶invocationhandler參數的構造方法
private ProxyGenerator.MethodInfo generateConstructor() throws IOException {
ProxyGenerator.MethodInfo var1 = new ProxyGenerator.MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V", 1);
DataOutputStream var2 = new DataOutputStream(var1.code);
this.code_aload(0, var2);
this.code_aload(1, var2);
var2.writeByte(183);
var2.writeShort(this.cp.getMethodRef("java/lang/reflect/Proxy", "<init>", "(Ljava/lang/reflect/InvocationHandler;)V"));
var2.writeByte(177);
var1.maxStack = 10;
var1.maxLocals = 2;
var1.declaredExceptions = new short[0];
return var1;
}

上面的流程可以簡單歸納為

1. 增加hashcode,equals,toString方法
2. 增加所有介面中聲明的未實現方法
3. 增加一個方法參數為java/lang/reflect/InvocationHandler的構造方法
4. 其他靜態初始化數據

動態代理的應用

Ⅰ.spring-aop

spring aop默認基於jdk動態代理來實現，我們來看下下面這個經典的面試問題

一個類裡面,兩個方法A和方法B,方法B上有加註解做事物增強,那麼A調用this.B為什麼沒有事物效果？

因為spring-aop默認基於jdk的動態代理實現，最終執行是通過生成的代理對象的,而代理對象執行A方法和B方法其實是調用的InvocationHandler裡面的增強後的方法,其中B方法是經過InvocationHandler做增強在方法前後增加了事物開啟和提交的代碼,而真正執行代碼是通過methodB.invoke(原始對象) 而A方法的實現內部雖然包含了this.B方法 但其實是調用了methodA.invoke(原始對象),而這一句代碼相當於調用的是原始對象的methodA方法,而這裡面的this.B()方法其實是調用的原始對象的B方法,沒有進行過事物增強,而如果是通過cglib做位元組碼增強,生成這個類的子類,這種調用this.B方法是有事物效果的

Ⅱ.rpc consumer

有過RMI開發經驗的人可能會很熟悉,為什麼在對外export rmi服務的時候會分別在client和server生成兩個stub文件,其中client的文件其實就是用動態代理生成了一個代理類 這個代理類,實現了所要對外提供服務的所有介面,每個方法的實現其實就是將介面信息,方法聲明,參數,返回值信息通過網路發給服務端,而服務端收到請求後通過找到對應的實現然後用反射method.invoke進行調用,然後將結果返回給客戶端

其實其他的RPC框架的實現方式大致和這個類似,只是客戶端的代理類,可能不僅要將方法聲明通過網路傳輸給服務提供方,也可以做一下服務路由,負載均衡,以及傳輸一些額外的attachment數據給provider

---

更多關於Java的技術和資訊可以關注我的專欄：

Java架構築基?

zhuanlan.zhihu.com

專欄免費給大家分享Java架構的學習資料和視頻

推薦閱讀：