java反射

类加载器的组成#

• Bootstrap ClassLoader 根类加载器
  也被称为引导类加载器，负责Java核心类的加载
  比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
• Extension ClassLoader 扩展类加载器
  负责JRE的扩展目录中jar包的加载。
  在JDK中JRE的lib目录下ext目录
• System ClassLoader 系统类加载器
  负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。

反射#

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。

先创建Person.class

package Models;

public class Person {
    //成员变量
    public String name;
    public int age;
    private String address;

    //构造方法
    public Person() {
        System.out.println("空参数构造方法");
    }

    public Person(String name) {
        this.name = name;
        System.out.println("带有String的构造方法");
    }
    //私有的构造方法
    public Person(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("带有String，int的构造方法");
    }

    private Person(String name, int age, String address){
        this.name = name;
        this.age = age;
        this.address = address;
        System.out.println("带有String, int, String的构造方法");
    }

    //成员方法
    //没有返回值没有参数的方法
    public void method1(){
        System.out.println("没有返回值没有参数的方法");
    }
    //没有返回值，有参数的方法
    public void method2(String name){
        System.out.println("没有返回值，有参数的方法 name= "+ name);
    }
    //有返回值，没有参数
    public int method3(){
        System.out.println("有返回值，没有参数的方法");
        return 123;
    }
    //有返回值，有参数的方法
    public String method4(String name){
        System.out.println("有返回值，有参数的方法");
        return "哈哈" + name;
    }
    //私有方法
    private void method5(){
        System.out.println("私有方法");
    }

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

Class类#

 public static void main(String[] args) throws ClassNotFoundException {
        //方式一: 通过Object类中的getObject()方法
        Person p = new Person();
        Class c1 = p.getClass();
        //方式二: 通过 类名.class 获取到字节码文件对象
        // （任意数据类型都具备一个class静态属性,看上去要比第一种方式简单）。
        Class c2 = Person.class;
        System.out.println("c2:" + c2);
        System.out.println("c1==c2:" + (c1 == c2));
        System.out.println("c1.equals(c2):" + c1.equals(c2));

        //方式三: 通过Class类中的静态方法（将类名作为字符串传递给Class类中的静态方法forName即可）。
        //包名.类名
        Class c3 = Class.forName("Models.Person");
        System.out.println("c3:" + c3);
        /*
        c2:class Models.Person
        c1==c2:true
        c1.equals(c2):true
        c3:class Models.Person
         */
    }

通过反射获取构造方法并使用#

在反射机制中，把类中的成员（构造方法、成员方法、成员变量）都封装成了对应的类进行表示。其中，构造方法使用类Constructor表示。可通过Class类中提供的方法获取构造方法：

• 返回一个构造方法
  • public Constructor<T> getConstructor(Class<?>... parameterTypes) 获取public修饰, 指定参数类型所对应的构造方法
  • public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取指定参数类型所对应的构造方法(包含私有的)
• 返回多个构造方法
  • public Constructor<?>[] getConstructors() 获取所有的public 修饰的构造方法
  • public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法(包含私有的)

获取所有构造方法#

    public static void main(String[] args) throws ClassNotFoundException {

        //通过反射获取构造方法并使用
        Class c1 = Class.forName("Models.Person");
        //getConstructors返回包含一个类的所有公共构造 类对象。
        Constructor[] constructors =  c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        /*
        结果：
       public Models.Person(java.lang.String,int)
	   public Models.Person(java.lang.String)
	   public Models.Person()
	   注意：没有  private Person(String name, int age, String address)
         */
    }

获取无参构造方法#

      public static void GetNoParameters() throws Exception{
        //通过反射获取构造方法并使用
        Class c1 = Class.forName("Models.Person");
        //2.1.获取空参构造方法
        Constructor constructor =  c1.getConstructor();
        //2.2 运行 Constructor.newInstance()
        Object object = constructor.newInstance();
        System.out.println(object);
       /*
        结果：
        空参数构造方法
        Person [name=null, age=0, address=null]
        */
    }

获取有参构造方法#

