註解和反射Day02

东方语虑發表於2024-10-07

分析類初始化

什麼時候會發生類初始化？

類的主動引用（一定會發生類的初始化）
- 當虛擬機器啟動，先初始化main方法所在的類
- new一個類的物件
- 呼叫類的靜態成員（除了final常量）和靜態方法
- 使用 java.lang.reflect 包的方法對類進行反射呼叫
- 當初始化一個類，如果其父類沒有被初始化，則會先初始化它的父類
類的被動引用（不會發生類的初始化）
- 當訪問一個靜態域時，只有真正宣告這個域的類才會被初始化。如：當透過子類引用父類的靜態變數，不會導致子類初始化
- 透過陣列定義類引用，不會觸發此類的初始化
- 引用常量不會觸發此類的初始化（常量在連結階段就存入呼叫類的常量池中了

package com.dongfang.reflection;

//測試類什麼時候會初始化
public class Test06 {
    static {
        System.out.println("main類被載入");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //1.主動引用
        //Son son = new Son();

        //反射也會產生主動引用
        //Class.forName("com.dongfang.reflection.Son");

        //不會產生類的引用的方法
        //System.out.println(Son.b);

        //Son[] array = new Son[5];

        //System.out.println(Son.M);
    }
}

class Father {
    static int b = 2;
    static {
        System.out.println("父類被載入");
    }
}

class Son extends Father {
    static {
        System.out.println("子類被載入");
        m = 300;
    }

    static int m = 100;
    static final int M = 1;
}

類載入器

類載入的作用：將class檔案位元組碼內容載入到記憶體中，並將這些靜態資料轉換成方法區的執行時資料結構，然後在堆中生成一個代表這個類的 java.lang.Class物件，作為方法區中類資料的訪問入口

類快取：標準的 JavaSE 類載入器可以按要求查詢類，但一旦某個類被載入到類載入器中，它將維持載入(快取)一段時間，不過 JVM垃圾回收機制可以回收這些Class物件

JVM規範定義瞭如下型別的類的載入器

引導類載入器:用C++編寫的，是 JVM自帶的類載入器，負責 Java平臺核心庫，用來裝載核心類庫，該載入器無法直接獲取
擴充套件類載入器:負責 jre/lib/ext 目錄下的 jre 包或 -D java.ext.dirs 指定目錄下的 jar 包裝入工作庫
系統類載入器:負責 java-classpath 或 -D java.class.path 所指定的目錄下的類與 jar 包裝入工作，是最常用的載入器

package com.dongfang.reflection;

public class Test07 {
    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("com.dongfang.reflection.Test07").getClassLoader();
        System.out.println(classLoader);

        //測試JDK內建的類是誰載入的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);

        //如何獲得系統類載入器可以載入的路徑
        System.out.println(System.getProperty("java.class.path"));
        
        
        //雙親委派機制
        //java.lang.String-->
    }
}

獲取類的執行時結構

透過反射獲取執行時類的完整結構

package com.dongfang.reflection;

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

//獲得類的資訊
public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class<?> c1 = Class.forName("com.dongfang.reflection.User");

        //獲得類的名字
        System.out.println(c1.getName());//獲得包名+類名
        System.out.println(c1.getSimpleName());//獲得類名

        //獲得類的屬性
        Field[] fields = c1.getFields();//只能找到public屬性

        fields = c1.getDeclaredFields();//找到全部的屬性
        for (Field field : fields) {
            System.out.println(field);
        }

        //獲得指定屬性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //獲得類的方法
        Method[] methods = c1.getMethods();//獲得本類及其父類的全部public方法
        for (Method method : methods) {
            System.out.println("正常的:"+method);
        }
        methods = c1.getDeclaredMethods();//獲得本類的所有方法
        for (Method method : methods) {
            System.out.println("getDeclaredMethods"+method);
        }

        //獲得指定方法
        //過載
        Method getName = c1.getMethod("getName",null);
        Method setName = c1.getMethod("setName",String.class);
        System.out.println(getName);
        System.out.println(setName);

        //獲得指定的構造器
        Constructor[] constructors = c1.getConstructors();//獲得本類及其父類的全部public方法
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        constructors = c1.getDeclaredConstructors();//獲得本類的所有方法
        for (Constructor constructor : constructors) {
            System.out.println("#" + constructor);
        }

        //獲得指定的構造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("指定:" + declaredConstructor);
    }
}

