Java反射和註解基本用法

Java註解和反射

Java註解

什麼是註解

• Annotation是從JDK5.0開始引入的新技術

• Annotation作用：

  • 不是程式本身，可以對程式做出解釋
  • 可以被其他程式（比如編譯器）讀取

  Annotation格式：

  • 註解是以@註解名在程式碼中存在的，還可以新增一些引數值，例如：@Service(value="")

• Annotation在哪些地方使用？

  • package、class、method、field等上面，相當於給他們新增了額外的輔助資訊，可以透過反射機制程式設計實現對這些後設資料的訪問

Java中內建註解

@Override:表示一個方法重寫另一個方法的宣告

@Deprecated:表示不鼓勵程式設計師使用，通常表示才操作被廢棄，但實際可以使用，也存在更好的方式

@SuppressWarnings:抑制編譯時的警告資訊

元註解

元註解的作用是負責註解其他註解，Java定義了4個標準的元註解，它們被用來提供對其他註解型別做說明。這些型別和他們支援的類所在java.lang.annotation包中可以找到：@Target, @Retention, @Docemented, @Inherited

1. @Target:用於描述註解的使用範圍（被描述的註解可以用在什麼地方）
2. @Retention:表示需要在什麼級別儲存該註解資訊，用於描述註解的生命週期(SSOURCE < CLASS < RUNTIME)，一般都是RUNTIME
3. @Documented:說明該註解被包含在javadoc文件中
4. @Inherited:說明子類可以繼承父類中的該註解

自定義一個簡單註解

@Target(value = {ElementType.METHOD, ElementType.TYPE}) //該註解作用在方法和類上使用
@Retention(value = RetentionPolicy.RUNTIME)  //生命週期一般預設為執行時
@Documented
@Inherited
public @interface MyAnnotation{

}

定義一個比較複雜的註解

package com.lily.demo2;

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

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation2 {
    //定義一個註解引數：引數型別 + 引數名()，可以設定預設值
    String name() default "";
    int age() default 0;
    int id() default -1;//預設值為-1代表不存在
    String[] schools();
}

//只有一個值的註解,預設為value，在使用該註解時可以省略value名字
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value() default "";
}

具體使用：

package com.lily.demo2;

public class Test2 {
    @MyAnnotation2(name = "hello",age=24,id=10086, schools={"aaa","bbb","ccc"})  //如果沒有預設值就必須給註解賦值
    public void fun1(){ }

    @MyAnnotation3("這是預設值，無需帶value")
    public void fun2(){ }
}

反射機制

Java反射機制概述

Reflection(反射)是Java被視為動態語言的關鍵，反射機制允許程式在執行期間藉助反射API獲取任何類的內部資訊，並且能直接操作任意物件的內部屬性以及方法。

記載類完畢後，在堆記憶體的方法區中就會產生一個Class型別的物件（一個類只有一個Class物件），這個物件就包含了完整的類的結構資訊。我們可以透過對這個Class物件看到類的結構。這個物件就像一面鏡子，透過這個鏡子就可以看到類的結構，所以，我們形象稱之為反射。

• 正常方式：引入需要的包類名稱->透過new例項化->獲取例項化物件
• 反射方式：例項化物件->getClass()方法->得到完整的包類名稱

優點：可以實現動態建立物件和編譯，體現出很大的靈活性

缺點：對效能有影響。使用反射基本上是一種解釋操作，因此速度比較慢

理解Class類並獲取Class例項

對於每個類而言，JRE都為其保留了一個不變的Class型別的物件，一個Class物件包含了特定某個結構（class/interface/enum/annotation/primitive type/void/[]）的有關資訊。

• Class本身就是一個類
• Class物件只能由系統建立物件
• 一個載入的類在JVM中只會有一個Class例項
• 一個Class物件對應的是一個載入到JVM中的一個.class檔案
• 每個類的例項都會記得自己是由哪個Class例項所生成
• 透過Class可以完整的得到一個類中的所有被載入的結構
• Class類是Reflection的根源，針對任何你想載入、執行的類，唯有先獲得相應的Class物件

Class類常用的方法

方法名	功能說明
static ClassforName(String name)	返回指定類名name的Class物件
Object newInstance()	呼叫預設建構函式，返回Class物件的一個例項
getName()	返回此Class物件所表示的實體（類、介面、陣列類、void）的名稱
Class getSuperClass()	返回當前Class物件的父類Class物件
Class[] getinterfaces()	獲取當前Class物件的介面
ClassLoader getClassLoader()	返回該類的類載入器
Constructor[] getConstructors()	返回一個包含某些Constructor物件的陣列
Method getMethod(String name,Class.. T)	返回一個Method物件，此物件的形參型別為paramType
Field[] getDeclareFields()	返回Field物件的一個陣列