    public static void GetHasParameters() throws Exception{
        //1.通过反射获取构造方法并使用
        Class c1 = Class.forName("Models.Person");
        //2.1.获取有参构造方法
        //getConstructor(Class<?>... parameterTypes)
        Constructor constructor =  c1.getConstructor(String.class,int.class);
        //2.2 运行  Constructor.newInstance(Object... initargs)
        Object object = constructor.newInstance("张三",20);
        System.out.println(object);
       /*
        结果：
        带有String，int的构造方法
        Person [name=张三, age=20, address=null]
        */
    }

快速使用无参构造方法的快速方法#

    /*
        前提：1.被反射的类，必须有空参构造方法
             2.构造方法必须为public
     */
    public static void GetFastParameters() throws Exception{
        //1.通过反射获取构造方法并使用
        Class c1 = Class.forName("Models.Person");
        //2.2 直接运行 Class.newInstance()
        Object object = c1.newInstance();
        System.out.println(object);
    }

反射获取私有方法#

不推荐，破坏程序的封装型，安全性

    /**
     * 返回所有构造方法，包括private
     */
    public static void GetDeclaredConstructors() throws  ClassNotFoundException{
        //通过反射获取构造方法并使用
        Class c1 = Class.forName("Models.Person");
        Constructor[] constructors =  c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        /*
        private Models.Person(java.lang.String,int,java.lang.String)
        public Models.Person(java.lang.String,int)
        public Models.Person(java.lang.String)
        public Models.Person()
         */
    }

调用私有构造方法（暴力反射）#

/**
     * 1.返回所有构造方法，包括private
     * 2.调用私有构造方法
     */
    public static void GetDeclaredConstructors() throws Exception{
        //通过反射获取构造方法并使用
        Class c1 = Class.forName("Models.Person");
        Constructor[] constructors =  c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("==========");
        /*
        private Models.Person(java.lang.String,int,java.lang.String)
        public Models.Person(java.lang.String,int)
        public Models.Person(java.lang.String)
        public Models.Person()
         */

        //getDeclaredConstructor(Class<?>... parameterTypes) 可以获取私有构造方法
        Constructor constructor =  c1.getDeclaredConstructor(String.class,int.class,String.class);
        System.out.println(constructor);
        //Constructor的父类：AccessibleObject
        //setAccessible(boolean flag) 在反射对象中设置accessible = true 取消权限检查,
        constructor.setAccessible(true);
        Object object = constructor.newInstance("李四",30,"老街");
        System.out.println(object);
        /*
        private Models.Person(java.lang.String,int,java.lang.String)
        带有String, int, String的构造方法
        Person [name=李四, age=30, address=老街]
         */
    }

获取成员变量#

通过方法，给指定对象的指定成员变量赋值或者获取值

• public void set(Object obj, Object value)
  在指定对象obj中，将此 Field 对象表示的成员变量设置为指定的新值
• public Object get(Object obj)
  返回指定对象obj中，此 Field 对象表示的成员变量的值

    /*
         反射成员变量，并修改
     */
    public static void  SetMembers() throws Exception{
        Class c1 = Class.forName("Models.Person");
        //获取公有
        Field[] filses =   c1.getFields();
        for (Field fils : filses) {
            System.out.println(fils);
        }
        System.out.println("====");
        //获取公有+私有
        Field[] fields = c1.getDeclaredFields();
        for (Field fils : fields) {
            System.out.println(fils);
        }
        System.out.println("====");
        //获取成员变量
        Field name = c1.getField("name");
        //set(Object obj, Object value) 将指定对象参数上的此 Field对象表示的字段设置为指定的新值。
        //obj - 其字段应被修改的对象
        //value - 修改了 obj的新值
        Object obj = c1.newInstance();
        name.set(obj,"王五");
        System.out.println(obj);
        /*
        结果：
        public java.lang.String Models.Person.name
        public int Models.Person.age
        ====
        public java.lang.String Models.Person.name
        public int Models.Person.age
        private java.lang.String Models.Person.address
        ====
        空参数构造方法
        Person [name=王五, age=0, address=null]
         */
    }

方法#

public Object invoke(Object obj, Object... args)
执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定。

