反射——框架设计的灵魂

反射——框架设计的灵魂

* 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
* 反射：将类的各个组成部分封装为其他对象，这就是反射机制
	* 好处：
		1. 可以在程序运行过程中，操作这些对象。
		2. 可以解耦，提高程序的可扩展性。

我们编写的java代码在计算机中会经历三个阶段：

当我们完成一个类的编写，点击运行时，Java代码经历了如下几个过程：
1.编译器会把“类名.java”文件编译为“类名.class”文件，这时该文件存储在硬盘中，并且分为“成员变量”、“构造方法”、“成员方法”三个部分。
2.通过类加载器的方法把这个class文件加载进内存，这时相当于使用FileInputStream把文件放到内存中，还不能运行其中的任何方法。
3.内存中会创建java.lang.Class的对象，用于接收这个加载进内存的，被分为“成员变量”、“构造方法”、“成员方法”三个部分的文件。
4.使用java.lang.Class中的方法getXXX()，得到三个部分java.lang.reflect.Field、java.lang.reflect.Constructor、java.lang.reflect.Method的对象。
5.分别使用三个部分的对象中的方法，来操作“成员变量”、“构造方法”、“成员方法”，这时这个类就在内存中运行了。
而反射就是将这个类在内存中创建对应的Class对象，并把其组成部分封装为其他对象的技术实现。

获取Class对象的方式

获取Class对象的方式：
		1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
			* 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
		2. 类名.class：通过类名的属性class获取
			* 多用于参数的传递
		3. 对象.getClass()：getClass()方法在Object类中定义着。
			* 多用于对象的获取字节码的方式

		* 结论：
			同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

public static void main(String[] args) throws ClassNotFoundException {
        //1.Class.forName
        Class aClass = Class.forName("cn.java.Pereson");
        System.out.println(aClass);
        //2.类名.class
        Class bClass = Pereson.class;
        System.out.println(bClass);
        //3.对象.getClass()
        Pereson p = new Pereson();
        Class cClass = p.getClass();
        System.out.println(cClass);
        //比较地址值，一次程序运行期间一个字节码文件只会被加载一次
        System.out.println(aClass == bClass);//true
        System.out.println(aClass == cClass);//true
    }

Class对象功能

//使用person类作为类字节码文件
public class Pereson {
    private String name;
    private int age;

    public String a = "aa";
    protected String b = "bb";
    String c = "cc";
    public String d = "dd";

    public void eat(){
        System.out.println("eat...");
    }
    public void eat(String food){
        System.out.println("eat..." + food);
    }
    //省略构造器，Getter,Setter,toString
}

1.获取成员变量

1. 获取成员变量们
				* Field[] getFields() ：获取所有public修饰的成员变量
				* Field getField(String name)   获取指定名称的 public修饰的成员变量

				* Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
				* Field getDeclaredField(String name) 

Field类中的一些方法：
			1. 设置值
				* void set(Object obj, Object value)  
			2. 获取值
				* get(Object obj) 

			3. 忽略访问权限修饰符的安全检查
				* setAccessible(true):暴力反射
注意：Class类对象的作用只是把类中的field抽取出来，Field设置值时，参数Object obj还是类在内存中创建的对象。

public static void main(String[] args) throws Exception {
        //0.通过类名的属性获取class类对象
        Class<Pereson> peresonClass = Pereson.class;
        Pereson p = new Pereson("张三", 15);//用于设置，获取其中的值
        //1.获取成员变量
        //被public修饰的
        Field[] fields = peresonClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
            System.out.println(field.get(p));//使用Field中的get方法得到p对象中的值
        }
        System.out.println("=================");
        Field a = peresonClass.getField("a");
        a.set(p,"阿拉");//field类中的set方法设置p对象中的成员值
        System.out.println(a);
        System.out.println(a.get(p));
        System.out.println("================");
        //全部权限的成员变量
        Field[] declaredFields = peresonClass.getDeclaredFields();
        Field.setAccessible(declaredFields,true);//Field静态方法setAccessible暴力反射,否则无法访问
        for (Field field : declaredFields) {
            System.out.println(field);
            System.out.println(field.get(p));
        }
        Field c = peresonClass.getDeclaredField("c");
        System.out.println(c);
        System.out.println(c.get(p));//没有设置暴力反射，报错IllegalAccessException

    }

