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

缺乏、安全感 2022-12-21 03:27 83阅读 0赞

反射：框架设计的灵魂；

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

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

在这里对Java虚拟机有了解之后，[对jvm的了解可以参考这个系列的博文][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][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);
    }
    }

1.  获取构造

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);
    	}
    }

1.  获取成员方法

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);
    	}
    }

[jvm]: https://blog.csdn.net/qq_44973159/category_10163120.html
[Class_ https_www.matools.com_api_java8]: https://www.matools.com/api/java8