反射

反射

　　Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

　　加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

 

  Java反射机制提供的功能

    在运行时判断任意一个对象所属的类

    在运行时构造任意一个类的对象

    在运行时判断任意一个类所具有的成员变量和方法

    在运行时获取泛型信息

    在运行时调用任意一个对象的成员变量和方法

    在运行时处理注解

    生成动态代理

  反射相关的主要API

    java.lang.Class:代表一个类

    java.lang.reflect.Method:代表类的方法

    java.lang.reflect.Field:代表类的成员变量

    java.lang.reflect.Constructor:代表类的构造器

 

@Data
public class Person {
    private String name;
    //公有属性
    public Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    //私有构造器
    private Person(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("你好 我是一个人");
    }
    //私有方法
    private String showNation(String nation){
        System.out.println("我的国籍是："+nation);
        return nation;
    }

    private static void showDesc(){
        System.out.println("我是一个可爱的人！");
    }
}

 

    @Test
    public void test1() throws Exception {
        Class clazz = Person.class;
        //1.通过反射，创建Person类的对象
        Constructor cons = clazz.getConstructor(String.class, Integer.class);
        Object obj = cons.newInstance("xiaojie", 25);
        Person person =(Person) obj;
        System.out.println(person);//Person(name=xiaojie, age=25)
        //2.通过反射，调用对象指定的属性、方法
        Field age = clazz.getDeclaredField("age");
        age.set(person,21);
        System.out.println(person);//Person(name=xiaojie, age=21)
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(person);//你好 我是一个人

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

        //通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
        //调用私有的构造器
        Constructor cons2 = clazz.getDeclaredConstructor(String.class);
        cons2.setAccessible(true);
        Object obj2 = cons2.newInstance("xiaojun");
        Person person2 = (Person) obj2;
        System.out.println(person2);//Person(name=xiaojun, age=null)
        //调用私有的属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(person2,"HanMeimei");
        System.out.println(person2);//Person(name=HanMeimei, age=null)
        //调用私有的方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        //相当于String nation = p1.showNation("中国")
        String nation = (String) showNation.invoke(person2,"中国");//我的国籍是：中国
        System.out.println(nation);//中国
    }

  关于java.lang.Class类的理解
    1.类的加载过程：
      程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。
      接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。
    2.换句话说，Class的实例就对应着一个运行时类。
    3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。

 

    //获取Class的实例的方式（前三种方式需要掌握）
    @Test
    public void test3() throws ClassNotFoundException {
        //方式一：调用运行时类的属性：.class
        Class clazz1 = Person.class;
        System.out.println(clazz1);//class com.company.Java8.reflex.Person
        //方式二：通过运行时类的对象,调用getClass()
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);//class com.company.Java8.reflex.Person

        //方式三：调用Class的静态方法：forName(String classPath)
        Class clazz3 = Class.forName("com.company.Java8.reflex.Person");
//        clazz3 = Class.forName("java.lang.String");
        System.out.println(clazz3);//class com.company.Java8.reflex.Person

        System.out.println(clazz1 == clazz2);//true
        System.out.println(clazz1 == clazz3);//true
    }

    //Class实例可以是哪些结构的说明：
    @Test
    public void test4(){
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = ElementType.class;
        Class c6 = Override.class;
        Class c7 = int.class;
        Class c8 = void.class;
        Class c9 = Class.class;

        int[] a = new int[10];
        int[] b = new int[100];
        Class c10 = a.getClass();
        Class c11 = b.getClass();
        // 只要数组的元素类型与维度一样，就是同一个Class
        System.out.println(c10 == c11);//true
    }

    通过发射创建对应的运行时类的对象

    @Test
    public void test1() throws IllegalAccessException, InstantiationException {
        Class<Person> clazz = Person.class;
        /*
        newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。

        要想此方法正常的创建运行时类的对象，要求：
        1.运行时类必须提供空参的构造器
        2.空参的构造器的访问权限得够。通常，设置为public。

        在javabean中要求提供一个public的空参构造器。原因：
        1.便于通过反射，创建运行时类的对象
        2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
         */
        Person obj = clazz.newInstance();
        System.out.println(obj);//Person(name=null, age=null)
    }

    /*
    创建一个指定类的对象。
    classPath:指定类的全类名
     */
    public Object getInstance(String classPath) throws Exception {
        Class clazz =  Class.forName(classPath);
        return clazz.newInstance();
    }

    //体会反射的动态性
    @Test
    public void test2(){
        for(int i = 0;i < 100;i++){
            int num = new Random().nextInt(3);//0,1,2
            String classPath = "";
            switch(num){
                case 0:
                    classPath = "java.util.Date";
                    break;
                case 1:
                    classPath = "java.lang.Object";
                    break;
                case 2:
                    classPath = "com.company.Java8.reflex.Person";
                    break;
            }
            try {
                Object obj = getInstance(classPath);
                System.out.println(obj);
                //Person(name=null, age=null)
                //java.lang.Object@3fc542
                //Mon Jan 16 21:18:00 CST 2023
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

 

 

    /**
     * 如何操作运行时类中的指定的属性
     * @throws Exception
     */
    @Test
    public void testField1() throws Exception {
        Class clazz = Person.class;
        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();
        //1. getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name");
        //2.保证当前属性是可访问的
        name.setAccessible(true);
        //3.获取、设置指定对象的此属性值
        name.set(p,"Tom");//Tom
        System.out.println(name.get(p));
    }

    /**
     * 如何操作运行时类中的指定的方法
     * @throws Exception
     */
    @Test
    public void testMethod() throws Exception {
        Class clazz = Person.class;
        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();
        //1.获取指定的某个方法getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
        Method show = clazz.getDeclaredMethod("showNation", String.class);
        //2.保证当前方法是可访问的
        show.setAccessible(true);

        //3. 调用方法的invoke():参数1：方法的调用者  参数2：给方法形参赋值的实参
        //   invoke()的返回值即为对应类中调用的方法的返回值。
        //String nation = p.showNation("CHN");
        Object returnValue = show.invoke(p,"CHN"); //我的国籍是：CHN
        System.out.println(returnValue);

        System.out.println("*************如何调用静态方法*****************");
        // private static void showDesc()
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
        //Object returnVal = showDesc.invoke(null);
        Object returnVal = showDesc.invoke(Person.class);//我是一个可爱的人！
        System.out.println(returnVal);//null
    }

user=zdy
password=abc123


/**
 * 读取配置文件
 */
public class ClassLoaderTest {

    @Test
    public void test1(){
        //对于自定义类，使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@b4aac2
        //调用系统类加载器的getParent()：获取扩展类加载器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println(classLoader1);//sun.misc.Launcher$ExtClassLoader@1f4acd0
        //调用扩展类加载器的getParent()：无法获取引导类加载器
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类的。
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);//null

        ClassLoader classLoader3 = String.class.getClassLoader();
        System.out.println(classLoader3);//null
    }

    /**
     * Properties：用来读取配置文件。
     * @throws Exception
     */
    @Test
    public void test2() throws Exception {
        Properties pros =  new Properties();
        //此时的文件默认在当前的module下。
        //读取配置文件的方式一：
        //FileInputStream fis = new FileInputStream("jdbc.properties");
        //FileInputStream fis = new FileInputStream("src\\jdbc1.properties");
        //pros.load(fis);
        //读取配置文件的方式二：使用ClassLoader
        //配置文件默认识别为：当前module的src下
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println("user = " + user + ",password = " + password);//user = zdy,password = abc123
    }
}