java反射机制历史_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 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);

}

}

}