在造轮子:实现一个简易的 Spring IoC 容器一文中提到 Spring 在创建 Bean 实例和依赖注入时使用了反射,本文来具体分析一下 Spring 中的反射以及反射的原理。
// 通过类加载器,根据 class 路径,得到其类对象
Class<?> clz = Thread.currentThread().getContextClassLoader().loadClass("org.deppwang.litespring.v1.service.PetStoreService");
// 根据类对象生成 Bean 实例
return clz.newInstance();
反射体现在 clz.newInstance();
中,核心代码可分为两部分:
1 、利用反射获取当前类 PetStoreService 的所有构造方法信息( Constructor 对象)
// java.lang.Class.java
// 调用 native 方法,此时 publicOnly 为 false
res = getDeclaredConstructors0(publicOnly);
// native 方法,从 jvm 中的 class 文件中获取构造方法信息,再转换为 Constructor 对象
private native Constructor<T>[] getDeclaredConstructors0(boolean publicOnly);
2 、利用反射通过默认构造方法生成实例
// sun.reflect.NativeConstructorAccessorImpl.java
// 调用 native 方法,var1 代表构造方法的参数,此时为 null
return newInstance0(this.c, var1);
// native 方法,真正生成实例的方法,执行 class 文件的构造方法 <init>
private static native Object newInstance0(Constructor<?> var0, Object[] var1);
// 通过反射获取当前类所有的构造方法信息( Constructor 对象)
Constructor<?>[] candidates = beanClass.getDeclaredConstructors();
// 设置构造方法参数实例
Object[] argsToUse = new Object[parameterTypes.length];
argsToUse[i] = getBean(beanNames.get(i));
// 使用带有参数的 Constructor 对象实现实例化 Bean 。此时使用反射跟上面一样( newInstance0 ),只是多了参数
return constructorToUse.newInstance(argsToUse);
// 通过反射获取当前类所有的方法信息( Method 对象)
Method[] methods = bean.getClass().getDeclaredMethods();
// 获得方法参数实例
Object propertyBean = getBean(propertyName);
// 通过反射执行调用 setter() 方法。invoke:调用方法,propertyBean 作为方法的参数
method.invoke(bean, propertyBean);
bean.getClass().getDeclaredMethods(); 中的核心代码:
// java.lang.Class.java
// 调用 native 方法,publicOnly 为 false
getDeclaredMethods0(publicOnly);
// native 方法,从 jvm 中的 class 文件中获取方法信息,再转换为 Method
private native Method[] getDeclaredMethods0(boolean publicOnly);
method.invoke(bean, propertyBean); 中的核心代码:
// sun.reflect.NativeMethodAccessorImpl.java
// 调用 native 方法,var1: bean 、var2: propertyBean
return invoke0(this.method, var1, var2);
// native 方法,运行 class 文件中的字节码指令
private static native Object invoke0(Method var0, Object var1, Object[] var2);
// 通过反射得到当前类所有的字段信息( Field 对象)
Field[] fields = bean.getClass().getDeclaredFields();
// 判断字段是否有 @Autowired 注解
Annotation ann = field.getAnnotation(Autowired.class);
// 设置字段可连接,相当于将非 public ( private 、default 、protect )更改为 public
field.setAccessible(true);
// 通过反射设置字段的值
field.set(bean, getBean(field.getName()));
bean.getClass().getDeclaredFields(); 中的核心代码:
// java.lang.Class.java
// 调用 native 方法,此时 publicOnly 为 false
getDeclaredFields0(publicOnly);
// native 方法,从 jvm 中获取 class 文件的字段信息,再转换为 Field
private native Field[] getDeclaredFields0(boolean publicOnly);
field.set(bean, getBean(field.getName())); 中的核心代码:
// sun.reflect.UnsafeObjectFieldAccessorImpl.java
// 调用 native 方法,将目标对象 var1 指定偏移量 fieldOffset 处的字段值设置(修改)为 var2 。var1 为 bean, var2 为参数实例
unsafe.putObject(var1, this.fieldOffset, var2);
// sun.misc.Unsafe.java
// native 方法,直接修改堆中对象字段的数据
public native void putObject(Object var1, long var2, Object var4);
class 文件由 java 文件编译而来,class 文件包含字段表、方法表、<init>
方法(构造方法)等。
当类加载器将 class 文件加载进虚拟机元数据区(方法区,jdk1.7 )时,虚拟机创建一个与之对应的类对象( Class 实例)。并将 class 文件由存放在磁盘的静态结构转换为存放在内存的运行时结构。
我们可以认为一个类( class 文件)对应一个类对象,当前类的所有对象共用一个类对象。类对象作为访问存放在 jvm 的 class 文件的入口。
package java.lang;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
public final class Class<T> {
private native Field[] getDeclaredFields0(boolean publicOnly);
private native Method[] getDeclaredMethods0(boolean publicOnly);
private native Constructor<T>[] getDeclaredConstructors0(boolean publicOnly);
// ReflectionData 缓存反射对象
private static class ReflectionData<T> {
volatile Field[] declaredFields;
volatile Field[] publicFields;
volatile Method[] declaredMethods;
volatile Method[] publicMethods;
volatile Constructor<T>[] declaredConstructors;
volatile Constructor<T>[] publicConstructors;
...
}
}
// 1 、通过对象
Class cls = object.getClass();
// Object.java
public final native Class<?> getClass();
// 2 、通过类加载器
Class cls = Thread.currentThread().getContextClassLoader().loadClass("org.deppwang.litespring.v1.service.PetStoreService");
// 3 、通过 Class 类,本质上也是通过类加载器
Class cls = Class.forName("org.deppwang.litespring.v1.service.PetStoreService");
// Class.java
private static native Class<?> forName0(String name, boolean initialize,
ClassLoader loader,
Class<?> caller)
以下是常用的反射方法。
Field[] fields = cls.getFields(); // 获取所有公共的 Field (包括父类)
Field[] fields = cls.getDeclaredFields(); // 获取当前类的所有 Field (不包括父类),包括公共和非公共
Field field = cls.getDeclaredField("fieldName"); // 指定获取当前类某个 Field
field.set(Object, Object); // 设置(修改)字段值
field.get(Object); // 获取字段值
field.get(Object) 核心代码:
// 调用 native 方法,获取字段对应的值
return unsafe.getObject(var1, this.fieldOffset);
// native 方法,从堆中获取对象指定位置的对象
public native Object getObject(Object var1, long var2);
Method[] methods = cls.getMethods(); // 获取所有公共的 Method (包括父类)
Method[] methods = cls.getDeclaredMethods(); // 获取当前类的所有 Method (不包括父类),包括公共和非公共
method.invoke(Object instance, Object... parameters); // 运行方法
运行方法使用场景:要么是修改对象的数据,如 void setter() 方法;要么是获得执行方法的返回结果。
String result = method.invoke().toString();
Constructor<?>[] constructors = cls.getConstructors(); // 获取所有公共的 Constructor (包括父类)
Constructor<?>[] constructors = cls.getDeclaredConstructors(); // 获取当前类的所有 Constructor (不包括父类),包括公共和非公共
constructor.newInstance(Object... parameters); // 运行构造方法
当没有明确编写构造方法,Java 编译器将为该类构建一个默认构造函数 <init>
Java 1.1 新增「 Java 本地接口」(Java Native Interface,JNI),JNI 是一种包容极广的编程接口,允许我们从 Java 应用程序里调用 native 方法,native 方法由其它语言( C 、C++ 或汇编语言等)编写。native 方法用于实现 Java 无法处理的功能。
一个在 Java 中使用 Java 本地接口( JNI )的简单示例。
// Main.java
public class Main {
public native int intMethod(int i);
static {
// 启动时载入 libMain.dylib
System.loadLibrary("Main");
}
public static void main(String[] args) {
System.out.println(new Main().intMethod(2));
}
}
// Main.c:
// 将 Main.h 引入
#include "Main.h"
// 相当于继承 "Main.h" 的 Java_Main_intMethod
JNIEXPORT jint JNICALL Java_Main_intMethod(
JNIEnv *env, jobject obj, jint i)
{
return i * i;
}
编译与运行:
// 同时生成 Main.class 和 Main.h
javac Main.java -h .
// 根据 Main.c 生成 libMain.dylib
gcc -dynamiclib -O3 \
-I/usr/include \
-I$JAVA_HOME/include \
-I$JAVA_HOME/include/darwin \
Main.c -o libMain.dylib
// 指定 library 的路径为当前路径
java -cp . -Djava.library.path=$(pwd) Main
输出:
4
/* Main.h .h 作为头文件*/
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class Main */
#ifndef _Included_Main
#define _Included_Main
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: Main
* Method: intMethod
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_Main_intMethod
(JNIEnv *, jobject, jint);
#ifdef __cplusplus
}
#endif
#endif
javac Main.java -h .
// 可拆分为两个命令
javac Main.java
javah -jni Main
运行 Main.class 时,将 libMain.dylib 载入虚拟机,JVM 调用 libMain.dylib 的 Java_Main_intMethod,传入参数,libMain.dylib 由系统直接运行,返回结果。
/*C code*/
JNIEXPORT void JNICALL Java_ClassName_MethodName
(JNIEnv *env, jobject obj, jstring javaString)
{
/*Get the native string from javaString*/
const char *nativeString = (*env)->GetStringUTFChars(env, javaString, 0);
/*Do something with the nativeString*/
/*DON'T FORGET THIS LINE!!!*/
(*env)->ReleaseStringUTFChars(env, javaString, nativeString);
}
反射反射,哪里体现反射字面意思?
可以这么理解,通过 native 方法得到反射对象,操作反射对象,像镜子一样,将反射到原对象上。
我们发现,反射和 native 方法的关系:
我们可以得出结论,反射由 native 方法实现。
我们说通过反射实现一个功能,我们也可以说
反射是一种非常规( native 方法实现)方式获取 class 文件信息、运行 class 文件字节码指令和操作对象数据的能力。
一句话总结 :反射是一种运行时获取和修改对象数据的能力。
关于运行时:Java 是静态语言,先编译,后运行。编译时不执行代码,代码都是运行时执行。
这是一个专为移动设备优化的页面(即为了让你能够在 Google 搜索结果里秒开这个页面),如果你希望参与 V2EX 社区的讨论,你可以继续到 V2EX 上打开本讨论主题的完整版本。
V2EX 是创意工作者们的社区,是一个分享自己正在做的有趣事物、交流想法,可以遇见新朋友甚至新机会的地方。
V2EX is a community of developers, designers and creative people.