動態建立物件執行方法

建立類的物件：呼叫Class物件的newInstance( )方法

類必須有一個無引數的的構造器
類的構造器訪問許可權需要足夠

沒有無參構造器時，只需在操作時明確呼叫類中的構造器，並將引數傳遞進去後，才可以例項化操作，步驟如下：

透過Class類的getDeclaredConstructor(Class...parameterTypes) 取得本類的指定形參型別的構造器
向構造器的形參中傳遞一個物件陣列進去，裡面包含了構造器中所需的各個引數
透過Constructor例項化物件

package com.dongfang.reflection;

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

//動態的建立物件，透過反射
public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //獲得class物件
        Class c1 = Class.forName("com.dongfang.reflection.User");

        //構造一個物件
        //User user = (User)c1.newInstance();//本質上是呼叫了類的無參構造器
        //System.out.println(user);

        //透過構造器建立物件
        //Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        //User user2 = (User)constructor.newInstance("東方",001,18);
        //System.out.println(user2);

        //透過反射呼叫普通方法
        User user3 = (User)c1.newInstance();
        //透過反射獲取一個方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke:啟用
        //(物件,"方法的值")
        setName.invoke(user3,"東方");
        System.out.println(user3.getName());

        //透過反射操作屬性
        User user4 = (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");

        //不能直接操作私有屬性，我們需要關閉程式的安全檢測，屬性或者方法的name.setAccessible(true)
        name.setAccessible(true);//關閉安全檢測
        name.set(user4,"dongfang");
        System.out.println(user4.getName());
    }
}

呼叫指定的方法

Object invoke (Object obj,Object...args)

Object對應原方法的返回值，若原方法無返回值，此時返回null;
若原方法為靜態方法，此時形參Object obj 可為null
若原方法形參列表為空，則Object[ ] args 為 null
若原方法宣告為private，則需要在呼叫此 invoke( )方法前，顯示呼叫方法物件的 setAccessible(true) 方法，將可訪問private的方法

setAccessible
- 提高反射效率
- 使得原本無法訪問的私有成員也可以訪問

效能對比分析

package com.dongfang.reflection;

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

//分析效能問題
public class Test10 {
    //普通方式呼叫
    public static void test01() {
        User user = new User();

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000000; i++) {
            user.getName();
        }

        long endTime = System.currentTimeMillis();

        System.out.println("普通方式執行1000000次" + (endTime - startTime) + "ms");
    }

    //反射方式呼叫
    public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();

        Method getName = c1.getDeclaredMethod("getName", null);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000000; i++) {
            getName.invoke(user,null);
        }

        long endTime = System.currentTimeMillis();

        System.out.println("反射方式執行1000000次" + (endTime - startTime) + "ms");
    }

    //反射方式呼叫  關閉檢測
    public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();

        Method getName = c1.getDeclaredMethod("getName", null);
        getName.setAccessible(true);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000000; i++) {
            getName.invoke(user,null);
        }

        long endTime = System.currentTimeMillis();

        System.out.println("關閉檢測方式執行1000000次" + (endTime - startTime) + "ms");
    }

    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        test01();
        test02();
        test03();
    }
}

反射操作泛型

Java採用泛型擦除的機制來引入泛型，Java中的泛型僅僅是給編譯器 javac使用的，確保資料的安全性和免去強制型別轉換問題，但是，一旦編譯完成，所有和泛型有關的型別全部擦除
為了透過反射操作這些型別，java新增了ParameterizedType，GenericArrayType，TypeVariable 和 WildcardType 幾種型別來代表不能被歸一到Class類中的型別但是又和原始型別齊名的型別
ParameterizedType：表示一種引數化型別，比如Collection
GenericArrayType：表示一種元素型別是引數化型別或者型別變數的陣列型別
TypeVariable：是各種型別變數的公共父介面
WildcardType：代表一種萬用字元型別表示式

