Java中级必备技 -- 反射机制

反射：框架设计的灵魂；

• 框架：半成品软件，在框架的基础上进行开发，可以简化编码

反射的定义： 将类的各个组成部分封装为其他对象，这就是反射机制

在这里对Java虚拟机有了解之后，对jvm的了解可以参考这个系列的博文
对反射的理解简单来说就是由class文件封装进内存的class类对象。

而使用反射的优点又是什么呢？

• 可以在程序运行过程中，操作这些对象
• 可以进行解耦，提高程序的可扩展性

简单的反射案例（Eclipse、idea）

在很多的地方都是用到了反射，就像eclipes或者idea这种开发工具，在定义一个String类型的变量，然后使用这个变量.这个时候后续会弹出这个String类的方法，在这个地方就使用到了反射的机制，在打开这个工具之后就将所需要的方法等加载到了内存，在使用的时候就直接加载出来。

获取class类对象的三种方式

分别对应了java代码进行运行的三个阶段，

• 第一阶段：在编译java代码之后还未写入内存之前，使用Class.forName(“全类名”)
• 第二阶段：在写入内存后，还未创建对象时，使用 类名.class 进行获取
• 第三阶段：在创建了这个类的对象之后，使用 对象.getclass 进行获取

在这里使用代码进行测试，先定义一个Person类用来获取类对象，之后使用一个测试类，调用上面的三个方法进行测试：并且比较三个对象是否相同，代码如下：

package com.lzq.test;

import com.lzq.ClassName.Person;

public class ClassTest {

	public static void main(String[] args)throws Exception {
		//1
		Class class1 = Class.forName("com.lzq.ClassName.Person");
		System.out.println(class1);
		//2
		Class class2 = Person.class;
		System.out.println(class2);
		//3
		Person person= new Person();
		Class class3 =  person.getClass();
		System.out.println(class3);
		
		System.out.println(class1 == class2 );
		System.out.println(class2 == class3 );

	}
}

输出的结果是一致的，故：当同一个字节码文件在同一次程序运行过程中，只会被加载一次，所以产生的对象时同一个。

class类对象的使用：参考java API，在类对象当中大部分方法都是get获取方法
Java api Class类 https://www.matools.com/api/java8

在这里主要我们对变量、构造方法、内部方法进行获取进行测试，在这之前我们需要定义过用于初始化的类，在这里以Person类为例：添加变量，构造，方法等。

package com.lzq.ClassName;

public class Person {

	private String name;
	private int age;
	public int height;

	public int getHeight() {
		return height;
	}

	public Person() {

	}

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", height=" + height + "]";
	}

	public void setHeight(int height) {
		this.height = height;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public void say() {
		System.out.println("say...");
	}
	public void eat(String food) {
		System.out.println("eat..."+food);
	}
	private void eat() {
		System.out.println("eat...");
	}
}

1. 获取变量

package com.lzq.test;
import java.lang.reflect.Field;
import com.lzq.ClassName.Person;

public class VariableTest {
	public static void main(String[] args) throws Exception{
		Class c = Person.class;
		//获取所有public修饰的成员变量
		Field [] fields = c.getFields();
		for(Field field : fields) {
			System.out.println(field);
		}
		
		System.out.println("--------");
		Field f =  Person.class.getField("height");
		Person p =  new Person();
		System.out.println(f.get(p));
		f.set(p,154);
		System.out.println(p);
		
		
		System.out.println("---------");
		Field [] fieldsD = c.getDeclaredFields();
		for(Field field : fieldsD) {
			System.out.println(field);
		}
		
		System.out.println("---------");
		Field fd =  c.getDeclaredField("age");
		fd.setAccessible(true);
		System.out.println(fd.get(p));
		fd.set(p,18);
		System.out.println(p);
}
}

2. 获取构造

package com.lzq.test;
import java.lang.reflect.Constructor;
import com.lzq.ClassName.Person;
public class ConstructionMethodTest {
	public static void main(String[] args) throws Exception {
		Class c = Person.class;
		//有参构造
		Constructor constructor = c.getConstructor(String.class,int.class);
		System.out.println(constructor);
		//创建对象
		Object obj = constructor.newInstance("张三",18);
		System.out.println(obj);
		
		//空参构造
		Object obj1 = c.newInstance();
		System.out.println(obj1);
	}
}

3. 获取成员方法

package com.lzq.test;
import java.lang.reflect.Method;
import com.lzq.ClassName.Person;
public class MemberMethod {
	public static void main(String[] args) throws Exception {
		Class c = Person.class;
		Method m = c.getMethod("say");
		m.invoke(new Person());

		Method eat = c.getMethod("eat", String.class);
		eat.invoke(new Person(), "rich");

		// 所有public修饰的方法
		Method[] ms = c.getMethods();
		for (Method method : ms) {
			System.out.println(method);
			//获取方法名
			String name = method.getName();
			System.out.println(name);
		}
		//全类名
		System.out.println(c.getName());
	}
}

案例实现：我们编写一个“框架”用来进行获取类，加载类的方法并且执行。

在这里，对框架来说，我们都需要对配置文件进行配置，也就是在这里我们添加一个配置文件，然后再用java封装好的类进行获取类并且执行方法。

添加一个配置文件pro.properties，在配置文件当中进行配置一个要加载的类名和方法名，如下：

className=com.lzq.ClassName.Person
methodName=say

之后我们读取这个配置文件进行测试：代码如下

package com.lzq.test;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

public class Automatic {

	public static void main(String[] args) throws Exception {
		// 创建对象
		Properties pro = new Properties();
		// 加载配置文件
		ClassLoader classLoader = Automatic.class.getClassLoader();
		InputStream is = classLoader.getResourceAsStream("pro.properties");
		pro.load(is);

		// 获取配置文件中的内容
		String className = pro.getProperty("className");
		String methodName = pro.getProperty("methodName");
		// System.out.println(className+""+methodName);

		// 加载这个类
		Class class1 = Class.forName(className);

		Object obj = class1.newInstance();

		Method m = class1.getMethod(methodName);
		m.invoke(obj);
	}
}