反射機制

Java中處理基本數據類型，如int、char等，其他均為引用類型。

每個引用類型也是Java中的一個對象，稱為類對象，用以記錄該類的信息：包括類名、包名、父類、實現的接口、所有方法、字段等。通過該引用類型創建的實例，稱為類的實例對象。

Java對類對象的加載是動態的，只有當JVM第一讀取到該類Class（包括Interface）的信息時，才會將該類對象加載到內存中，并將該Class的名稱與類對象進行關聯。

反射：通過類型的名稱，構建類對象，獲取該類的信息。

public class ReflectTest {
    public static void main(String[] args) {
        String str = "hello";
        ///獲取類對象
        ///1
        Class cls = str.getClass();
        ///2
        cls = String.class;
        ///3
        try {
            cls = Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        String simpleName = cls.getSimpleName();
        String packageName = cls.getPackageName();
        String name = cls.getName();
        System.out.println(simpleName);//String
        System.out.println(packageName);///java.lang
        System.out.println(name);//java.lang.String
        System.out.println(cls);///class java.lang.String
    }
}

反射調用示例：

///將要反射的類
package learn.cls;
public class Person extends  Object {
    public int age;
    String name;

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

    public void introduce(String from) {
        System.out.printf("我叫%s,今年%d歲,來自%s%n",name,age,from);
    }
    public String getInfo() {
        return name + " : " +age + "歲";
    }
}
///反射調用
public class ReflectTest {
    public static void main(String[] args) {
        ///反射創建實例和調用方法
        try {
            Class cls = Class.forName("learn.cls.Person");
            ///調用指定的構造函數
            Object instance = cls.getDeclaredConstructor(String.class).newInstance("張三");
            ///反射字段
            Field field = cls.getDeclaredField("age");
            field.set(instance,18);
            ///獲取該字段的值
            Integer age = field.getInt(instance);
            System.out.println(age);///18
            ///反射方法
            Method method = cls.getDeclaredMethod("introduce", String.class);
            ///方法調用
            method.invoke(instance,"上海");///我叫張三,今年18歲,來自上海
            ///反射調用獲取返回值
            Method method1 = cls.getDeclaredMethod("getInfo");
            String info = (String) method1.invoke(instance);
            System.out.println(info);///張三 : 18歲
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
}
///上述反射調用等同于下述代碼
Person person = new Person("張三");
person.age = 18;
Integer age = person.age;
System.out.println(age);
person.introduce("上海");
String info = person.getInfo();
System.out.println(info);

動態代理

動態代理：JDK提供的動態創建接口對象的方式。定義了接口，但是并不去編寫實現類，而是直接通過JDK提供的一個Proxy.newProxyInstance()創建了一個接口對象。這種沒有實現類但是在運行期動態創建了一個接口對象的方式，我們稱為動態代碼。

示例1：

///接口
interface Game {
    void play(String toy);
    String category();
}

public class DynamicDelegateTest {
    public static void main(String[] args) {
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               ///等同接口方法的實現
                if (method.getName().equals("play")) {
                    String out = "let us play " + args[0];
                    System.out.println(out);
                } else if (method.getName().equals("category")) {
                    return "游戲";
                }
                return null;
            }
        };
       ///不寫實現類，直接創建接口對象
        Game game = (Game) Proxy.newProxyInstance(Game.class.getClassLoader(), new Class[]{Game.class},invocationHandler);
        game.play("basketball");///let us play basketball
        String str = game.category();//游戲
        System.out.println(str);
    }
}
///上述代碼的本質
public class DynamicDelegateTest implements Game {
    public InvocationHandler invocationHandler;
    public  DynamicDelegateTest(InvocationHandler handler){
        this.invocationHandler = handler;
    }
    @Override
    public void play(String toy) {
        try {
            this.invocationHandler.invoke(this, getClass().getDeclaredMethod("play", String.class), new Object[]{toy});
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
    @Override
    public String category() {
        String result = null;
        try {
           result = (String)this.invocationHandler.invoke(this, getClass().getDeclaredMethod("category"), null);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return  result;
    }
}

示例2：動態代理實現接口方法的監聽

public class DynamicDelegateTest {
    
    public static void main(String[] args) {
        Game game = new Game() {
            @Override
            public void play(String toy) {
                System.out.println("玩游戲中...");
            }

            @Override
            public String category() {
                return "游戲";
            }
        };
        ///game：最終執行方法的對象 proxyGame：實現接口方法監聽生效的對象
        Game proxyGame = (Game) proxyObject(game);
        ///啟用接口方法監聽
        proxyGame.play("籃球");
        ///輸出：
        /*
        方法：play，調用前
        玩游戲中...
        方法：play，調用后
        */
    }

    public static Object proxyObject(Game target) {
        Class[] interfaces = {Game.class};
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.printf("方法：%s，調用前%n", method.getName());
                ///對接口方法進行監聽后，由被代理的對象去執行
                Object objc = method.invoke(target, args);
                System.out.printf("方法：%s，調用后%n", method.getName());
                return objc;
            }
        };
        return Proxy.newProxyInstance(Game.class.getClassLoader(), interfaces, handler);
    }
}

Java注解

注解的概念

Java中的注解是一種可以放在類、字段、方法、參數前的特殊”注釋“。
Java中的注釋會被編譯器忽略，注解則可以被編譯器打包進.class文件，因此注解是一種用作標注的元數據。

Java中使用@interface來定義注解。注解的參數類似無參方法。聲明注解參數時，推薦使用default關鍵字為其設定默認值；常用的注解參數命名為value，可在注解參數只有一個時，省略其參數名稱。

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD,ElementType.METHOD})
public @interface Range {
    int min() default 0;
    int max() default 100;
    int value() default 50;
}

