Java -- 浅入Java反射机制
1,Java 反射是Java语言的一个很重要的特征，它使得Java具体了“动态性”。
Java 反射机制主要提供了以下功能：
在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法。
在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中：
Class类：代表一个类。
Field 类：代表类的成员变量（成员变量也称为类的属性）。
Method类：代表类的方法。
Constructor 类：代表类的构造方法。
Array类：提供了动态创建数组，以及访问数组的元素的静态方法。
2,通过Class对象获取成员变量、成员方法、接口、超类、构造方法等。
API中给我们提供了一下方法
getName()：获得类的完整名字。 getFields()：获得类的public类型的属性。 getDeclaredFields()：获得类的所有属性。 getMethods()：获得类的public类型的方法。 getDeclaredMethods()：获得类的所有方法。 getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。 getConstructors()：获得类的public类型的构造方法。 getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。 newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。
下面就先从是用来说起吧
- 通过对象获取完整的包名和类名
public class TestReflect{
public static void main(String[] args){
TestReflect testReflect = new TestReflect();
System.out.println(testReflect.getClass().getName());
}
}
- 实例化class类对象
package com.qianmo.flowlayout.reflection;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
/**
* Created by wangjitao on 2017/3/28 0028.
* E-Mail：543441727@qq.com
* Java反射机制的简单实现
*/
public class TestReflect{
/**
* @param args
*/
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException, NoSuchFieldException {
Class<?> class1 = null;
Class<?> class2 = null;
Class<?> class3 = null;
class1 = Class.forName("com.qianmo.flowlayout.reflection.TestReflect");
class2 = new TestReflect().getClass();
class3 =TestReflect.class;
System.out.println("类名称："+class1.getName());
System.out.println("类名称："+class2.getName());
System.out.println("类名称："+class3.getName());
}
}
- 获取对象父类和实现的接口
package com.qianmo.flowlayout.reflection;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
/**
* Created by wangjitao on 2017/3/28 0028.
* E-Mail：543441727@qq.com
* Java反射机制的简单实现
*/
public class TestReflect{
/**
* @param args
*/
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException, NoSuchFieldException {
Class<?> clazz = Class.forName("com.qianmo.flowlayout.reflection.TestReflect");
//获取父类
Class<?> superClazz = clazz.getSuperclass();
System.out.println("父类名称："+superClazz.getName());
//获取所有接口
Class<?> intes[] = clazz.getInterfaces();
for (int i = 0; i < intes.length; i++) {
System.out.println("实现的接口有："+intes[i].getName());
}
}
}
- 通过反射得到一个类中的全部构造函数
先创建User类
package com.qianmo.flowlayout.reflection;
/**
* Created by wangjitao on 2017/3/29 0029.
* E-Mail：543441727@qq.com
*/
public class User {
private int age;
private String name;
public User() {
super();
}
public User(int age) {
super();
this.age = age;
}
public User(String name) {
super();
this.name = name;
}
public User(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
System.out.println("Java 反射机制 - 调用某个类的方法1.");
return age;
}
public void setAge(int age) {
this.age = age;
System.out.println("Java 反射机制 - 调用某个类的方法2.");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User [age=" + age + ",name:" + name + "]";
}
}
在main方法中调用
package com.qianmo.flowlayout.reflection;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
/**
* Created by wangjitao on 2017/3/28 0028.
* E-Mail：543441727@qq.com
* Java反射机制的简单实现
*/
public class TestReflect{
/**
* @param args
*/
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException, NoSuchFieldException {
Class<?> class1 = null;
class1 = Class.forName("com.qianmo.flowlayout.reflection.User");
//第一种方法使用默认的构造方法
User user_one = (User) class1.newInstance();
user_one.setAge(20);
user_one.setName("wangjitao");
System.out.println(user_one);
//第二种获取所有构造方法，使用构造函数赋值
Constructor<?> cons[] = class1.getConstructors();
//查看每一个构造方法中所需要的参数
for (int i = 0; i < cons.length; i++) {
System.out.print("cons[" + i + "] (");
Class<?> clazzs[] = cons[i].getParameterTypes();
for (int j = 0; j <clazzs.length ; j++) {
System.out.print(clazzs[j].getName()+",");
}
System.out.println(")");
}
//通过获取到的构造函数创建对象
user_one = (User) cons[0].newInstance(24,"wangjitao04");
System.out.println(user_one);
user_one = (User) cons[1].newInstance("wangjitao04");
System.out.println(user_one);
}
}
- 获取类中全部属性
Class<?> clazz = Class.forName("com.qianmo.flowlayout.reflection.User");
//获取本类中的全部属性
Field[] field = clazz.getDeclaredFields();
for (int i = 0; i < field.length; i++) {
//权限修饰符
String priv = Modifier.toString(field[i].getModifiers());
//属性类型
Class<?> type = field[i].getType();
System.out.println("修饰符：" + priv + ",属性类型：" + type.getName());
}
//获取实现的接口或者父类的属性
Field[] fild1 = clazz.getFields();
for (int i = 0; i <fild1.length ; i++) {
int mo = fild1[i].getModifiers();
String priv = Modifier.toString(mo);
// 属性类型
Class<?> type = fild1[i].getType();
System.out.println(priv + " " + type.getName() + " " + fild1[i].getName() + ";");
}
- 获取类中的全部方法
Class<?> clazz = Class.forName("com.qianmo.flowlayout.reflection.User");
Method method[] = clazz.getMethods();
for (int i = 0; i < method.length; i++) {
Class<?> returnType = method[i].getReturnType();
Class<?> para[] = method[i].getParameterTypes();
int temp = method[i].getModifiers();
System.out.println(method[i].getName() + "," + returnType.getName() + "," + Modifier.toString(temp));
for (int j = 0; j < para.length; j++) {
System.out.print(para[j].getName());
}
}
- 通过反射调用类中的方法
Class<?> clazz = Class.forName("com.qianmo.flowlayout.reflection.User");
Method method = clazz.getMethod("getAge");
method.invoke(clazz.newInstance());
method = clazz.getMethod("setAge", int.class);
method.invoke(clazz.newInstance(), 20);
- 通过反射操作类中的属性(包括私有属性)
Class<?> clazz = Class.forName("com.qianmo.flowlayout.reflection.User");
User user = (User) clazz.newInstance();
Field field = clazz.getDeclaredField("age");
field.setAccessible(true);
field.set(user, 50);
System.out.print(field.get(user));
通过以上的这些我们基本上可以在运行时候拿到一个类中成员变量、成员方法、接口、超类、构造方法等信息。
3，深入了解反射机制
一般来说Java中使用Class.fromName（）函数来生成Class对象，那我们来看看源码（这里只展示了主要的部分）
.......省略........
@CallerSensitive
public static Class<?> forName(String className)
throws ClassNotFoundException {
return forName(className, true, VMStack.getCallingClassLoader());
}
.......省略...........
@CallerSensitive
public static Class<?> forName(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException
{
if (loader == null) {
loader = BootClassLoader.getInstance();
}
Class<?> result;
try {
result = classForName(name, initialize, loader);
} catch (ClassNotFoundException e) {
Throwable cause = e.getCause();
if (cause instanceof LinkageError) {
throw (LinkageError) cause;
}
throw e;
}
return result;
}
/** Called after security checks have been made. */
static native Class<?> classForName(String className, boolean shouldInitialize,
ClassLoader classLoader) throws ClassNotFoundException;
Class.forName(classname)方法,实际上是调用了Class类中的 Class.forName(classname, true, currentLoader)方法。参数：name - 所需类的完全限定名；initialize - 是否必须初始化类；loader - 用于加载类的类加载器。currentLoader则是通过调用ClassLoader.getCallerClassLoader()获取当前类加载器的。类要想使用，必须用类加载器加载，所以需要加载器。反射机制，不是每次都去重新反射，而是提供了cache，每次都会需要类加载器去自己的cache中查找，如果可以查到，则直接返回该类。
而java的类加载器也很有意思，分为一下四类
BootStrap Class Loader(引导类加载器)； Extensions Class Loader (扩展类加载器)； App ClassLoader(或System Class Loader)； Custom ClassLoader(用户自定义类加载器)
类在加载的过程中，首先判断类是否被加载过，检测过程自底向上，首先从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个classloader已加载就视为已加载此类，保证此类只所有ClassLoader加载一次。而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类。这里如果没有检测到则调用BootStrap ClassLoader加载器
这幅图简单的说明了类加载器的类加载过程。先检查自己是否已经加载过该类，如果加载过，则直接返回该类，若没有则调用父类的loadClass方法，如果父类中没有，则执行findClass方法去尝试加载此类，也就是我们通常所理解的片面的"反射"了。这个过程主要通过ClassLoader.defineClass方法来完成。defineClass 方法将一个字节数组转换为 Class 类的实例（任何类的对象都是Class类的对象）。这种新定义的类的实例需要使用 Class.newInstance 来创建，而不能使用new来实例化。
