java反射原来是这么玩的（反射一开，谁都不爱）

反射的发展历史

1996年01月23日，jdk 1.0版本发布，代号为Oak（橡树）。

这个代号为Oak（橡树）的版本，在发布后的第二年，1997年02月19日，发布jdk 1.1版本，这次版本发布中引入了反射机制。

关于反射机制，由于年代久远，能搜索到对于反射机制的记载少之又少，能找到最为久远的是一篇题为《Using Java Reflection》的文章，发表于 1998年1月，文中提到：反射是一个可以获取java类、属性的一个工具，因为它是动态加载的。

而在另外一篇文章《A Button is a Bean》里解释道，反射是为了能把一个类的属性可视化的展示给用户，如下图所示：

通俗的解释就是：无论是公有还是私有的方法、属性、构造方法，全都可以用反射进行获取、进行赋值、调用。听到这个解释，是不是感觉反射很强。

正因为反射的强大，在java世界里运用的地方有很多，比如：Java类加载和初始化、Java中RTTI、Spring的IOC，。

如此广泛的运用，只能说反射除了强，用起来肯定很爽。我想起我的同事，IT界的刁民，总是热衷于反射。

他在讲解他是如何运用反射时，嘴角总是压抑不住的微笑，这种迷恋反射的样子，像极了爱情。

正所谓：反射一开，谁都不爱。（傲娇）

下面就看看反射究竟是如何在程序中使用的。

反射的概述和使用

反射的概述

JAVA反射机制是在运行状态中，

对于任意一个类，都能够知道这个类的所有属性和方法；

对于任意一个对象，都能够调用它的任意一个方法和属性；

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

我们知道class文件是在编译的时候生成的，Class对象是将class文件读入内存，并为之创建一个Class对象。

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

Class类里面，包含了一个类应有的所有描述，包括：

字段：Field.java

方法：Method.java

构造方法：Constructor.java

等等...

知道了Class类里面包含了哪些内容之后，再看一下new一个对象的究竟会发生那些过程：

反射的使用

这里使用一个Animal类来作为示范，可以看到这个类里的成员变量、方法、构造方法的访问修饰符既有public、也有private的。下面就将使用反射获取不同修饰符修饰的成员变量、方法、构造方法。

package com.shuai.ioc.ref;public class Animal { /**
* 动物名字
*/
public String name; /**
* 动物年龄
*/
protected int age; @Override
public String toString() {
return "Animal{" +
"name='" + name + '\'' +
", age=" + age +
'}';
} /**
* 默认的构造方法
*
* @param name
*/
Animal(String name) {
System.out.println("执行了" + "默认的构造方法 " + name);
} /**
* 无参构造方法
*/
public Animal() {
System.out.println("执行了" + "无参构造方法 ");
} /**
* 有一个参数的构造方法
*
* @param name
*/
public Animal(char name) {
System.out.println("执行了" + "有一个参数的构造方法 name:" + name); } /**
* 有多个参数的构造方法
*
* @param name
* @param age
*/
public Animal(String name, int age) {
System.out.println("执行了" + "有多个参数的构造方法 name:" + name + "age:" + age);
} /**
* protected的构造方法
*
* @param n
*/
protected Animal(boolean n) {
System.out.println("执行了" + "受保护的构造方法 n:" + n);
} /**
* 私有构造方法
*
* @param age
*/
private Animal(int age) {
System.out.println("执行了" + "私有构造方法 age:" + age);
this.name = "私有构造方法调用成功";
this.age = age;
} /**
* 公有方法
*
* @param s
*/
public void public1(String s) {
System.out.println("调用了" + "公有的方法" + "： public1 , s:" + s);
} /**
* protected的方法
*/
protected void protected2() {
System.out.println("调用了" + "protected的方法" + "： protected2 ");
} /**
* 友好的方法
*/
void friendly1() {
System.out.println("调用了" + "友好的方法" + "： friendly1 ");
} /**
* 私有方法
*
* @param age
* @return
*/
private String private1(int age) {
System.out.println("调用了" + "私有方法" + "： private1 ，age：" + age);
return age + "";
}}


用反射获取类的构造方法

在Class类中，提供一系列获取被反射类构造方法的方法。

• 批量获取构造方法的方法
  • public Constructor[] getConstructors()：所有"公有的"构造方法
  • public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
• 获取单个的方法，并调用
  • public Constructor getConstructor(Class... parameterTypes)：获取单个的"公有的"构造方法
  • public Constructor getDeclaredConstructor(Class... parameterTypes)：获取"某个构造方法"可以是私有的，或受保护、默认、公有；
• 调用构造方法
  • newInstance(Object... initargs)