元注解

可以修飾其他注解的注解稱為元注解。Java標準庫已經定義了一些元注解，我們只需要使用元注解，通常不需要自己去編寫元注解。

@Target：定義注解可以被用于源碼的哪些位置。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    //注解參數為數組，可以定義多個位置
    ElementType[] value();
}
///該注解的參數類型：`ElementType`
public enum ElementType {
    TYPE,///類、接口、標注接口，枚舉、record 聲明
    FIELD,///類的字段聲明、包括枚舉常量
    METHOD,///方法聲明
    PARAMETER,///形式參數聲明
    CONSTRUCTOR,///構造函數聲明
    LOCAL_VARIABLE,///本地變量聲明
    ANNOTATION_TYPE, ///注解類型聲明
    PACKAGE,///Package聲明
    TYPE_PARAMETER,///類型參數聲明
    TYPE_USE,///使用類型
    MODULE,///模塊聲明
    RECORD_COMPONENT;///record部分
}

2.@Retention: 定義注解的生命周期
如果在一個注釋接口聲明中沒有Retention注釋，保留策略默認為RetentionPolicy.CLASS

/*If no Retention annotation is present on an annotation interface declaration, the retention policy defaults to RetentionPolicy.CLASS.*/
public @interface Retention {
    RetentionPolicy value();
}
///該注解的參數類型：`RetentionPolicy `
public enum RetentionPolicy {
    ///Annotations are to be discarded by the compiler.
    ///修飾的注解被編譯器舍棄
    SOURCE, ///編譯器
    /// Annotations are to be recorded in the class file by the compiler
    ///  but need not be retained by the VM at run time
   ///修飾的注解將被編譯器記錄到`java`類的`.class`文件中，但在運行時不需要被`JVM`保留
    CLASS,///class文件

    /// Annotations are to be recorded in the class file by the compiler and
    /// retained by the VM at run time, so they may be read reflectively.
    /// 修飾的注解將被編譯器記錄到`java`類的`.class`文件中，并且運行時會被`JVM`保留
    RUNTIME///運行期
}

@Repeatable：注釋其聲明的注釋接口是可重復的。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Repeatable {
    Class<? extends Annotation> value();
}
///可重復使用注解的定義
@Repeatable(value = Ranges.class)
@Target(ElementType.TYPE)
public @interface Range {
    int min() default 0;
    int max() default 100;
    int value() default 50;
}

@Target(ElementType.TYPE)
@interface Ranges {
    Range[] value();
}
///具體使用
@Range(min = 10,max = 200,value = 120)
@Range(80)
@Range(value = 19)
class Test {
}

@ Inherited
使用@Inherited定義子類是否可繼承父類定義的注解。@Inherited僅針對@Target(ElementType.TYPE)類型的注解有效，并且僅針對class的繼承，對interface的繼承無效：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}
///示例
@Inherited
@Target(ElementType.TYPE)
public @interface Report {
    int type() default 0;
    String level() default "info";
    String value() default "";
}
///父類使用了這個被`@Inherited`修飾的注解
@Report(type=1)
public class Person {
}
///子類默認也繼承了該父類的注解
public class Student extends Person {
}

注解的定義

第一步：使用@interface定義注解

public @interface Report {
}

第二步：定義注解的參數、默認值