    /*
        方法运行
     */
    public static void InvokeMethod() throws Exception {
        Class c1 = Class.forName("Models.Person");
        System.out.println("1.空参方法,没有返回值======");
        Object obj = c1.newInstance();
        Method m1 = c1.getMethod("method1");
        //invoke(Object obj, Object... args)
        //在具有指定参数的 方法对象上调用此 方法对象表示的底层方法。
        //obj - 从底层方法被调用的对象
        //args - 用于方法调用的参数
        m1.invoke(obj);

        System.out.println("2.有参方法，没有返回值======");
        Method m2 = c1.getMethod("method2", String.class);
        m2.invoke(obj, "唐三三");

        System.out.println("3.无参方法，有返回值======");
        Method m3 = c1.getMethod("method3");
        Object returnResult = m3.invoke(obj);
        System.out.println(returnResult);

        System.out.println("4.有参方法，有返回值======");
        Method m4 = c1.getMethod("method4", String.class);
        Object returnResult1 = m4.invoke(obj, "李白");
        System.out.println(returnResult1);

        /*
        1.空参方法,没有返回值======
        空参数构造方法
        没有返回值没有参数的方法
        2.有参方法，没有返回值======
        没有返回值，有参数的方法 name= 唐三三
        3.无参方法，有返回值======
        有返回值，没有参数的方法
        123
        4.有参方法，有返回值======
        有返回值，有参数的方法
        哈哈李白
        */
    }

泛型擦除#

思考，将已存在的ArrayList<Integer>集合中添加一个字符串数据，如何实现呢？
其实程序编译后产生的.class文件中是没有泛型约束的，这种现象我们称为泛型的擦除。那么，我们可以通过反射技术，来完成向有泛型约束的集合中，添加任意类型的元素。

    /**
     * 泛型擦除
     * ArrayList<String> 添加 int
     *
     * @throws Exception
     */
    public static void GenerictypeClear() throws Exception{
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        //arrayList.add(1); 失败

        Class c = arrayList.getClass();
        Method method = c.getMethod("add",Object.class);
        method.invoke(arrayList,150);
        method.invoke(arrayList,50);

        System.out.println(arrayList); //[a, 150, 50]
    }

读取配置文件 Properties#

• . 反射通过配置文件来决定运行的步骤
  • a. 操作依据
    通过配置文件得到类名和要运行的方法名,用反射的操作类名得到对象和调用方法
  • b. 实现步骤:
    * 1. 准备配置文件,键值对
    * 2. IO流读取配置文件 Reader
    * 3. 文件中的键值对存储到集合中 Properties
    集合保存的键值对,就是类名和方法名
    * 4. 反射获取指定类的class文件对象
    * 5. class文件对象,获取指定的方法
    * 6. 运行方法

    /**
     * 读取配置文件Properties
     */
    public static void ReadProperties() throws Exception {

        //2. IO流读取配置文件  Reader
        FileReader reader = new FileReader("src\\config.properties");
        //3. 文件中的键值对存储到集合中 Properties
        Properties properties = new Properties();
        properties.load(reader);
        //集合保存的键值对,就是类名和方法名
        String className = properties.getProperty("className");
        String method1 = properties.getProperty("method1");
        //4. 反射获取指定类的class文件对象
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        //5. class文件对象,获取指定的方法
        Method method = c.getMethod(method1);
        //6. 运行方法
        method.invoke(obj);
    }