package com.shuai.ioc.ref;import com.shuai.ioc.Book;import java.lang.reflect.Constructor;public class ConstructorsTest { public static void main(String[] args) throws Exception { //1.加载Class对象
Class clazz = Class.forName("com.shuai.ioc.ref.Animal"); //2.获取所有公有构造方法
System.out.println("所有公有构造方法");
Constructor[] conArray = clazz.getConstructors();
for (Constructor c : conArray) {
System.out.println(c);
} // 所有的构造方法，公有、私有都行
System.out.println("");
System.out.println("所有的构造方法，包括：私有、受保护、默认、公有");
conArray = clazz.getDeclaredConstructors();
for (Constructor c : conArray) {
System.out.println(c);
} // 获取公有、无参的构造方法
System.out.println("");
System.out.println("获取公有、无参的构造方法");
Constructor con = clazz.getConstructor(null); System.out.println("con = " + con);
//调用构造方法
Object obj = con.newInstance(); // 获取私有构造方法
System.out.println("");
System.out.println("获取私有构造方法，并调用");
con = clazz.getDeclaredConstructor(int.class);
System.out.println(con);
//暴力访问，忽略掉访问修饰符
con.setAccessible(true);
//调用构造方法
Animal animal = (Animal) con.newInstance(1);
System.out.println(animal.toString()); }
}


用反射获取类的方法

在Class类中，提供一系列获取被反射类构造方法的方法。

• 批量的
  • public Method[] getMethods()：获取所有"公有方法"；（包含了父类的方法也包含Object类）
  • public Method[] getDeclaredMethods()：获取所有的成员方法，包括私有的(不包括继承的)
• 获取单个的
  • public Method getMethod(String name,Class<?>... parameterTypes)，name： 方法名；Class ... ：形参的Class类型对象
  • public Method getDeclaredMethod(String name,Class<?>... parameterTypes)，obj：要调用方法的对象；args：调用方式时所传递的实参；
• 调用方法
  • public Object invoke(Object obj,Object... args)，obj:要调用方法的对象；args：调用方式时所传递的实参；

package com.shuai.ioc.ref;import java.lang.reflect.Method;public class MethodClassTest { public static void main(String[] args) throws Exception {
//1.获取Class对象
Class stuClass = Class.forName("com.shuai.ioc.ref.Animal"); //2.获取所有公有方法
System.out.println("获取所有 公有 方法");
stuClass.getMethods();
Method[] methodArray = stuClass.getMethods();
for (Method m : methodArray) {
System.out.println(m);
} System.out.println();
System.out.println("获取所有的方法，包括私有的");
methodArray = stuClass.getDeclaredMethods();
for (Method m : methodArray) {
System.out.println(m);
} System.out.println();
System.out.println("获取公有的public1()方法");
Method m = stuClass.getMethod("public1", String.class);
System.out.println(m);
//实例化一个Student对象
Object obj = stuClass.getConstructor().newInstance();
m.invoke(obj, "this is name value"); System.out.println();
System.out.println("获取私有的private1()方法");
m = stuClass.getDeclaredMethod("private1", int.class);
System.out.println(m);
m.setAccessible(true);//解除私有限定
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
System.out.println("返回值：" + result); }
}


用反射获取类的字段

在Class类中，提供一系列获取被反射类构造方法的方法。

• 批量的
  • Field[] getFields():获取所有的"公有字段"
  • Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；
• 获取单个的
  • public Field getField(String fieldName):获取某个"公有的"字段；
  • public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)
• 设置字段的值
  • public void set(Object obj,Object value)：obj:要设置的字段所在的对象；value：要为字段设置的值；

package com.shuai.ioc.ref;import java.lang.reflect.Field;public class FieldsTest { public static void main(String[] args) throws Exception {
//1.获取Class对象
Class animalClass = Class.forName("com.shuai.ioc.ref.Animal");
//2.获取字段
System.out.println("获取所有公有的字段");
Field[] fieldArray = animalClass.getFields();
for (Field f : fieldArray) {
System.out.println(f);
} System.out.println();
System.out.println("获取所有的字段(包括私有、受保护、默认的)");
fieldArray = animalClass.getDeclaredFields();
for (Field f : fieldArray) {
System.out.println(f);
} System.out.println();
System.out.println("获取公有字段并调用");
Field f = animalClass.getField("name");
System.out.println(f);
//获取一个对象
Object obj = animalClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
//为字段设置值
f.set(obj, "dog");//为Student对象中的name属性赋值--》stu.name = "刘德华"
//验证
Animal stu = (Animal) obj;
System.out.println("验证name：" + stu.name); System.out.println();
System.out.println("获取私有字段并调用");
f = animalClass.getDeclaredField("name");
System.out.println(f);
f.setAccessible(true);//暴力反射，解除私有限定
f.set(obj, "this is name value");
System.out.println("验证name：" + stu); }
}


反射越过泛型检查

编写代码时，如果我们设置容器list为String类型，在调用add方法插入数据时入参传了其他类型，编译时会无法成功，但是通过反射却可以执行，实例代码：

package com.shuai.ioc.ref;import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;/*
* 通过反射越过泛型检查
*
*/
public class IgnoreType {
public static void main(String[] args) throws Exception {
List<String> list = new ArrayList<>();
list.add("one");
//反射获取list对象
Class listClass = list.getClass();
// 调用list对象的add方法
Method m = listClass.getMethod("add", Object.class);
m.invoke(list, 100);
//输出验证
for (Object obj : list) {
System.out.println(obj);
}
}
}