2.获取构造方法

2. 获取构造方法们
				* Constructor<?>[] getConstructors()  
				* Constructor<T> getConstructor(类<?>... parameterTypes)  

				* Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  
				* Constructor<?>[] getDeclaredConstructors() 
				* 
Constructor类的方法：
		* 创建对象：
			* T newInstance(Object... initargs)  
			* 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

ublic static void main(String[] args) throws Exception {
        //0.
        Class peresonClass = Pereson.class;
        //1.
        Constructor c = peresonClass.getConstructor(String.class, int.class);//使用反射获取构造方法
        Object person = c.newInstance("李四", 54);//构造方法获取对象
        System.out.println(person);
        //如果是无参构造，如下写法比较麻烦
        Constructor c2 = peresonClass.getConstructor();
        Object person2 = c2.newInstance();
        System.out.println(person2);
        //可以使用Class类中的newInstance方法
        Object c3 = peresonClass.newInstance();
        System.out.println(c3);
    }

3.获取成员方法，4.获取全类名

3. 获取成员方法们：
				* Method[] getMethods()  
				* Method getMethod(String name, 类<?>... parameterTypes)  

				* Method[] getDeclaredMethods()  
				* Method getDeclaredMethod(String name, 类<?>... parameterTypes)  

			4. 获取全类名	
				* String getName()

Method类的方法
		* 执行方法：
			* Object invoke(Object obj, Object... args)  
		* 获取方法名称：
			* String getName:获取方法名
注意：Method调用方法时，参数Object obj还是类在内存中创建的对象。

public static void main(String[] args) throws Exception {
        //0.
        Class peresonClass = Pereson.class;
        Pereson pereson = new Pereson();
        //1.
        Method method = peresonClass.getMethod("eat");//获取这个方法的方法反射
        method.invoke(pereson);
        //method.invoke(pereson,"蛋炒饭");//IllegalArgumentException非法调用方法，无法传参进无参方法的反射中
        Method method2 = peresonClass.getMethod("eat",String.class);//获取这个方法的方法反射
        method2.invoke(pereson,"蛋炒饭");

        //2.
        Method[] methods = peresonClass.getMethods();//集合中包含父类
        for (Method method1 : methods) {
            System.out.println(method1.getName());//获取方法名
        }
        //获取类名
        String name = peresonClass.getName();
        System.out.println(name);
    }

5.补充

 获取类加载器：（主要是用于获取输入流，在下面的框架demo中有使用）
				*  ClassLoader getClassLoader() 返回该类的类加载器。 
类加载器的方法
				*URL getResource(String name)查找具有给定名称的资源
				InputStream getResourceAsStream(String name)查找具有给定名称的资源，返回读取指定资源的输入流

框架设计的原理——制作简易“框架”

要求：使用反射技术制作“框架”模型，在不改变任何代码的情况下，可以获取任意类的对象，可以执行任意方法。
原理：把properties文件中存储的类名和方法名取出，加载进内存，通过类名创建class对象，通过Class对象newInstance()方法构造对象，使用Class对象获取Method，使用method调用构造出来的对象的方法。这样，我们就可以只改动properties文件，就可以获取任意类的对象，执行任意方法了。

prop.properties文件：

className=cn.java.Person
methodName=eat

public static void main(String[] args) throws Exception {
        //创建prop.properties文件,其中写两行className=cn.java.Pereson ,methodName=eat
        //创建properties对象
        Properties p = new Properties();
        //创建字符输入流对象
        /*FileReader file = new FileReader("01_Junit\\src\\prop.properties");
        BufferedReader reader = new BufferedReader(file);*/
        //优化
        ClassLoader loader = Demo05Test.class.getClassLoader();//得到类加载器方法
        InputStream reader = loader.getResourceAsStream("prop.properties");
        //文件加载给p对象,获取className和methodName
        p.load(reader);
        String className = p.getProperty("className");
        String methodName = p.getProperty("methodName");
        /*System.out.println(className);
        System.out.println(methodName);*/
        //创建反射
        Class aClass = Class.forName(className);
        //创建反射的对象，加载进内存
        Object o = aClass.newInstance();
        //得到对象的方法
        Method method = aClass.getMethod(methodName);
        //使用对象方法
        method.invoke(o);
    }