public @interface Report {
    int type() default 0;
    String level() default "info";
    String value() default "";
}

把最常用的參數定義為value()，推薦所有參數都盡量設置默認值。
第三步：用元注解配置注解

@Target(ElementType.TYPE)///注解類、接口、枚舉等
@Retention(RetentionPolicy.RUNTIME)///運行期保留注解
public @interface Report {
    int type() default 0;
    String level() default "info";
    String value() default "";
}

其中，必須設置@Target和@Retention，@Retention一般設置為RUNTIME，因為我們自定義的注解通常要求在運行期讀取。一般情況下，不必寫@Inherited和@Repeatable。

注解的處理

注解定義后也是一種class，所有的注解都繼承自java.lang.annotation.Annotation，因此，讀取注解，需要使用反射API。

Java中提供的與注解相關的反射API


///-------判斷注解是否存在------

///判斷類是否有注解
AnnotationTest.class.isAnnotationPresent(Range.class);
///判斷類的構造函數是否有注解
AnnotationTest.class.getDeclaredConstructor().isAnnotationPresent(Range.class);
///判斷某個方法是否有注解
Method method = AnnotationTest.class.getMethod("getSomeUsefulInfo");
method.isAnnotationPresent(Range.class);
///判斷某個字段是否有注解
Field field = AnnotationTest.class.getField("userType");
field.isAnnotationPresent(Range.class);

///-------讀取注解信息------

///獲取類的注解
AnnotationTest.class.getAnnotation(Range.class);
try {
    ///獲取類的構造函數的注解
    AnnotationTest.class.getDeclaredConstructor().getAnnotation(Range.class);
    ///獲取某個方法的注解
    AnnotationTest.class.getMethod("getSomeUsefulInfo").getAnnotation(Range.class);
    //獲取某個字段的注解
    Field field = AnnotationTest.class.getField("userType");
    field.getAnnotation(Range.class);
 } catch (NoSuchMethodException e) {
      e.printStackTrace();
 } catch (NoSuchFieldException e) {
      e.printStackTrace();
}

Java注解的示例
1.定義兩個注解：Router和GetFuncInfo，分別用來注解類和方法

///注解類，定義類的實例對象需要執行的操作
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Router {
    String value() default "";
    String operation() default "getInfo";
}

///注解方法，并設置方法調用的默認參數
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface GetFuncInfo {
    String value() default "";
}

注解的類和方法

@Router(operation = "getSomeUsefulInfo",value = "markedClass")
public class AnnotationTest {
    
    public String param0;
    public String param1;
    public int param2;
    
    @GetFuncInfo("張三的個人信息")
    public void getSomeUsefulInfo(String param0){
        System.out.printf("getSomeUsefulInfo:%s",param0);
    }
    
    public void functionWithSomeParameters(String p1, int p2) {
        System.out.println(p1);
        System.out.println(p2);
    }
}

3.處理注解

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        ///定義操作
        String operate = "getSomeUsefulInfo";
        ///掃描`Router`注解的類，此處假設已知
        String classStr = "annotation.AnnotationTest";
        Class cls = Class.forName(classStr);

        if (cls.isAnnotationPresent(Router.class)){
            ///獲取類的注解
            Router router = (Router)cls.getAnnotation(Router.class);
            System.out.println(router);///@annotation.Router(value="markedClass", operation="getSomeUsefulInfo")
            ///根據注解的操作，找到對應的方法
            String operateStr = router.operation();
            for (Method method: cls.getMethods()) {
                if (method.getName().equals(operateStr)) {
                    ///獲取方法的注解
                    if (method.isAnnotationPresent(GetFuncInfo.class)){
                        GetFuncInfo funcInfo = method.getAnnotation(GetFuncInfo.class);
                        System.out.println(funcInfo);///@annotation.GetFuncInfo("\u5f20\u4e09\u7684\u4e2a\u4eba\u4fe1\u606f")
                        ///讀取注解參數
                        String param = funcInfo.value();
                        ///創建對象實例
                        Object clsObj = cls.getDeclaredConstructor().newInstance();
                        ///調用方法，傳入注解參數
                        method.invoke(clsObj,param); ///getSomeUsefulInfo:張三的個人信息
                    }
                }
            }
        }

    }

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Java基礎知識（二）

Java基礎知識（二）

反射機制

動態代理

Java注解

注解的概念

元注解

注解的定義

注解的處理

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Java基礎知識（二）

反射機制

動態代理

Java注解

注解的概念

元注解

注解的定義

注解的處理

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频