獲取Class物件的三種方式：

package com.lily.demo3;

public class Test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //第一種方式:透過物件獲取
        Person person = new Person();
        Class c1 = person.getClass();

        //第二種方式: 使用Class.forName()
        Class c2 = Class.forName("com.lily.demo3.Person");

        //第三種方式: 透過類名.class
        Class c3 = Person.class;

        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
    }
}

class Person {
    private int id;
    private String name;
}

189568618
189568618
189568618

Process finished with exit code 0

所有型別的Class

package com.lily.demo3;

import java.lang.annotation.ElementType;

// 所有型別的class
public class Test2 {
    public static void main(String[] args) {
        //1. 類class
        Class c1 = Object.class;
        //2. 介面class
        Class c2 = Comparable.class;
        //3. 陣列class
        Class c3 = String[].class;
        Class c4 = String[][].class;
        //4. 註解class
        Class c5 = Deprecated.class;
        //5. 列舉class
        Class c6 = ElementType.class;
        //6. Integer class
        Class c7 = Integer.class;
        //7. void class
        Class c8 = void.class;
        //8. Class class
        Class c9 = Class.class;
    }
}

類的載入與ClassLoader

• 載入：將class檔案位元組碼內容載入到記憶體中，並將這些靜態資料轉換成方法區的執行時資料結構，然後生成一個代表該類的java.lang.Class物件
• 連結：將Java類的二進位制程式碼合併到JVM的執行狀態之中的過程
• 類的初始化

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

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

package com.lily.demo3;

public class Test3 {
    public static void main(String[] args) {
        //獲取系統類載入器-->使用者自定義編寫的類
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        //獲取系統類載入器的父類載入器-->擴充套件類載入器-->Java內建的類
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        //獲取擴充套件類載入器的父類載入器-->引導類載入器-->Java核心類庫
        ClassLoader superParent = parent.getParent();
        System.out.println(superParent);    //C/C++編寫
    }
}

jdk.internal.loader.ClassLoaders$AppClassLoader@36baf30c
jdk.internal.loader.ClassLoaders$PlatformClassLoader@b4c966a
null

Process finished with exit code 0

獲取執行時類的完整結構

package com.lily.demo3;

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

//獲得類的資訊
public class Test5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c = Class.forName("com.lily.demo3.User");
        //獲取類的名字
        String className = c.getName();//獲取包名+類名
        System.out.println(className);//com.lily.demo3.User
        String classSimpleName = c.getSimpleName(); //獲取類的簡單名字
        System.out.println(classSimpleName);//User
        System.out.println("=====================");
        //獲得類的屬性
        //c.getFields();//只能找到public定義的額屬性
        Field[] fields = c.getDeclaredFields(); //找到全部的屬性
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("=====================");
        //獲得指定屬性的值
        Field name = c.getDeclaredField("name");
        System.out.println(name);
        System.out.println("=====================");
        //獲得類的方法:可以獲得本類的全部方法
        Method[] declaredMethods = c.getDeclaredMethods();
        for (Method method : declaredMethods) {
            System.out.println(method);
        }
        System.out.println("=====================");
        //獲得指定方法
        Method method = c.getDeclaredMethod("getName");
        System.out.println(method);
        Method method2 = c.getDeclaredMethod("setName", String.class);
        System.out.println(method2);
        System.out.println("=====================");
        //獲得指定的構造器
        Constructor[] constructors = c.getConstructors();
        Constructor[] declaredConstructor = c.getDeclaredConstructors();
        for (Constructor constructor : declaredConstructor) {
            System.out.println(constructor);
        }
        //獲得指定的構造器
        Constructor declaredConstructor1 = c.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("指定構造器" + declaredConstructor1);
    }
}

class User {
    private String name;
    private int id;
    private int age;

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

    public User() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        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;
    }

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

D:\develop_tools\jdk21\jdk-21.0.1+12\bin\java.exe "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2023.2.3\lib\idea_rt.jar=52734:D:\Program Files\JetBrains\IntelliJ IDEA 2023.2.3\bin" -Dfile.encoding=UTF-8 -Dsun.stdout.encoding=UTF-8 -Dsun.stderr.encoding=UTF-8 -classpath C:\Users\Yihao\IdeaProjects\JVMDemo\out\production\anno com.lily.demo3.Test5
com.lily.demo3.User
User
=====================
private java.lang.String com.lily.demo3.User.name
private int com.lily.demo3.User.id
private int com.lily.demo3.User.age
=====================
private java.lang.String com.lily.demo3.User.name
=====================
public java.lang.String com.lily.demo3.User.getName()
public java.lang.String com.lily.demo3.User.toString()
public void com.lily.demo3.User.setName(java.lang.String)
public int com.lily.demo3.User.getId()
public void com.lily.demo3.User.setId(int)
public int com.lily.demo3.User.getAge()
public void com.lily.demo3.User.setAge(int)
=====================
public java.lang.String com.lily.demo3.User.getName()
public void com.lily.demo3.User.setName(java.lang.String)
=====================
public com.lily.demo3.User(java.lang.String,int,int)
public com.lily.demo3.User()
指定構造器public com.lily.demo3.User(java.lang.String,int,int)

