Java 高级_反射机制

Java反射机制

框架 = 注解 + 反射 + 设计模式

Java反射机制概述

Java Reflection

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于 Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性和方法
加载完类后，在堆内存的方法区中就产生了一个 Class类型的对象（一个类只有一个 Class对象），这个对象就包含了完整的类的结构的信息；我们可以通过这个对象看到类的结构；这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射
正常方式：引入需要的“包类”名称 -> 通过 new实例化 -> 取得实例化对象
反射方式：实例化对象 -> getClass()方法 -> 得到完整的“包类”名称

Java反射机制研究及应用

Java反射机制提供的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理

反射相关的主要 API

java.lang.Class：代表一个类；反射的源头
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Constructor：代表类的构造器
... ...

实例：

package com.atguigu.java;

import org.junit.Test;

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

/**
 * @author lv
 * @create 2021-03-01 20:37
 *
 */
public class ReflectionTest {
    /**
     * 学反射之前，可以对 Person类进行的操作
     */
    @Test
    public void test1 () {
//        1.创建 Person类的对象
        Person p1 = new Person("Tom", 11);
//        2.通过对象，调用其内部属性、方法
        p1.age = 18;
        System.out.println(p1.toString());
        p1.show();

        /**
         * 在 Person类的外部，不能通过 Person类的对象调用其内部私有结构
         * 比如：name、showNation()、私有构造器
         */

    }
    /**
     * 学反射后，对于 Person类的操作
     */
    @Test
    public void test2 () throws Exception {

        Class pClass = Person.class;
//        1.通过反射创建类的对象
        Constructor pCons = pClass.getConstructor(String.class, int.class);
        Object pObj = pCons.newInstance("Tom", 12);
        System.out.println(pObj.toString()); // Person{name='Tom', age=12}
        Person p1 = (Person) pObj;
//        2.通过反射，调用对象自动的属性、方法
//        调用属性：
        Field age = pClass.getDeclaredField("age");
        age.set(p1, 10);
        System.out.println(p1.toString()); // Person{name='Tom', age=10}

//        调用方法：
        Method show = pClass.getDeclaredMethod("show");
        show.invoke(p1); // 我是一个人啊

        /**
         * 通过反射，可以调用 Person类的私有结构：属性、方法、构造器...
         * 总结：通过反射可以做与 类对象一样的事，并且也可以做类和对象做不到的事
         *
         */
//        调用 私有构造器
        Constructor pCons1 = pClass.getDeclaredConstructor(String.class);
        pCons1.setAccessible(true);
        Object pObj1 = pCons1.newInstance("Rolay");
        Person p2 = (Person)pObj1;
        Field age2 = pClass.getDeclaredField("age");
        age2.set(p2, 13);
        System.out.println(p2); // Person{name='Rolay', age=13}
//        修改私有属性
        Field name2 = pClass.getDeclaredField("name");
        name2.setAccessible(true);
        name2.set(p2, "Tom2");
        System.out.println(p2); // Person{name='Tom2', age=13}
//        调用私有方法
        Method showNation = pClass.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        String china = (String)showNation.invoke(p2, "China");
        System.out.println("nation: " + china); // nation: China
//        System.out.println(p2);

    }

}

疑问

通过直接 new的方式或反射的方式都可以调用公共的结构，开发中具体用哪一种
- 建议直接 new的方式
- 何时使用反射：在编译前不确定创建那种对象时
反射机制与面向对象中的封装性是否矛盾，如何看待这两种技术反射
- 两种技术不矛盾
- 封装性体现的是，建议用户去使用公共的属性、方法...，不建议用户使用私有的属性、方法...
- 反射体现的是，反射可以做什么

理解 Class类并获取 Class实例*

理解 Classl类

类的加载过程：程序经过 javac.exe命令后会具体的类生成对应的字节码文件（Xxx.class）。

接着我们使用 java.exe命令对某个字节码文件进行解释运行；相当于将某个字节码文件加载到内存中，此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为 Class的一个实例。

