Web基础02_反射

二、反射：框架设计的灵魂

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

获取Class对象的方式：

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

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

public class ReflectDemo0 {
    public static void main(String[] args) throws Exception {
        //1 Class.forName("全类名") 静态方法
        Class cls1 = Class.forName("domain.Person");
        System.out.println(cls1);  //class domain.Person
        //2 类名.class：通过类名的属性class获取
        Class cls2 = Person.class;
        System.out.println(cls2); //class domain.Person
        //3 对象.getClass()：getClass()方法在Object类中定义着
        Person p = new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3); //class domain.Person

        //==比较三个对象
        System.out.println(cls1==cls2);  //true
        System.out.println(cls2==cls3);  //true
        System.out.println(cls1==cls3);  //true
        //* 结论：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个

        Class c = Student.class;
        System.out.println(cls1==c);  //false
    }
}

---

Class对象功能：

• 获取功能：

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):暴力反射

public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
        //0 获取person的class对象
        Class<Person> personClass = Person.class;
       
        //Field[] getFields() ：获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);  //domain.Person.a
        }

        System.out.println("----------------");

        //2 Field getField(String name)   获取指定名称的 public修饰的成员变量
        Field a = personClass.getField("a");  //声明异常
        //获取成员变量的值
        Person p = new Person();
        //Object get​(Object obj) 返回由该 Field表示的字段在指定对象上的值
        Object value = a.get(p);
        System.out.println(value); //null
        //设置a的值
        //void set​(Object obj, Object value) 将指定的对象参数中由此 Field对象表示的字段设置为指定的新值
        a.set(p,"张三");
        System.out.println(p);

        System.out.println("==================");

        //Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符（包括private）
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //Field getDeclaredField(String name)
        Field d = personClass.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true); //暴力反射,添加这行代码就可以访问私有变量了
        Object value2 = d.get(p);
        //can not access a member of class domain.Person with modifiers "private"
//        System.out.println(value2); //非法访问异常--私有
        System.out.println(value2); //null
    }
}

---

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

• Constructor:构造方法
  • 创建对象：
    * T newInstance(Object… initargs)
    * 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        //0 获取person的class对象
        Class<Person> personClass = Person.class;
        //1 获取构造器
        Constructor<Person> constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);  //public domain.Person(java.lang.String,int)
        //创建对象 T newInstance(Object... initargs)
        Person person = constructor.newInstance("张三", 23);
        System.out.println(person);  //Person{name='张三', age=23, a='null', b='null', c='null', d='null'}

        System.out.println("----------------");

//        Constructor<Person> constructor1 = personClass.getConstructor(); //使用空参构造器
//        System.out.println(constructor1); //public domain.Person()
//        Person person1 = constructor1.newInstance();

        //如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法,即不用先获取构造器
        Person person1 = personClass.newInstance();
        System.out.println(person1);  //Person{name='null', age=0, a='null', b='null', c='null', d='null'}、

//        暴力反射，当使用Constructor<?>[] getDeclaredConstructors()私有构造器构造对象时可使用
//        constructor.setAccessible(true);
    }
}

---

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

• Method：方法对象
  • 执行方法：
    * Object invoke(Object obj, Object… args)
  • 获取方法名称：
    * String getName:获取方法名

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

public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        //0 获取person的class对象
        Class<Person> personClass = Person.class;
        //获取指定名称的方法（需指定方法名和参数列表）
        Method eat_method = personClass.getMethod("eat");  //获取无参数列表的eat方法
        //Object invoke​(Object obj, Object... args) 在具有指定参数的指定对象上调用此 方法对象表示的基础方法
        Person p = new Person();
        //1 执行方法
        eat_method.invoke(p);  //eat... 这个方法没有参数，所以只有传递对象，不需实参

        Method eat2 = personClass.getMethod("eat", String.class);//获取带参数的eat方法
        eat2.invoke(p,"包子");  //eat...包子

        System.out.println("-------------");
        //获取所有public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);  //打印方法对象，也包含Object类的方法，因为Person没有任何继承，默认继承Object
            String name = method.getName();//2 获取方法名称
//            method.setAccessible(true); 也支持暴力反射
            System.out.println(name);
        }

        //3 获取类名
        String className = personClass.getName();
        System.out.println(className);  //domain.Person 全类名：包名.类名

    }
}

5. 练习案例：

• 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
  • 实现：
  1. 配置文件
  2. 反射
  • 步骤：
  3. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
  4. 在程序中加载读取配置文件
  5. 使用反射技术来加载类文件进内存
  6. 创建对象
  7. 执行方法

//配置文件Pro.properties
className=domain.Student
methodName=sleep

/*
    假设的框架类（直接用，不更改）
    (只需要改变配置文件，就可以创建不同的类和执行不同的方法）
 */
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        //前提：不能改变该类的任何代码，可以创建任意类的对象，并且执行其中任意方法
       /* Person p = new Person();
        p.eat();
        Student stu = new Student();
        stu.sleep();*/
        
       //1 加载配置文件
        //1.1创建Properties对象
        Properties pro = new Properties();
        //1.2加载配置文件，转换成一个集合
        //1.2.1 获取class目录下的配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();//获取字节码文件对应的类加载器，就是使用这个类加载器加载进内存
        InputStream is = classLoader.getResourceAsStream("pro.properties");//返回字节流
        pro.load(is);

        //2 获取配置文件中定义的数据
        String className = pro.getProperty("className"); //要加载的类的全类名
        String methodName = pro.getProperty("methodName"); //要执行的方法名称

        //3 加载该类进内存
        Class<?> cls = Class.forName(className);  //返回一个class对象
        //4 创建对象
        Object obj = cls.newInstance();
        //5 获取方法对象
        Method method = cls.getMethod(methodName);
        //6 执行方法
        method.invoke(obj);
        //输出	sleep...
    }
}