为什么写这个呢？ 答案在最后。。。
Java反射机制
java的反射机制是指在程序在运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任选一个对象和方法。这种动态获取程序信息以及动态调用对象的功能称为java语言的反射机制。
原理+示例
java类的class字节码文件被类加载器加载到JVM中，生成对应的java.lang.Class对象实例，通过该Class对象可以获得对应类中的成员变量和方法（构造方法Constructor和成员方法Method）。
有三种方式可以获得类的Class对象实例：
- Object的getClass()方法
// 创建对象，通过对象的getClass()方法获取Class对象实例
Class clazz = new HelloWorld().getClass();
- 类型的.class
// 通过类型的class获得Class实例
Class clazz = HelloWorld.class;
- Class.forName(“类的完全限定名”)
// 通过Class.forName("类的完全限定名")获取Class对象实例
try {
Class clazz = Class.forName("com.learn.demo.reflection.HelloWorld");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
为了更清楚的展示Java反射机制，我们直接上代码
创建两个类分别是Reflection 和 HelloWorld
// 创建对象，通过对象的getClass()方法获取Class对象实例
Class clazz0 = new HelloWorld().getClass();
System.out.println(clazz0.getClassLoader());
System.out.println(clazz0);
// 通过类型的class属性获取Class对象实例
Class clazz1 = HelloWorld.class;
System.out.println(clazz0.getClassLoader());
System.out.println(clazz1);
System.out.println(clazz0 == clazz1);
// 通过Class.forName("类的完全限定名")获取Class对象实例
Class clazz2 = Class.forName("com.learn.demo.reflection.HelloWorld");
System.out.println(clazz0.getClassLoader());
System.out.println(clazz2);
System.out.println(clazz0 == clazz2);
我们通过三种方式获得到的Class对象实例，通过Class对象实例的getClassLoader()方法获得到加该类的类加载器。
从输出内容我们看到了什么？
1，使用的类加载器是一致的。
2，获得到的HelloWorld的Class对象实例是同一个，代码里通过==号比较结果为true。
思考：如果使用不同的类加载器加载同一个类， 那得到的Class对象实例还会是同一个吗？
这个问题暂不在这里讨论。。。 自己可以做测试一下。
上面已经分别通过三种方式获得到了类的Class对象实例，下一步我们可以做些什么呢？
- 获得类的构造方法
我们先在HelloWord类中添加几个构造方法。
public class HelloWorld {
private int id;
private String title;
public HelloWorld(){}
public HelloWorld(int id){
this.id = id;
}
public HelloWorld(int id, String title){
this.id = id;
this.title = title;
}
private HelloWorld(String title){
this.title = title;
}
}
// 通过Class.forName("类的完全限定名")获取Class对象实例
Class clazz = Class.forName("com.learn.demo.reflection.HelloWorld");
//通过getConstructors()方法获得类的public修饰的构造方法
Constructor[] constructors = clazz.getConstructors();
System.out.println("public的构造方法数量：" + constructors.length);
for (Constructor constructor : constructors) {
Parameter[] parameters = constructor.getParameters();
System.out.println("构造方法参数数量：" + parameters.length);
for (Parameter parameter : parameters) {
// 控制台打印参数名称和参数类型
System.out.println(parameter.getName() + "\t" + parameter.getType());
}
}
这里我们通过Class对象实例的getConstructors()方法获得类的构造方法，这里我们看到获得到的构造方法数量为3，实际上我们在HelloWorld类中有4个构造方法，这里我们根据参数数量及参数类型可以判断出，private修饰的构造方法实际未被获取到。
要得到类的全部构造方法我们可以通过getDeclaredConstructors()方法来获得类的全部构造方法，上代码：
// 通过Class.forName("类的完全限定名")获取Class对象实例
Class clazz = Class.forName("com.learn.demo.reflection.HelloWorld");
//通过getConstructors()方法获得类的public修饰的构造方法
//Constructor[] constructors = clazz.getConstructors();
Constructor[] constructors = clazz.getDeclaredConstructors();
System.out.println("public的构造方法数量：" + constructors.length);
for (Constructor constructor : constructors) {
Parameter[] parameters = constructor.getParameters();
System.out.println("构造方法参数数量：" + parameters.length);
for (Parameter parameter : parameters) {
// 控制台打印参数名称和参数类型
System.out.println(parameter.getName() + "\t" + parameter.getType());
}
}
从控制台输出，我们看到已经获得到HelloWorld类的全部构造方法了。
获取到类的构造方法， 那我们就可以通过构造方法创建类的实例对象了，上代码：
// 也可以通过getConstructor(Class<?>... parameterTypes)直接得到构造方法实例
// 通过构造方法实例通过newInstance方法创建一个类对象实例。
// 构造方法-一个int类型参数的构造方法
Constructor constructor0 = clazz.getConstructor(int.class);
Object obj0 = constructor0.newInstance(1);
// 构造方法-一个int类型参数和一个String类型参数的构造方法
Constructor constructor1 = clazz.getConstructor(int.class, String.class);
Object obj1 = constructor1.newInstance(2, "我出生了！");
// 构造方法-无参数的构造方法
Constructor constructor = clazz.getConstructor();
Object obj = constructor.newInstance();
// 无参数的构造方法创建类对象可以直接通过这种方式来创建。
obj = clazz.newInstance();
3. 获得类的成员方法
我们先在HelloWord类中添加几个成员方法。
public class HelloWorld {
private int id;
private String title;
public HelloWorld(){}
public HelloWorld(int id){
this.id = id;
}
public HelloWorld(int id, String title){
this.id = id;
this.title = title;
}
private HelloWorld(String title){
this.title = title;
}
public void getA(int a){
System.out.println("getA: " + a);
}
public void getA(int a, String b){
System.out.println("getA===::: a:" + a + "\t b:" + b);
}
private void getB(String b){
System.out.println("getB: " + b);
}
}
// 获得类的public成员方法
Method[] methods0 = clazz.getMethods();
for (Method method : methods0) {
System.out.println(method.getName() + "\t" + method.getParameterCount());
}
System.out.println("===============================================");
// 获得类的所有成员方法
Method[] methods1 = clazz.getDeclaredMethods();
for (Method method : methods1) {
System.out.println(method.getName() + "\t" + method.getParameterCount());
}
分别用getMethods方法和getDeclaredMethods方法获取类的方法，自己看区别哈！
也可以通过getMethod(String name, Class<?>… parameterTypes)方法直接获取方法实例。
// 直接通过getMethod(String name, Class<?>... parameterTypes)获取方法实例
Method method = clazz.getMethod("getA", int.class);
// 通过Method实例的invoke方法来调用该实例方法
method.invoke(obj, 1);
输出结果 ：
这里我们看到确实调用了HelloWorld的getA方法，并在控制台输出了内容。
也可以通过getDeclaredMethod(String name, Class<?>… parameterTypes)方法直接获取private方法实例。
// 直接通过getDeclaredMethod(String name, Class<?>... parameterTypes)获取方法实例
Method method = clazz.getDeclaredMethod("getB", String.class);
// 设置访问属性为true
method.setAccessible(true);
// 通过Method实例的invoke方法来调用该实例方法
method.invoke(obj, "大家好！我是b。");
输出结果 ：
- 获得类的成员变量
// 通过getDeclaredFields方法获取private成员变量
Field [] fields = clazz.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName() + "\t" + field.getType());
}
输出结果：
这里直接使用getDeclaredFields方法获取所有成员变量了， 因为HelloWorld类中未定义public的成员变量，这里就不做测试了， 如感兴趣可以自行敲一下代码。
获取private的成员变量并赋值，然后在控制台输出：
// 通过getDeclaredField(String name)获取成员变量
Field field = clazz.getDeclaredField("id");
// 因id是private修饰的，所在这里要设置该成员变量可访问
field.setAccessible(true);
// 设置成员变量的值
field.set(obj, 111);
// 获取值并输出
System.out.println(field.getInt(obj));
留给你的：可以添加一个getId方法，用前面介绍的调用该方法的方式来获取id的值。可以自己动手写一下。。。
以上仅介绍了获取类构造方法，并通过构造方法创建类实例对象，获取类成员方法，通过invoke调用方法，获取成员变量，给成员变量赋值等简单示例，实际上还有很多东西没介绍到，需要自己动手去发现。。。
获取类的注解，方法的注解，变量的注解。。。 是不是可以想到注解的实现原理了呢？
Spring中大量使用了Java反射机制，是Java反射机制很好的实践项目。
Spring的AOP和IOC… 继续学习吧
好了， 基本就到这里了
前面讲到的为什么要写这个呢， 啊哈哈！ 不说， 你猜！
不仅要做到知其然，还要做到知其所以然…
转载请注明出处，谢谢！
128
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
