Java反射机制

Java Reflection：

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

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

正常方式：引入需要的“包类”名称——>通过new实例化——>取得实例化对象

反射方式：实例化对象——>getClass()方法——>得到完整的“包类”名称

动态语言和静态语言：

动态语言：

是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。

主要动态语言：Object-C、C#、Javascript、PHP、Python、Erlang。

静态语言：

与动态语言相对应，运行时结构不可变的语言就是静态语言。如Java、C、C++。

Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活。

Java反射机制研究及应用：

Java反射机制提供的功能：

1）在运行时判断任意一个对象所属地类

2）在运行时构造任意一个类地对象

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

4）在运行时获取泛型信息

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

6）在运行时处理注解

7）生成动态代理

反射相关的主要API：

java.lang.Class：代表一个类

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

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

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

举例：

反射前后，对Person的操作。

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

    public Person() {
    }

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

    private Person(String name){
        this.name=name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println("一个人");
    }

    private String showNation(String nation){
        System.out.println("国籍是："+nation);
        return nation;
    }
}

import org.junit.Test;
import 自定义泛型类.FileDemo;

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

public class ReflectionTest {
    //反射之前，对于Person的操作
    @Test
    public void test1(){
        //1.创建Person类的对象
        Person p1=new Person("Tom",12);

        //通过对象，调用其内部的属性、方法
        p1.age=10;
        System.out.println(p1.toString());//Person{name="Tom",age=10}

        p1.show();//一个人

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

    //反射之后，对于Person的操作
    @Test
    public void test2() throws Exception{
        Class clazz=Person.class;
        //1.通过反射，创建Person类的对象
        Constructor cons=clazz.getConstructor(String.class,int.class);
        Object obj=cons.newInstance("Tom",12);
        Person p=(Person) obj;
        System.out.println(obj.toString());//Person{name='Tom',age=12}

        //2.通过反射，调用对象制定的属性、方法
        //调用属性
        Field age=clazz.getDeclaredField("age");
        age.set(p,10);
        System.out.println(p.toString());//Person{name='Tom',age=10}

        //调用方法
        Method show=clazz.getDeclaredMethod("show");
        show.invoke(p);//一个人

        //通过反射，可以调用Person类的私有结构。比如：私有的构造器、方法、属性。
        //调用私有的构造器
        Constructor cons1=clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1=(Person) cons1.newInstance("Jerry");
        System.out.println(p1);//Person{name="Jerry",age=0}

        //调用私有的属性
        Field name=clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1,"HanMeimei");
        System.out.println(p1);//Person{name="HanMeimei",age=0}

        //调用私有方法
        Method showNation=clazz.getDeclaredMethod("showNation",String.class);
        showNation.setAccessible(true);
        String nation=(String) showNation.invoke(p1,"China");//相当于String nation=p1.showNation("China")  //国籍：China
        System.out.println(nation);//China
    }
}

问题：

1、通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底使用哪个？

建议：直接new的方式

什么时候会使用：反射的方式反射的特征：动态性

2、反射机制与面向对对象中的封装性是不是矛盾的？

不矛盾

关于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);
        //方式二：通过运行时类的对象
        Person p1=new Person();
        Class clazz2=p1.getClass();
        System.out.println(clazz2);
        //方式三：调用Class的静态方法：forName(String classPath)
        Class clazz3=Class.forName("reflect.Person");
        System.out.println(clazz3);
        //方式四：使用类的加载器：ClassLoader
        ClassLoader classLoader=ReflectionTest.class.getClassLoader();
        Class clazz4=classLoader.loadClass("reflect.Person");
        System.out.println(clazz4);

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

哪些类型可以有Class对象：

1）class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类

2）interface：接口

3）[]：数组

4）enum：枚举

5）annotation：注解@interface

6）primitive type：基本数据类型

7）void

    @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=void.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
    }

类的加载过程：

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

类的加载（Load）——> 类的链接（link）——> 类的初始化（Initialize）

类的加载(Load)：将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成。

类的链接(link)：将类的二进制数据合并到JRE中。

类的初始化(Initialize)：JVM负责对类进行初始化。

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

链接：将Java类的二进制代码合并到JVM的运行状态中的过程。

1）验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题

2）准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法去中进行分配。

3）解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

初始化：

1）执行类构造器()方法的过程。类构造器()方法是由编译器自动收集类中所有类变量的赋值动作和静态代码中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。

2）当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

3）虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

public class ClassLoadingTest{
    public static void main(String[] args){
        System.out.println(A.m);
    }
}

class A{
    static{
        m=300;
    }
    static int m=100;
}

类加载器的作用：

1）类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法去中类数据的访问入口。

2）类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

ClassLoader：

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

自底向上检查类是否已装载——>

自定义类加载器 —> System Classloader—>Extension Classloader—>Boostap Classloader

自顶向下尝试加载类<——

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

扩展类加载器：负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库。

系统类加载器：负责java-classPath或-D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器。

了解类的加载器：

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


public class ClassLoaderTest {
    @Test
    public void test1(){
        //对于自定义类，使用系统类加载器进行
        ClassLoader classLoader=ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);

        //调用系统类加载器的getParen()：获取拓展类加载器
        ClassLoader classLoader1=classLoader.getParent();
        System.out.println(classLoader1);

        //调用扩展类的加载器的getParent()：无法获取引导类加载器
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类的
        ClassLoader classLoader2=classLoader1.getParent();
        System.out.println(classLoader2);//null

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

    
    @Test
    public void test2() throws IOException {
        Properties pros=new Properties();
        //此时的文件默认在当前的module下
        //读取配置文件的方式一
        //FileInputStream fis=new FileInputStream("jdbc.properties");
        //pros.load(fis);

        //读取配置文件的方式二：使用ClassLoader
        //配置文件默认识别为：当前module的src下
        ClassLoader classLoader=ClassLoaderTest.class.getClassLoader();
        InputStream is=classLoader.getResourceAsStream("jdbc.properties");
        pros.load(is);


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

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

import org.junit.Test;

import java.util.Random;


public class NewInstanceTest {
    @Test
    public void test1() throws IllegalAccessException, InstantiationException {
        Class clazz=Person.class;

        
        Person obj=(Person) clazz.newInstance();
        System.out.println(obj);
    }

    //体会反射的动态性
    @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="src.reflect.Person";
                    break;
            }
            try {
                Object obj=getInstance(classPath);
                System.out.println(obj);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    
    public Object getInstance(String classPath) throws Exception{
        Class clazz=Class.forName(classPath);
        return clazz.newInstance();
    }
}

提供结构丰富的Person类：

import org.junit.Test;

@MyAnnotation(value = "hi")
public class Person extends Creature implements Comparable,MyInterface{
    private String name;
    int age;
    public int id;

    public Person(){}

    @MyAnnotation(value = "abc")
    public Person(String name) {
        this.name = name;
    }

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

    @MyAnnotation(value = "hi")
    public String show(String nation){
        System.out.println("国籍："+nation);
        return nation;
    }

    public String display(String insterests){
        return insterests;
    }

    @Override
    public void info(){
        System.out.println("一个人");
    }

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

}

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

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

@Target({TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}

public interface MyInterface {
    void info();
}

import java.io.Serializable;

public class Creature implements Serializable {
    private char gender;
    public double weight;

    private void breath(){
        System.out.println("生物呼吸");
    }
    public void eat(){
        System.out.println("生物吃东西");
    }
}

获取当前运行时类的属性结构：

Java反射机制

Python相关栏目本月热门文章