Java反射（详细学习笔记）

蔚落 2024-03-25 03:39 112阅读 0赞

## Java反射 ##

### 1. Java反射机制概述 ###

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

Class c = Class.forName("java.lang.String");

加载完类之后，在堆内存的方法区中就会产生一个Class类型的对象（一个类只有一个Class对象），

这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。

*  正常方式：`引入包类`=>`new实例化`=>`获取实例对象`
 *  反射方式：`实例化对象`=>`getClass()方法`=>`获取完整包类名称`

### 2. 理解Class类并获取Class实例 ###

#### 2.1Class类 ####

*  Class 本身就是一个类
 *  Class 对象只能由系统建立对象
 *  一个加载的类在JVM中只有一个Class实例
 *  一个Class对象对应的是一个加载到JVM中的一个.class文件
 *  每个类的实例都会记得自己是由哪个Class实例所生成
 *  通过Class可以完整地得到一个类中所有被加载的结构
 *  Class类是Reflection的根源，争对任何你想动态加载、运行的类，唯有先获得相应的Class对象。

#### 2.2 Class类的常用方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>功能说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>static ClassforName(String name)</td> 
   <td>返回指定类名name的Calss对象</td> 
  </tr> 
  <tr> 
   <td>Object newInstance()</td> 
   <td>调用缺省构造函数，返回Class对象的一个实例</td> 
  </tr> 
  <tr> 
   <td>getName()</td> 
   <td>返回此Class对象所表示的实体(类，接口，数组类或void)的名称。</td> 
  </tr> 
  <tr> 
   <td>Class getSuperClass()</td> 
   <td>返回当前Class对象的父类的Class对象返回当前类对象的父类的类对象</td> 
  </tr> 
  <tr> 
   <td>Class[] getinterfaces()</td> 
   <td>获取当前Class对象的接口</td> 
  </tr> 
  <tr> 
   <td>ClassLoader getClassLoader()</td> 
   <td>返回该类的类加载器</td> 
  </tr> 
  <tr> 
   <td>Constructor[] getConstructors()</td> 
   <td>返回一个包含某些Constructor对象的数组</td> 
  </tr> 
  <tr> 
   <td>Method getMothed(String name,Class… T)</td> 
   <td>返回一个Method对象，此对象的形参类型为paramType</td> 
  </tr> 
  <tr> 
   <td>Field[] getDeclaredFields()</td> 
   <td>返回Filed对象的一个数组</td> 
  </tr> 
 </tbody> 
</table>

#### 2.3 获取Class对象的方式 ####

a.若已知具体的类对象，通过类的class属性获取，该方法最为安全可靠，程序性能高

Class c = Person.class;

b.已知某个类的实例，调用该实例的getClass()方法获取Class对象

Class c = person.getClass();

c.已知一个类的全类名，且该类在路径下，可通过Class类的静态方法forName()获取

可能抛出`ClassNoFoundException`

Class c = Class.forName("demo.Student");

d.内置基本数据类型可以直接用类名.Type

e.利用ClassLoader

#### 2.4 哪些类型有Class对象 ####

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

public static void main(String[] args) {
        
        Class c1 = Object.class;
        Class c2 = String[].class;
        Class c3 = int.class;
        Class c4 = Override.class;
        Class c5 = ElementType.class;
        Class c6 = Integer.class;
        Class c7 = void.class;
        Class c8 = Class.class;
    }

### 3.类的加载与ClassLoader ###

#### 3.1 Java内存 ####

**（1）堆**

*  存放new的对象和数组
 *  可以被所有的线程共享，不会存放别的对象引用

**（2）栈**

*  存放基本变量类型（会包含这个基本类型的具体数值）
 *  引用对象的变量（会存放这个引用在堆里面的具体地址）

**（3）方法区**

*  可以被所有线程共享
 *  包含了所有的class和static变量

#### 3.2 类的加载过程 ####

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

**类的加载（Load）**=>**类的链接（Link）**=>**类的初始化（initialize）**

*  **类的加载（Load）**
    
    将类的class文件读入内存，并为之建立一个java.lang.Class对象。**此过程由类加载器完成**。
 *  **类的链接（Link）验证>准备>解析**
    
    将Java类的二进制代码合并到JVM的运行状态之中的过程。
    
    （1）验证：确保加载类的信息符合JVM规范，没有安全方面的问题。
    
    （2）准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法中进行分配。
    
    （3）解析：虚拟机常量池的符号引用（常量名）替换为直接引用（地址）的过程。
 *  **类的初始化（initialize）**
    
    JVM负责对类进行初始化。
    
    （1）执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的，不是构造该类对象的构造器)。
    
    （2）当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
    
    （3）虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