Process finished with exit code 0

呼叫執行時類的指定結構

package com.lily.demo3;

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

// 透過你反射動態的建立物件
public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<?> c = Class.forName("com.lily.demo3.People");
        //構造一個物件
//        People p = (People) c.getDeclaredConstructor().newInstance();//預設呼叫無參構造器,如果沒有無參構造器，則會例項化失敗
//        System.out.println(p);

        //透過構造器建立物件(有參構建物件)
        People p1 = (People) c.getDeclaredConstructor(String.class, int.class, int.class).newInstance("lily", 1, 20);
        System.out.println(p1);

        //透過反射獲取方法
        Method method = c.getDeclaredMethod("setName", String.class);
        method.invoke(p1, "update_string");//invoke(物件,"引數值");--->執行方法
        System.out.println(p1);

        //透過反射操作屬性
        People p3 = (People) c.getDeclaredConstructor().newInstance();
        Field name = c.getDeclaredField("name");
        //不能直接操作私有屬性，我們需要關閉程式安全檢測: 屬性.setAccessible(true);
        name.setAccessible(true);
        name.set(p3, "hello");
        System.out.println(p3);
    }
}

class People {
    private String name;
    private int id;
    private int age;

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

    public People() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        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;
    }

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

獲取註解資訊

package com.lily.demo4;

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

// 練習反射操作註解
public class Test9 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        //根據反射獲取類物件
        Class<?> studentClass = Class.forName("com.lily.demo4.Student");
        //透過反射獲取註解
        Annotation[] annotations = studentClass.getDeclaredAnnotations();
        for (Annotation a : annotations) {
            System.out.println(a);
        }

        System.out.println("================");
        //獲取類上的註解值
        //根據Class物件獲取其類上的註解物件
        Table table = (Table) studentClass.getDeclaredAnnotation(Table.class);
        //獲取其註解物件上的值
        System.out.println(table.value());
        System.out.println("******************");

        //根據Class物件獲取其所有欄位
        Field[] fieldArray = studentClass.getDeclaredFields();
        for (Field f1 : fieldArray) {
            System.out.println(f1.getName());	//獲取欄位名
            Field f = studentClass.getDeclaredField(f1.getName());//根據欄位名獲取指定的欄位物件
            //根據欄位物件獲取其上自定義的註解物件
            MyField myFieldAnnotation = f.getDeclaredAnnotation(MyField.class);
            //根據註解物件獲取器註解上對應的值
            System.out.println(myFieldAnnotation.columnName());
            System.out.println(myFieldAnnotation.length());
            System.out.println(myFieldAnnotation.type());
        }
        System.out.println("******************");


        System.out.println("================");
        //獲取類欄位上的註解值
        Field f = studentClass.getDeclaredField("name");
        MyField myFieldAnnotation = f.getDeclaredAnnotation(MyField.class);
        System.out.println(myFieldAnnotation.columnName());
        System.out.println(myFieldAnnotation.length());
        System.out.println(myFieldAnnotation.type());
    }
}

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

//屬性註解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyField {
    String columnName();

    String type();

    int length();
}

@Table(value = "db_student")
class Student {
    @MyField(columnName = "db_id", type = "int", length = 10)
    private int id;
    @MyField(columnName = "db_age", type = "int", length = 5)
    private int age;
    @MyField(columnName = "db_name", type = "varchar", length = 3)
    private String name;

    public Student() {
    }

    public Student(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 "Student{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

D:\develop_tools\jdk21\jdk-21.0.1+12\bin\java.exe "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2023.2.3\lib\idea_rt.jar=53190:D:\Program Files\JetBrains\IntelliJ IDEA 2023.2.3\bin" -Dfile.encoding=UTF-8 -Dsun.stdout.encoding=UTF-8 -Dsun.stderr.encoding=UTF-8 -classpath C:\Users\Yihao\IdeaProjects\JVMDemo\out\production\anno com.lily.demo4.Test9
@com.lily.demo4.Table("db_student")
================
db_student
******************
id
db_id
10
int
age
db_age
5
int
name
db_name
3
varchar
******************
================
db_name
3
varchar

Process finished with exit code 0