package com.dongfang.reflection;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

//透過反射獲取泛型
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 {
        Method method = Test11.class.getMethod("test01", Map.class, List.class);

        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("#" + genericParameterType);
            if (genericParameterType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }

        method = Test11.class.getMethod("test02",null);
        Type genericReturnType = method.getGenericReturnType();

        if (genericReturnType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

反射操作註解

package com.dongfang.reflection;

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

//透過反射操作註解
public class Test12 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.dongfang.reflection.Student2");

        //透過反射獲得註解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //獲得註解的value的值
        TableDongfang tableDongfang = (TableDongfang)c1.getAnnotation(TableDongfang.class);
        String value = tableDongfang.value();
        System.out.println(value);

        //獲得類指定的註解
        Field f = c1.getDeclaredField("name");//獲得name屬性的註解
        FieldDongfang annotation = f.getAnnotation(FieldDongfang.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}

@TableDongfang("db_student")
class Student2 {

    @FieldDongfang(columnName = "db_id",type = "int",length = 10)
    private int id;
    @FieldDongfang(columnName = "db_age",type = "int",length = 10)
    private int age;
    @FieldDongfang(columnName = "db_name",type = "varchar",length = 3)
    private String name;

    public Student2() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

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

//類名的註解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface  TableDongfang {
    String value();
}

//屬性的註解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldDongfang {
    String columnName();
    String type();
    int length();
}

註解和反射
2024-08-09
反射
Java 註解和反射
2020-11-20
Java反射
Java註解和反射
2024-05-01
Java反射
【Java基礎】反射和註解
2016-07-22
Java反射
Java反射和註解基本用法
2024-03-13
Java反射
註解 & 反射
2022-02-15
反射
Java列舉類、註解和反射
2021-05-11
Java反射
註解和反射學習筆記
2020-12-09
反射筆記
Java反射-註解
2019-01-19
Java反射
java註解，反射
2017-04-01
Java反射
註解與反射
2024-08-04
反射
Java反射與註解
2018-08-08
Java反射
JAVA-註解(2)-自定義註解及反射註解
2019-07-26
Java反射
Java之註解與反射
2021-07-21
Java反射
Java ”框架 = 註解 + 反射 + 設計模式“ 之註解詳解
2023-02-22
Java框架反射設計模式
Java註解與反射的使用
2020-12-27
Java反射
【譯】8. Java反射——註解
2013-09-12
Java反射
Java註解與反射機制
2024-06-25
Java反射
自定義註解以及註解在反射中的應用
2022-02-28
反射
死磕java底層（三）—反射、動態代理和註解
2021-12-05
Java反射
自定義註解+反射實現給註解新增功能的效果
2020-12-01
反射
關於Java中泛型、反射和註解的掃盲篇
2020-11-08
Java泛型反射
暑期自學 Day 07 | Junit，反射，註解（一）
2020-05-15
反射
暑期自學 Day 08 | Junit，反射，註解（二）
2020-05-16
反射
Java註解與反射學習筆記
2020-12-21
Java反射筆記
反射、註解與依賴注入總結
2016-04-21
反射依賴注入
Java反射動態修改註解的值
2024-08-09
Java反射
Environment Switcher 原理解析（註解、Apt、反射、混淆）
2018-09-02
APT反射
【進階】Spring中的註解與反射
2022-06-08
Spring反射
Java利用spring註解做反射機制
2014-12-18
JavaSpring反射
8.集合、泛型、列舉、註解、反射
2024-04-14
泛型反射
利用反射和註解模擬ORM框架中的自動建表功能
2016-12-21
反射ORM框架
從Java反射機制到Android註解框架
2016-06-13
Java反射Android框架
Java基礎加強筆記——測試、反射、註解
2020-07-26
Java筆記反射
小白都能學會的Java註解與反射機制
2021-04-07
Java反射
03-Java核心類庫_列舉、註解與反射
2020-10-24
Java反射
反射，註解，動態代理，依賴注入控制反轉
2018-06-07
反射依賴注入
【Android】註解框架（一）基礎知識Java 反射
2017-12-23
Android框架Java反射