#### 3.3 类的初始化 ####

**类的主动引用（一般发生类的初始化）**

（1）当虚拟机启动，先初始化main方法所在的类

（2）new 一个对象的对象

（3）调用类的静态成员（除去final常量）和静态方法

（4）使用java.lang.reflect包（**反射**）

（5）当初始化一个类，如果其父类没有初始化，则先初始化他的父类。

**类的被动引用（不会发生类的初始化）**

（1）当访问一个静态域时，只有真正声明这个域的类才会初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。

（2）通过数组定义的类引用，不会触发此类的初始化。

（3）引用常量不会触发此类的初始化（**常量在链接阶段就存入调用类的常量池中了**）

class Father {
        
        static int a = 2;
    
        static {
        
            System.out.println("父类被初始化");
        }
    }
    
    class Son extends Father {
        
        static {
        
            System.out.println("子类被初始化");
            m = 300;
        }
    
        static int m = 100;
        static final int M = 1;
    }
    
    
    public class Test6 {
        
        static {
        
            System.out.println("Main类被加载");
        }
    
        public static void main(String[] args) throws ClassNotFoundException {
        
            //主动引用
            //Son son = new Son();
            //反射也会产生主动引用
            // Class.forName("org.example.reflection.Son");//
            /** 主动引用结果
             * Main类被加载
             * 父类被初始化
             * 子类被初始化
             */
            // 不会产生类的引用方法
            // System.out.println(Son.a);
            /** 以上结果
             * Main类被加载
             * 父类被初始化
             * 2
             */
            // 数组
            //Son[] ar = new Son[10];
            /** 以上结果
             * Main类被加载
             */
        }
    }

#### 3.4 类加载器的作用 ####

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

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

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

**`自定义类加载器`**>**`System Classloader（系统类加载器）`**>**`Extecnsion Classloader（扩展类加载器）`**>**`Bootstap Classloader（引导类加载器）`**

*  自低向上检查类是否已经被装载
 *  自顶向下尝试加载类

（1）引导类加载器

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

（2）扩展类加载器

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

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

public static void main(String[] args) throws ClassNotFoundException {
        
        // 获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println("系统类的加载器 " + systemClassLoader);
        // 获取系统类的加载器的父类加载器->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println("扩展类加载器 " + parent);
        // 获取系扩展类加载器的父类加载器->根加载器（c/c++）
        ClassLoader parent1 = parent.getParent();
        System.out.println("根加载器 " + parent1);
        // 测试当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("org.example.reflection.Test7").getClassLoader();
        System.out.println("org.example.reflection.Test7 " + classLoader);
        // 测试JDK内部类是谁加载的
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println("java.lang.Object " + classLoader1);
        // 获取系统类加载器可以加载的路径
        String property = System.getProperty("java.class.path");
        String[] split = property.split(";");
        System.out.println(Arrays.toString(split));
    }

> 系统类的加载器 sun.misc.Launcher$AppClassLoader@18b4aac2  
> 扩展类加载器 sun.misc.Launcher$ExtClassLoader@1b6d3586  
> 根加载器 null  
> org.example.reflection.Test7 sun.misc.Launcher$AppClassLoader@18b4aac2  
> java.lang.Object null  
> \[E:\\Java\\jdk1.8.0\_191\\jre\\lib\\charsets.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\deploy.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\access-bridge-64.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\cldrdata.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\dnsns.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\jaccess.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\jfxrt.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\localedata.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\nashorn.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\sunec.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\sunjce\_provider.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\sunmscapi.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\sunpkcs11.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\ext\\zipfs.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\javaws.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\jce.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\jfr.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\jfxswt.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\jsse.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\management-agent.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\plugin.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\resources.jar, E:\\Java\\jdk1.8.0\_191\\jre\\lib\\rt.jar, E:\\IdeaProjects\\java-demo-parent\\basics\\target\\classes, E:\\Program Files\\JetBrains\\IntelliJ IDEA 2022.3.2\\lib\\idea\_rt.jar\]

### 4.创建运行时类对象 ###

>     public class User {
>          
>         private String name;
>         private int id;
>     }