换句话说，Class的实例就对应着一个运行时类
加载到内存中的运行时类，会缓存一段时间；在此时间内，我们可以通过不同的方式来获取此运行时类

获取 Class实例

类本身就是一个对象：体会到万事万物皆对象


    /**
     *  * 关于 java.lang.Class类的理解
     *  * 1.类的加载过程：
     *  * 程序经过 javac.exe命令后会具体的类生成对应的字节码文件（Xxx.class）。
     *  * 接着我们使用 java.exe命令对某个字节码文件进行解释运行；相当于将某个字节码文件加载到内存中，
     *  * 此过程就称为类的加载。
     *  * 加载到内存中的类，我们就称为运行时类，此运行时类，就作为 Class的一个实例。
     *  *
     *  * 2.换句话说，Class的实例就对应着一个运行时类
     *  * 3.加载到内存中的运行时类，会缓存一段时间；在此时间内，
     *  * 我们可以通过不同的方式来获取此运行时类
     */
    @Test
    public void test3 () {
//        获取 Class实例的方式（前三种需要掌握）

//        方式一：调用运行时类的属性
        Class clazz1 = Person.class;
        System.out.println(clazz1); // class com.atguigu.java.Person 类本身
//        方式二：通过运行时类的对象，调用 getClass()
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);
//        方式三（此法更好的体现动态性，使用频率更高）：
//          调用 Class的静态方法：forName(String classPath)
        Class clazz3 = null;
        try {
            clazz3 = Class.forName("com.atguigu.java.Person");
            System.out.println(clazz3);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

//        方式四：使用类的加载器：ClassLoader（了解）
        ClassLoader cl = ReflectionTest.class.getClassLoader();
        Class clazz4 = null;
        try {
            clazz4 = cl.loadClass("com.atguigu.java.Person");
            System.out.println(clazz4 == clazz2); // true
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

哪些类型可以有 Class对象

class：外部类、成员（内部类、静态内部类）、局部内部类、匿名内部类
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void

类的加载与 ClassLoader的理解

了解，类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化

一、类的加载（Load）

将类的 class文件读入内存，并为之创建一个 java.lang.Class对象；此过程由类加载器完成
加载：将 class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的 java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）；所有需要访问和使用类数据只能通过这个 Class对象；这个加载的过程需要类加载器参与

二、类的链接（Link）

将类的二进制数据合并到 JRE中
链接：将 Java类的二进制代码合并到 JVM的运行状态之中的过程
1. 验证：确保加载的类信息符合 JVM规范，如：以 cafe开头，没有安全方面的问题
2. 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
3. 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程

三、类的初始化（Initialize）

JVM负责对类进行初始化
初始化：
1. 执行类构造器\<clinit>()方法的过程；类构造器\<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的;（类构造器是构造类信息的，不是构造该类对象的构造器）
2. 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
3. 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步

class A {
	// 代码块和显示赋值，按照书写顺序执行
	static {
    	m = 300;
    }
    static int m = 100;
}
// 第一步：加载
// 第二步：链接结束后 m = 0
// 第三步：初始化后，m的值由<clinit>()方法执行决定
// 这个 A的类构造器<clinit>()由类变量的赋值和静态代码块中的语句按照顺序合并产生，类似于
// <clinit>() {
//  	m = 300;
//      m = 100;
// }

类的加载器

类加载器的作用：

类加载的作用：将 class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后再堆中生成一个代表这个类的 java.lang.Class对象，作为方法区中类数据的访问入口
类缓存：标准的 JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间；不过 JVM垃圾回收机制可以回收这些 Class对象

了解：ClassLoader

类加载器作用是用来把类（class）装载进内存的；JVM规范定义了如下类型的类的加载器

引导类加载器（Bootstap ClassLoader）

用 C++编写的，是 JVM自带的类加载器，负责 Java平台核心库，用来装载核心类库；该加载器无法直接获取

扩展类加载器（Extention ClassLoader）

负责 jre/lib/ext目录下的 jar包或 _D java.ext.dirs 指定目录下的 jar包装入工作库

系统类加载器（System ClassLoader）

负责 java-classpath 或 _D java.class.path所指的目录下的类与 jar包装入工作，是最常用的加载器

package com.atguigu.java;

import org.junit.Test;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @author lv
 * @create 2021-03-03 20:37
 */
public class ClassLoaderTest {
    @Test
    public void test1 () {
//        自定义类使用系统类加载器
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println("系统类加载器：" + classLoader); // 系统类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
//        通过系统类加载器的 getParent()获取 扩展类加载器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println("扩展类加载器：" + classLoader1); // 扩展类加载器：sun.misc.Launcher$ExtClassLoader@452b3a41
//        无法直接获取 引导类加载器
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println("引导类加载器：" + classLoader2); // 引导类加载器：null，无法直接获取

//        通过 String获取引导类加载器
        ClassLoader classLoader3 = String.class.getClassLoader();
        System.out.println("引导类加载器：" + classLoader3); // 引导类加载器：null

    }

    /**
     * 掌握:
     * 集合 Propertise：用来读取配置文件
     *
     */
    @Test
    public void test2 () {
//        Properties特点：键值都是 String
        Properties pros = new Properties();
//        FileInputStream fis = null;
        try {
//            读取配置文件的方式一
//            jdbc.properties此时文件默认在当前 Module下
//            fis = new FileInputStream("jdbc1.properties");
//            fis = new FileInputStream("src\\jdbc.properties");
//            pros.load(fis);
//            读取配置文件的方式二
            ClassLoader cl = ClassLoaderTest.class.getClassLoader();
//            getResourceAsStream()方法默认识别路径在 当前Module的 src下
            InputStream is = cl.getResourceAsStream("jdbc1.properties");
            pros.load(is);


            String user = pros.getProperty("user");
            String password = pros.getProperty("password");
            System.out.println("user：" + user + " password：" + password);
            // user：无非 password：abc123
            // user：无非1 password：abc123

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
//            try {
//                if (null == fis)
//                fis.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
        }


    }
}

创建运行时类的对象*

package com.atguigu.java;

import org.junit.Test;

import java.util.Random;

/**
 * @author lv
 * @create 2021-03-06 9:56
 *
 *
 */
public class ReflectionNewInstanceTest {

    /**
     * 体会反射的 动态性：框架中大量使用
     *
     * 反射的动态性，最重要的一点
     */
    @Test
    public void test1 () {
        int i = new Random().nextInt(3);// 0、1、2
        String classPath = "";
        switch (i) {
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "com.atguigu.java.Person";
                break;
        }
        Object instance = getInstance(classPath);
        System.out.println(instance);
    }

    /**
     * 创建一个指定类的对象
     * @param classPath
     * @return
     */
    public Object getInstance (String classPath) {
        Class clazz = null;
        try {
            clazz = Class.forName(classPath);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Object o = null;
        try {
             o = clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } finally {
            return o;
        }

    }


    /**
     * 通过反射创建对应的运行时类的对象
     */

    @Test
    public void test () {

        Class clazz = Person.class;
        /**
         * newInstance()：调用此方法，创建对应的运行时类的对象
         * 此方法内部调用了运行时类的空参构造器
         *
         * 如想此方法正常的创建运行时类的对象，要求：
         * 1. 运行时类必须提供空参构造器
         * 2. 空参构造器的访问权需要符合规定，通常，设为 public
         *
         * 在 javabean中要求提供一个 public的空参构造器，原因：
         * 1. 便于通过反射，创建运行时类的对象
         * 2. 便于子类继承此运行时类时，默认使用 super()时，保证父类有此构造器
         *
         */
        Person obj;
        {
            try {
                obj = (Person)clazz.newInstance();
            } catch (InstantiationException e) {
//                类的构造器问题
                e.printStackTrace();
            } catch (IllegalAccessException e) {
//                访问权限问题
                e.printStackTrace();
            }
        }
    }

}

获取运行时类的完整结构

package com.atguigu.java1;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;

/**
 * @author lv
 * @create 2021-03-06 11:08
 */
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}

package com.atguigu.java1;

/**
 * @author lv
 * @create 2021-03-06 10:56
 */
public interface MyInterface {
    void info();
}

package com.atguigu.java1;

import java.io.Serializable;

/**
 * @author lv
 * @create 2021-03-06 10:53
 */
public class Creature<T> implements Serializable {

    private char gender;
    public double weight;

    private void breath () {
        System.out.println("breath");
    }
    public void eat () {
        System.out.println("eat");
    }
}

package com.atguigu.java1;

/**
 * @author lv
 * @create 2021-03-06 10:51
 */
@MyAnnotation(value = "hi")
public class Person extends Creature<String> implements Comparable<String>, MyInterface {

    private String name;
    int age;
    public int id;

    public Person () {}
    @MyAnnotation(value = "cons")
    private Person (String name) {
        this.name = name;
    }
    Person (String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String display (String interests) {
        return interests;
    }
    @MyAnnotation
    private String show (String nation) {
        System.out.println("Nation：" + nation);
        return nation;
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }

    @Override
    public void info() {
        System.out.println("person");
    }
}

根据以上类获取属性信息

package com.atguigu.java2;

import com.atguigu.java1.Person;
import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * @author lv
 * @create 2021-03-06 11:13
 *
 * 获取当前运行时类的属性结构
 *
 */
public class FieldTest {

    @Test
    public void test () {
        Class clazz = Person.class;
//        获取属性结构
        /**
         * getFields()：获取当前运行时类及其父类中声明为 public权限的属性
         */
        Field[] fields = clazz.getFields();
        for (Field f : fields) {
            System.out.println("Field：" + f);
            /**
             * Field：public int com.atguigu.java1.Person.id
             * Field：public double com.atguigu.java1.Creature.weight
             */
        }
        System.out.println();
        /**
         * getDeclaredFields()：只获取当前运行时类本身声明的所有属性
         */
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field f : declaredFields) {
            System.out.println("Field：" + f);
            /**
             * Field：private java.lang.String com.atguigu.java1.Person.name
             * Field：int com.atguigu.java1.Person.age
             * Field：public int com.atguigu.java1.Person.id
             */
        }

    }

    /**
     * 属性的基本信息
     */
    @Test
    public void test2 () {
        Class clazz = Person.class;
        Field[] dFields = clazz.getDeclaredFields();
        for (Field f : dFields) {
//            1.权限修饰符
            int modifiers = f.getModifiers();
            System.out.print(Modifier.toString(modifiers) + "\t"); // private、 、public
//            2.数据类型
            Class type = f.getType();
            System.out.print(type + "\t"); // class java.lang.String、int、int
//            3.变量名
            String name = f.getName();
            System.out.println(name); // name、age、id

        }
    }
}

根据以上类获取方法信息

package com.atguigu.java2;

import com.atguigu.java1.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * @author lv
 * @create 2021-03-06 14:32
 *
 * 获取运行时类的方法结构
 */
public class MethodTest {
    @Test
    public void test () {
        Class clazz = Person.class;
        /**
         * getMethods()：只获取当前运行时类及父类们权限为 public的方法
         */
        Method[] methods = clazz.getMethods();
        for (Method m : methods) {
            System.out.println(m);
        }
        System.out.println();
        /**
         * getDeclaredMethods()：获取当前运行时类本身声明的所有方法
         */
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            System.out.println(m);
        }

        Object o = null;
        try {
            o = clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        Method declaredMethod = null;
        try {
            declaredMethod = clazz.getMethod("display", String.class);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        try {
            Object lve = declaredMethod.invoke(o, "lve");
            System.out.println(lve); // lve
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }
    /**
     * 方法的具体结构
     *
     * @Xxxx
     *
     * 权限修饰符、返回值类型、方法名(参数类型1 形参名1, ...) throws XxxException {}
     */
    @Test
    public void test1 () {
        Class<Person> clazz = Person.class;
        Method[] methods = clazz.getDeclaredMethods();
        for (Method m : methods) {
//            1.获取方法声明的注解
            Annotation[] annotations = m.getAnnotations();
            for (Annotation anno : annotations) {
                System.out.print(anno);
            }
            System.out.println();
//            2.权限修饰符
            int modifiers = m.getModifiers();
            System.out.print(Modifier.toString(modifiers) + "\t");
//            3.获取返回值类型
            Class<?> returnType = m.getReturnType();
            System.out.print(returnType + "\t");

//            TypeVariable<Method>[] typeParameters = m.getTypeParameters();
//            4.获取方法名
            String name = m.getName();
            System.out.print(name);
//            System.out.println();
//            System.out.println(typeParameters);
//            5.获取形参类型
            Class<?>[] parameterTypes = m.getParameterTypes();
            System.out.print("(");
            if (null != parameterTypes && 0 != parameterTypes.length) {
                for (Class c : parameterTypes) {
                    System.out.print(c);
                }
            }
            System.out.print(")");
//            6.抛出的异常
            Class<?>[] et = m.getExceptionTypes();
            if (0 != et.length && null != et) {
                System.out.println(" throws ");
                for (int i = 0; i < et.length; i++) {
                    if (i == et.length - 1) {
                        System.out.print(et[i] + " {}");
                    } else {
                        System.out.print(et[i] + ", ");
                    }
                    
                }
                System.out.println();
            }
            System.out.println("******************");

        }

    }
}

获取其它类结构信息

package com.atguigu.java2;

import com.atguigu.java1.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.*;

/**
 * @author lv
 * @create 2021-03-06 16:19
 */
public class OtherTest {
    /**
     * 获取构造器结构
     *
     */
    @Test
    public void test () {
        Class<Person> clazz = Person.class;
        /**
         * getConstructors()：获取当前运行时类中权限声明为 public的构造器
         */
        Constructor<?>[] constructors = clazz.getConstructors();

        for (Constructor c : constructors) {
            System.out.println(c);
        }
        System.out.println("------------------------");
        Constructor<?>[] dCons = null;
        /**
         * getDeclaredConstructors()：获取当前运行时类中声明的所有的构造器
         */
        dCons = clazz.getDeclaredConstructors();
        for (Constructor c : dCons) {
            System.out.println(c);

            int modifiers = c.getModifiers();
            String s = Modifier.toString(modifiers);
            System.out.println(s);

        }
    }

    /**
     * 获取运行时类的父类
     */
    @Test
    public void test1 () {
        Class<Person> clazz = Person.class;
        /**
         * getSuperclass()：获取当前运行时类的父类
         */
        Class sClazz = clazz.getSuperclass();
        System.out.println(sClazz); // class com.atguigu.java1.Creature
        Field[] dFields = sClazz.getDeclaredFields();
        for (Field f : dFields) {
            System.out.println(f);
        }

    }
    /**
     * 获取运行时类的带泛型的父类
     *
     * 代码：逻辑型代码 vs 功能型代码
     */
    @Test
    public void test2 () {
        Class<Person> clazz = Person.class;
        /**
         * getGenericSuperclass()：获取当前运行时类的泛型父类
         */
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass); // com.atguigu.java1.Creature<java.lang.String>
        String typeName = genericSuperclass.getTypeName();
        System.out.println(typeName); // com.atguigu.java1.Creature<java.lang.String>

//        重要：获取带泛型的父类的泛型****
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
//        getActualTypeArguments()：获取泛型类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        for (Type t : actualTypeArguments) {
            System.out.println(t.getTypeName());
            // java.lang.String
        }

    }
    /**
     * 获取运行时类实现的接口***
     * 应用：动态代理
     *
     */
    @Test
    public void test3 () {
        Class clazz = Person.class;
        Class[] interfaces = clazz.getInterfaces();
        for (Class c : interfaces) {
            System.out.println(c);
            /**
             * interface java.lang.Comparable
             * interface com.atguigu.java1.MyInterface
             */
        }
//        获取运行时类的父类实现的接口
        Class superclass = clazz.getSuperclass();
        Class[] interfaces1 = superclass.getInterfaces();
        for (Class c : interfaces1) {
            System.out.println(c);
            /**
             * interface java.io.Serializable
             */
        }
    }
    /**
     * 获取当前运行时类所在的包
     */
    @Test
    public void test4 () {
        Class clazz = Person.class;
        Package aPackage = clazz.getPackage();
        System.out.println(aPackage); // package com.atguigu.java1
        String name = aPackage.getName();
        System.out.println(name); // com.atguigu.java1
    }
    /**
     * 获取运行时类的注解*****
     * 应用：框架中使用
     *
     */
    @Test
    public void test5 () {
        Class clazz = Person.class;
        Annotation[] clazzAnnotations = clazz.getAnnotations();
        for (Annotation a : clazzAnnotations) {
            System.out.println(a);
//            System.out.println(a.toString());
            /**
             * @com.atguigu.java1.MyAnnotation(value=hi)
             */
        }
    }
}

调用运行时类的指定结构*

属性***

getField()
getDeclaredField() -- 掌握
setAccessible() -- 掌握

package com.atguigu.java2;

import com.atguigu.java1.Person;
import org.junit.Test;

import java.lang.reflect.Field;

/**
 * @author lv
 * @create 2021-03-07 10:05
 *
 * 通过反射获取运行时类的指定结构：属性、方法、构造器
 *
 */
public class ReflectionConsTest {
    /**
     * 了解此方式获取属性 -- 了解
     * 获取属性结构
     */
    @Test
    public void testField () {
        Class clazz = Person.class;
//        创建运行时类的对象
        Person p1 = null;
        try {
            p1 = (Person) clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        /**
         * getField()：获取指定的权限为 public的属性
         *
         * 一般不使用此方法
         */
        try {
            Field id = clazz.getField("id");
            /**
             * 设置当前属性的值
             * set(instance, value)
             */
            id.set(p1, 123);
            /**
             * 获取当前属性的值
             * get(instance)
             */
//            Object o = id.get(p1);
            int i = (int) id.get(p1);
            System.out.println(i); // 123

        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }

    /**
     * 需要掌握此方式获取属性 -- 掌握
     */
    @Test
    public void testField1 () {
        Class clazz = Person.class;
        Person p1 = null;
        try {
            p1 = (Person) clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        /**
         * getDeclaredField()：通常使用此方法获取属性
         */
        try {
//            Field age = clazz.getDeclaredField("age");
//            age.set(p1, 10); // IllegalAccessException：非法访问（权限）
            Field name = clazz.getDeclaredField("name");
            /**
             * setAccessible(boolean)：当权限非 public时，指定此属性可修改
             */
            name.setAccessible(true);
            name.set(p1, "Tomer");
            String nameStr = (String) name.get(p1);
            System.out.println(nameStr); // Tomer

        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
//            IllegalAccessException：非法访问（权限）
            e.printStackTrace();
        }
    }
}

方法****

getDeclaredMethod(methodName, args...)
setAccessible(boolean)
invoke(instance, args..) / invoke(clazz, args..)

/**
     * 操作运行时类中指定的方法 -- 掌握
     */
    @Test
    public void testMethod () {
        Class clazz = Person.class;
        Person p1 = null;
        try {
            p1 = (Person) clazz.newInstance();
            /**
             * 1.getDeclaredMethod(methodName, args...)：获取指定的方法
             * 2.setAccessible(true)：保证方法是可调用的
             * 3.invoke(instance, args...)：调用此方法
             */
            Method show = clazz.getDeclaredMethod("show", String.class);
            show.setAccessible(true); // 不设置此方法会报错：IllegalAccessException
            String china = (String) show.invoke(p1, "China");
            System.out.println(china);

            System.out.println("*******************如何调用静态方法********************");

//            private static void showInfo ()
            Method showInfo = clazz.getDeclaredMethod("showInfo");
            showInfo.setAccessible(true);
//            如运行时类中被调用的方法无返回值，则默认返回 null
            Object invoke = showInfo.invoke(clazz);
//            Object invoke = showInfo.invoke(null); // 参数写为 null也可以

            System.out.println("invoke：" + invoke); // invoke：null


        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

构造器***

/**
     * 调用运行时类中指定的构造器 -- 了解
     *
     */
    @Test
    public void testCons () {

        Class clazz = Person.class;
        Constructor dCons = null;
        try {
            /**
             * 1. 获取指定的构造器
             * getDeclaredConstructor(argsClass...)：获取指定参数的构造器
             */
//            private Person (String name)
            dCons = clazz.getDeclaredConstructor(String.class);
//            2. setAccessible(true)：指明构造器可访问
            dCons.setAccessible(true);
//            3. 构造器调用 newInstance()创建运行时类的对象
            Person p2 = (Person) dCons.newInstance("Jerry");
            System.out.println(p2);

        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

反射的应用：动态代理（动态性）

代理模式的原理

使用一个代理将对象包装起来，然后用该代理对象取代原始对象；任何对原始对象的调用都要通过代理；代理对象决定是否以及何时将方法调用转到原始对象上

之前为大家讲解过代理机制的操作，属于静态代理，特点是代理类和目标对象的类都是在编译期间确定下来的，不利于程序的扩展性、灵活性；同时，每个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理；最好可以通过一个代理类完成全部的代理功能。
动态代理是指客户通过代理类来调用其它对象的方法并且是在程序运行时根据需要动态创建目标类的代理对象
动态代理使用场合：
- 调试
- 远程方法调用
动态代理相较于静态代理的优点：
1. 抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理（一个代理类可以搞定其它所有的被代理类），这样，我们可以更加灵活和统一的处理众多的方法

实例

package com.atguigu.java;

/**
 * @author lv
 * @create 2021-03-07 16:34
 *
 * 静态代理举例
 * 特定：代理类和被代理类在编译期间，就确定下来了
 *
 */
interface ClothFactory {
    void produceCloth();
}

/**
 * 代理类
 *
 */
class ProxyClothPactory implements ClothFactory {

    private ClothFactory factory;
    public ProxyClothPactory (ClothFactory factory) {
        this.factory = factory;
    }
    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作：produceCloth");
        factory.produceCloth();
        System.out.println("代理工厂做一些收尾工作：finished");
    }
}

/**
 * 被代理类
 *
 */
class NikeClothFactory implements ClothFactory {

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂开始生产服装");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {

//        创建被代理类的对象
        NikeClothFactory nikeClothFactory = new NikeClothFactory();
//        创建代理类的对象
        ProxyClothPactory proxyClothPactory = new ProxyClothPactory(nikeClothFactory);
        proxyClothPactory.produceCloth();

    }
}

package com.atguigu.java;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 代理：接口 + 被代理类 + 动态代理类
 *
 * @author lv
 * @create 2021-03-07 17:00
 *
 * 动态代理举例
 *
 */

interface Human {
    String getBelief ();
    void eat (String food);
}

class HumanUtil {
    public void method1 () {
        System.out.println("----------------method1-----------------");
    }
    public void method2 () {
        System.out.println("----------------method2-----------------");
    }
}

// 被代理类
class SuperMan implements Human {

    @Override
    public String getBelief() {
        return "I believe I can Fly!";
    }

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

/**
 * 要想实现动态代理，需要解决的问题：
 * 1.如何根据加载到内存中的被代理类，动态创建一个代理类及其对象
 * 2.当通过代理类的对象调用方法时，如何动态的去调用被代理类的方法
 */

class ProxyFactory {

//    调用此方法，返回一个代理类的对象；解决问题1
    public static Object getProxyInstance (Object obj) { // obj被代理类对象

        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
//        如下代码执行后，会自动调用 invoke()方法
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }
}
//  解决问题2
class MyInvocationHandler implements InvocationHandler {

    private Object obj; // 需要使用被代理类的对象进行赋值

    public void bind (Object obj) {
        this.obj = obj;
    }


//    当我们通过代理类的对象，调用方法 a时，就会自动调用如下方法：invoke()
//    将被代理类要执行的方法 a的功能就声明在 invoke()中
    @Override
    /**
     * proxy：代理类的对象
     * method：代理类调用的方法
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    	// 面向切面示例
        HumanUtil humanUtil = new HumanUtil();
        humanUtil.method1();
        /**
         * method：即为代理类对象调用的方法，此方法也就作为被代理类对象要调用的方法
         * obj：被代理类的对象
         */
        Object returnValue = method.invoke(obj, args);
    	// 面向切面示例
        humanUtil.method2();
        
        return returnValue;
    }
}

public class DynamicProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();

//        proxyInstance：代理类的对象
//        Object proxyInstance = ProxyFactory.getProxyInstance(superMan);
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);

//        当通过代理类对象 proxyInstance调用方法时，会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println("belief：" + belief); // belief：I believe I can Fly!
        proxyInstance.eat("青菜"); // eat：青菜

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

        NikeClothFactory nikeClothFactory = new NikeClothFactory();

//        Object proxyClothFactory = ProxyFactory.getProxyInstance(nikeClothFactory);
        ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
//        强转后才能调用对应的属性、方法
        proxyClothFactory.produceCloth(); // Nike工厂开始生产服装

    }
}

动态代理与 AOP（Aspect Orient Programming）

具体使用参看上边示例代码 - HumanUtil

问题

写出获取 Class实例的三种常见方式

// 方式一：-- 了解
// 此方法在编译期已经写死，不能体现动态性
Class clazz = Person.class;

// 方式二：-- 熟悉
Person p1 = new Person();
Class clazz = p1.getClass();

// 方式三：-- 掌握
// 此方法体现了反射的动态性，在程序运行期加载指定的类
String classPath = "xxx/xxx/Xxx";
Class clazz = Class.forName(classPath);

谈谈对 Class类的理解

Class是一个类
Class实例对应着加载到内存中的一个运行时类（类、数组、接口）
通过 Class类的实例可以调用运行时类的结构

创建 Class对应运行时类的对象的通用方法，代码实现；此操作需要运行时类构造器需满足的条件

Class clazz = Class.forName(String classPath);
Object obj = clazz.newInstance();
Method show = clazz.getDeclaredMethod("show", String.class);
show.setAccessiable(true);
show.invoke(obj, "China");

必须有空参构造器
构造器的权限要够，一般写为 public

在工程获取 module的 src下有名为 “jdbc.properties”的配置文件，文件内容为：name=Tom；如何在程序中通过代码获取这个变量 “Tom”

public class ClassLoaderTest {

    @Test
    public void test2 () {
//        Properties特点：键值都是 String
        Properties pros = new Properties();
//        FileInputStream fis = null;
        try {
//            读取配置文件的方式一
//            jdbc.properties此时文件默认在当前 Module下
//            fis = new FileInputStream("jdbc1.properties");
//            fis = new FileInputStream("src\\jdbc.properties");
//            pros.load(fis);
//            读取配置文件的方式二
            ClassLoader cl = ClassLoaderTest.class.getClassLoader();
//            getResourceAsStream()方法默认识别路径在 当前Module的 src下
            InputStream is = cl.getResourceAsStream("jdbc1.properties");
            pros.load(is);


            String user = pros.getProperty("user");
            String password = pros.getProperty("password");
            System.out.println("user：" + user + " password：" + password);
            // user：无非 password：abc123
            // user：无非1 password：abc123

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
//            try {
//                if (null == fis)
//                fis.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
        }
    }
}