反射（框架设计的灵魂）

反射（框架设计的灵魂）

1、框架

• 框架可以成为半成品软件，不能独立的运行，可以在框架的基础上进行软件开发，简化编码

2、反射的基本概念

• 将类的各个组成部分封装成其他对象，这就是反射的机制（将类的成员变量封装为Field对象，将构造函数封装为Constructor对象，将成员方法封装为Method对象。对象可以有很多，所以使用数组封装）
  

• 反射的好处：

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

3、获取Class对象的三种方式

• Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象

• 类名.Class：通过类名的属性Class获取

• 对象.getClass()：getClass()方法在Object类中有定义

  

• 举例说明：首先创建一个Person.java类，在定义两个成员变量name和age，创建两个参数的构造方法，空参构造，get/set方法以及toString()。其次，通过三个方式分别获取字节码文件对象。

• 方式1：Class.forName(“全类名”)（多用于配置文件，将类名定义在配置文件中。读取文件，加载类。）
  

• 方式2：类名.Class （多用于参数的传递）

• 方式3：对象.getClass() （多用于对象的获取字节码的方式）

• 验证（字符串表示形式都一样，但不能说明这三个对象是相同的）

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

4、Class对象的功能

1、获取功能

• 获取成员变量
  • Field[] getFields()：获取所有public修饰的成员变量
  • Field getField(String name)：获取指定名称的public修饰的成员变量
  • Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
  • Field getDeclaredField(String name) ：获取指定的成员变量，不考虑修饰符
• 获取构造方法
  • Constructor<?>[] getConstructors()
  • Constructor getConstructor(类<?>… parameterTypes)
  • Constructor<?>[] getDeclaredConstructors()
  • Constructor getDeclaredConstructor(类<?>… parameterTypes)
• 获取成员方法
  • Method[] getMethods()
  • Method getMethod(String name, 类<?>… parameterTypes)
  • Method[] getDeclaredMethods()
  • Method getDeclaredMethod(String name, 类<?>… parameterTypes)
• 获取类名
  • String getName()

package cn.itcast.reflect;

import cn.itcast.domain.Person;
import java.lang.reflect.Field;

public class ReflectDemo02 {
    public static void main(String[] args) throws Exception{
        //0.获取Person的Class对象
        Class personClass = Person.class;
        //1.Field[] getFields() 获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field:fields) {
            System.out.println(field);
        }
        System.out.println("--------------");
        //2.Field getField(String name) 获取指定名称的public修饰的成员变量
        Field a = personClass.getField("a");
        //获取成员变量a的值
        Person person = new Person();
        Object value = a.get(person);
        System.out.println(value);//null
        //设置a的值
        a.set(person,"欧阳");
        System.out.println(person);//欧阳
        System.out.println("--------------");
        //3.Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField:declaredFields) {
            System.out.println(declaredField);
        }
        System.out.println("--------------");
        //4.Field getDeclaredField(String name) 获取指定的成员变量，不考虑修饰符
        Field d = personClass.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(person);
        System.out.println(value2);
    }
}

package cn.itcast.reflect;

import cn.itcast.domain.Person;

import java.lang.reflect.Constructor;

public class ReflectDemo03 {
    public static void main(String[] args) throws Exception{
        //0.获取Person的Class对象
        Class personClass = Person.class;
        //1.Constructor<T> getConstructor(类<?>... parameterTypes)
        Constructor constructor1 = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor1);
        //创建对象
        Object person1 = constructor1.newInstance("欧阳", 18);
        System.out.println(person1);
        System.out.println("-----------");
        Constructor constructor2 = personClass.getConstructor();
        System.out.println(constructor2);
        //创建对象
        Object person2 = constructor1.newInstance();
        System.out.println(person2);
        System.out.println("-----------");
    }
}

package cn.itcast.reflect;

import cn.itcast.domain.Person;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ReflectDemo04 {
    public static void main(String[] args) throws Exception{
        //0.获取Person的Class对象
        Class personClass = Person.class;
        //获取指定名称的方法
        Method eat_method = personClass.getMethod("eat");
        Person person = new Person();
        //执行方法
        eat_method.invoke(person);

        Method eat_method1 = personClass.getMethod("eat",String.class);
        //执行方法
        eat_method1.invoke(person,"可乐鸡翅");
        System.out.println("----------");
        //获取所有public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method:methods) {
            System.out.println(method);
            String name = method.getName();
            System.out.println(name);
            //method.setAccessible(true);
        }

        //获取类名
        String className = personClass.getName();
        System.out.println(className);
    }
}

package cn.itcast.domain;

public class Person {
    private String name;
    private int age;

    public String a;
    protected String b;
    String c;
    private String d;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }

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

    public Person() {
    }

    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 eat(){
        System.out.println("eat...");
    }

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

2、案例

• 编写一个“框架”，不改变该类的任何代码条件下，可以帮我们创建任意类的对象，并且执行其中任意方法

• 实现方式：配置文件、反射

• 实现步骤：

  • 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
  • 在程序中加载读取配置文件
  • 使用反射技术来加载类文件进内存
  • 创建对象
  • 执行方法

• package cn.itcast.reflect;
  
  import cn.itcast.domain.Person;
  import cn.itcast.domain.Student;
  
  import java.io.InputStream;
  import java.lang.reflect.Method;
  import java.util.Properties;
  
  /**
   * 框架类
   */
  
  public class ReflectTest {
      public static void main(String[] args) throws Exception{
          //可以创建任意类的对象，可以执行任意方法
          /*
              前提：不改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
           */
  //        Person person = new Person();
  //        person.eat();
  //        Student student = new Student();
  //        student.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);
          //4.创建对象
          Object obj = cls.newInstance();
          //5.获取方法对象
          Method method = cls.getMethod(methodName);
          //6.执行方法
          method.invoke(obj);
      }
  }