// 获得Class对象
    Class c1 = Class.forName("org.example.reflection.User");

**（1）调用无参构造器**

// 构建一个对象（调用无参构造器）
    User user1 = (User) c1.newInstance();
    System.out.println("user1 " + user1);

> user1 User\{name=‘null’, id=0\}

**（2）调用有参数构造器**

// 通过构造器创建对象
    Constructor constructor = c1.getDeclaredConstructor(String.class, int.class);
    User user2 = (User) constructor.newInstance("张三", 1);
    System.out.println("user2 " + user2);

> user2 User\{name=‘张三’, id=1\}

**（3）通过反射调用方法**

// 通过反射调用方法
    User user3 = (User) c1.newInstance();
    // 通过反射获取一个方法
    Method setName = c1.getDeclaredMethod("setName", String.class);
    setName.invoke(user3, "李四");
    System.out.println("user3 " + user3);

> （1）`public Object invoke(Object obj, Object... args)`
> 
>  *  Object对应原方法的返回值，若原方法无返回值，此时返回null
>  *  若原方法为静态方法，此时形参Object obj可为null
>  *  若原方法形参列表为空，则Object\[\] args为null
>  *  若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。
> 
> （2）`setAccessible(true)`启动和禁用访问安全检查的开关
> 
>  *  Method、Field、Constructor对象都有setAccessible()
>  *  取消检查、提高反射效率

**（4）通过反射操作属性**

// 通过反射操作属性
    User user4 = (User) c1.newInstance();
    Field name = c1.getDeclaredField("name");
    // 无法操作私有属性，关闭安全检测setAccessible(true)
    name.setAccessible(true);
    name.set(user4, "王二");

> 如果没有设置会报异常`IllegalAccessException`: `User with modifiers "private"`

### 5.获取运行时类的完整结构 ###

>     public class User {
>          
>        private String name;
>        private int id;
>     }

通过反射获取运行时类的完整结构

Filed（字段）、Method（方法）、Constructor（构造）、Superclass（父类）、Interface（接口）、Annotation（注解）

// 通过包名获取
    Class c1 = Class.forName("org.example.reflection.User");
    // 通过对象获取
    //User user = new User();
    //Class c2 = user.getClass();
    // 获取类的名字
    System.out.println("包名+类名 " + c1.getName());
    System.out.println("类名 " + c1.getSimpleName());
    // 获取对象属性
    System.out.println("=============对象属性=============");
    // getFields() 只能找到public属性
    Field[] fields = c1.getDeclaredFields();
    for (Field field : fields) {
        
        System.out.println(field);
    }
    // 获取指定的属性
    System.out.println("获取指定的属性" + c1.getDeclaredField("id"));
    // 获取类的方法
    // getMethods：获取本类及父类的全部public方法
    System.out.println("=============类的方法=============");
    Method[] methods = c1.getMethods();
    for (Method method : methods) {
        
        System.out.println(method);
    }
    // 获取本类的所有方法
    System.out.println("=========getDeclaredMethods=========");
    Method[] methods1 = c1.getDeclaredMethods();
    for (Method method : methods1) {
        
        System.out.println(method);
    }
    // 获取指定的方法
    System.out.println("指定方法" + c1.getDeclaredMethod("getName", null));
    System.out.println("指定方法" + c1.getDeclaredMethod("setName", String.class));
    
    // 获取指定构造器
    System.out.println("=============指定构造器=============");
    Constructor[] constructors = c1.getDeclaredConstructors();
    for (Constructor c : constructors) {
        
        System.out.println(c);
    }
    System.out.println("获取指定构造器 " + c1.getDeclaredConstructor(String.class, int.class));

> 包名+类名 org.example.reflection.User  
> 类名 User  
> //对象属性  
> private java.lang.String org.example.reflection.User.name  
> private int org.example.reflection.User.id  
> 获取指定的属性private int org.example.reflection.User.id  
> //类的方法  
> public java.lang.String org.example.reflection.User.toString()  
> public java.lang.String org.example.reflection.User.getName()  
> public int org.example.reflection.User.getId()  
> public void org.example.reflection.User.setName(java.lang.String)  
> public void org.example.reflection.User.setId(int)  
> public final void java.lang.Object.wait() throws java.lang.InterruptedException  
> public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException  
> public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException  
> public boolean java.lang.Object.equals(java.lang.Object)  
> public native int java.lang.Object.hashCode()  
> public final native java.lang.Class java.lang.Object.getClass()  
> public final native void java.lang.Object.notify()  
> public final native void java.lang.Object.notifyAll()  
> //getDeclaredMethods  
> public java.lang.String org.example.reflection.User.toString()  
> public java.lang.String org.example.reflection.User.getName()  
> public int org.example.reflection.User.getId()  
> public void org.example.reflection.User.setName(java.lang.String)  
> public void org.example.reflection.User.setId(int)  
> 指定方法public java.lang.String org.example.reflection.User.getName()  
> 指定方法public void org.example.reflection.User.setName(java.lang.String)  
> //指定构造器  
> public org.example.reflection.User(java.lang.String,int)  
> public org.example.reflection.User()  
> 获取指定构造器 public org.example.reflection.User(java.lang.String,int)

### 6.获取泛型 ###

Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除。

为了通过反射操作这些类型，Java新增了`ParameterizedType` ,`GenericArrayType`,  
TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型.

`ParameterizedType`:表示一种参数化类型,比如Collection<String>

`GenericArrayType`:表示一种元素类型是参数化类型或者类型变量的数组类型

`TypeVariable`:是各种类型变量的公共父接口

`WildcardType`:代表一种通配符类型表达式

public class Test11 {
        
        public void test01(Map<String, User> map, List<User> list) {
        
            System.out.println("test01");
        }
    
        public Map<String, User> test02() {
        
            System.out.println("test02");
            return null;
        }
    
        public static void main(String[] args) throws NoSuchMethodException {
        
            // 参数泛型
            System.out.println("===========参数泛型==========");
            Method test01 = Test11.class.getMethod("test01", Map.class, List.class);
            Type[] genericExceptionTypes = test01.getGenericParameterTypes();
            for (Type t : genericExceptionTypes) {
        
                System.out.println("genericExceptionTypes " + t);
                if (t instanceof ParameterizedType) {
        
                    Type[] actualTypeArguments = ((ParameterizedType) t).getActualTypeArguments();
                    for (Type i : actualTypeArguments) {
        
                        System.out.println("actualTypeArguments " + i);
                    }
                }
            }
            // 返回值泛型
            System.out.println("===========返回值泛型==========");
            Method test02 = Test11.class.getMethod("test02");
            Type genericReturnType = test02.getGenericReturnType();
            System.out.println("genericReturnType " + genericReturnType);
            if (genericReturnType instanceof ParameterizedType) {
        
                Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
                for (Type i : actualTypeArguments) {
        
                    System.out.println("actualTypeArguments " + i);
                }
            }
        }
    }

> //参数泛型  
> genericExceptionTypes java.util.Map<java.lang.String, org.example.reflection.User>  
> actualTypeArguments class java.lang.String  
> actualTypeArguments class org.example.reflection.User  
> genericExceptionTypes java.util.List<org.example.reflection.User>  
> actualTypeArguments class org.example.reflection.User  
> //返回值泛型  
> genericReturnType java.util.Map<java.lang.String, org.example.reflection.User>  
> actualTypeArguments class java.lang.String  
> actualTypeArguments class org.example.reflection.User

### 7.反射操作注解 ###

@TableName("db_student")
    class Student {
        
    
        @Column(name = "s_id", type = "int", length = 10)
        private int id;
        @Column(name = "s_name", type = "varchar", length = 32)
        private String name;
    
        public Student() {
        
        }
    
        public Student(int id, String name) {
        
            this.id = id;
            this.name = name;
        }
    
        public int getId() {
        
            return id;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    
    /**
     * 表名
     */
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @interface TableName {
        
        String value();
    }
    
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    @interface Column {
        
        String name();
    
        String type();
    
        int length();
    }
    
    public class Test12 {
        
        public static void main(String[] args) {
        
            Student student = new Student();
            TableName annotation = student.getClass().getAnnotation(TableName.class);
            System.out.println("类注解值：" + annotation.value());
            Field[] declaredFields = student.getClass().getDeclaredFields();
            for (Field field : declaredFields) {
        
                Column a = field.getAnnotation(Column.class);
                System.out.println("====属性：" + field.getName() + "====");
                System.out.println("名称：" + a.name() + ",类型：" + a.type() + ",长度：" + a.length());
            }
        }
    
    }

> 类注解值：db\_student  
> //属性：id  
> 名称：s\_id,类型：int,长度：10  
> //属性：name  
> 名称：s\_name,类型：varchar,长度：32