java反射機制怎么實現

這篇文章主要介紹“java反射機制怎么實現”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“java反射機制怎么實現”文章能幫助大家解決問題。

  1.獲取Class對象的三種方式

1. 通過對象的getClass()方法
Class c1=(new User()).getClass();

2. 通過字節(jié)碼文件獲取
Class c2=User.class;

3. 通過Class類的靜態(tài)方法獲取
Class c3=Class.forName("com.bee.entity.User");

2. 同一個類只會被加載一次

public class Test {

  public static void main(String[] args) {
    String path = "demo6.TestBean";
    try {
      Class<?> clazz1 = Class.forName(path);
      System.out.println(clazz1.hashCode());

      Class<?> class2 = Class.forName(path);
      System.out.println(class2.hashCode());

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

輸出

366712642
366712642

Class對象專門用來存放類的信息。一個類只對應一個Class對象。因為，類的對象雖然可以有多個，但對應的類只有一個。

3. 利用反射獲取類的信息

先定義一個類TestBean

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

  public TestBean() {
  }

  public String getName() {
    return name;
  }

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

  public int getAge() {
    return age;
  }

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

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

讀取上述類TestBean的信息

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

public class Test {

  public static void main(String[] args) {
    String path = "demo.TestBean";
    try {
      Class<?> clazz = Class.forName(path);

      // 獲取類的名字
      System.out.println(clazz.getName()); // 獲得包全路徑名
      System.out.println(clazz.getSimpleName()); // 只獲得類名

      // 獲取屬性信息
      Field[] fields1 = clazz.getFields(); // 只能獲取public屬性
      Field[] fields2 = clazz.getDeclaredFields(); // 可以獲得private屬性(可以獲得所有的屬性)
      Field field3 = clazz.getDeclaredField("name");
      for (Field field : fields2) {
        System.out.println("屬性：" + field);
      }

      // 獲取方法信息
      // clazz.getMethod(name, parameterTypes) 只能獲得public方法
      Method[] methods = clazz.getDeclaredMethods();
      Method method1 = clazz.getDeclaredMethod("getName", null);
      // 如果方法有參數，必須傳遞參數類型對應的Class對象。
      Method method2 = clazz.getDeclaredMethod("setName", String.class);
      for (Method method : methods) {
        System.out.println("方法：" + method);
      }

      // 獲得構造器信息
      // Constructor[] constructors=clazz.getConstructors() 只能獲得public構造方法
      Constructor[] constructors = clazz.getDeclaredConstructors();
      for (Constructor constructor : constructors) {
        System.out.println("構造器：" + constructor);
      }
      // 獲取無參構造器
      Constructor cons1 = clazz.getDeclaredConstructor(null);
      System.out.println("無參構造器：" + cons1);
      // 獲取有參構造器
      Constructor cons2 = clazz.getDeclaredConstructor(String.class, int.class);
      System.out.println("有參構造器：" + cons2);

    } catch (Exception e) {
      e.printStackTrace();
    }

  }

}

4. 通過反射動態(tài)操作構造器，方法，屬性

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

public class Test {

  public static void main(String[] args) {
    String path = "demo.TestBean";
    try {
      Class<TestBean> clazz = (Class<TestBean>) Class.forName(path);

      // 通過反射構造對象
      TestBean tb = clazz.newInstance(); // 調用TestBean的無參構造方法
      // 對于JavaBean/POJO/DTO必須要配置一個無參構造器，以便框架使用newInstance()構建對象實例。
      System.out.println(tb);

      // 調用有參構造器
      Constructor<TestBean> cons1 = clazz.getDeclaredConstructor(String.class, int.class);
      TestBean tb1 = cons1.newInstance("黃忠", 83);
      System.out.println(tb1.getName() + tb1.getAge() + "歲");

      // 通過反射調用普通方法
      TestBean tb2 = clazz.newInstance();
      tb2.setName("云長"); // 等效于下邊的invoke()方法
      tb2.setAge(57); // 等效于下邊的invoke()方法

      TestBean tb3 = clazz.newInstance();
      Method method1 = clazz.getDeclaredMethod("setName", String.class);
      Method method2 = clazz.getDeclaredMethod("setAge", int.class);
      method1.invoke(tb3, "玄德");
      method2.invoke(tb3, 66);
      System.out.println(tb3.getName() + tb3.getAge() + "歲");

      // 通過反射操作屬性
      TestBean tb4 = clazz.newInstance();
      Field f1 = clazz.getDeclaredField("name");
      Field f2 = clazz.getDeclaredField("age");

      // 報錯不能訪問私有屬性的解決方法（屬性可以設置，方法也可以這樣設置）
      f1.setAccessible(true);
      f2.setAccessible(true);

      f1.set(tb4, "紫龍");
      f2.set(tb4, 33);
      System.out.println(tb4.getName() + f2.get(tb4) + "歲");

    } catch (Exception e) {
      e.printStackTrace();
    }
  }

}

5. 反射機制的性能

• setAccessible

1. 是訪問安全檢查的開關。設置true表示反射的對象在使用時應該取消Java語言訪問檢查。

2. 禁止安全檢查可以提高反射的運行速度。

• 可以考慮使用cglib/javaassist字節(jié)碼操作提升反射操作的速度。

6. 反射操作泛型（Generic）

• Java使用泛型擦除機制來引入泛型。Java中的泛型僅僅是給編譯器javac使用的。泛型用于確保數據的安全性和免去強制類型轉換帶來的不便。Java一旦編譯完成，所有和泛型有關的類型將全部擦除。

• Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType幾種類型來代表不能被歸一到Class類中的類型，但又和原始類型保持一致。

1. ParameterizedType：表示一種參數化的類型，比如：Collection

2. GenericArrayType：表示一種元素類型是參數化類型或者類型變量的數組類型

3. TypeVariable：是各種類型變量的公共父接口

4. WildcardType：代表一種通配符類型表達式，比如：?，? extends Number，? super Integer。

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 Test {

  public void test1(Map<String, TestBean> map, List<TestBean> list) {
    System.out.println("Test.test1()");
  }

  public Map<Integer, TestBean> test2() {
    System.out.println("Test.test2()");
    return null;
  }

  public static void main(String[] args) {
    try {
      // 獲得指定方法參數泛型信息
      Method m = Test.class.getMethod("test1", Map.class, List.class);
      Type[] t = m.getGenericParameterTypes();
      for (Type type : t) {
        System.out.println("#" + type);
        if (type instanceof ParameterizedType) {
          Type[] genericTypes = ((ParameterizedType) type).getActualTypeArguments();
          for (Type genericType : genericTypes) {
            System.out.println("泛型類型：" + genericType);
          }
        }
      }

      System.out.println("-------------------");

      // 獲得指定方法返回值泛型信息
      Method m2 = Test.class.getMethod("test2", null);
      Type returnType = m2.getGenericReturnType();
      System.out.println("#" + returnType);
      if (returnType instanceof ParameterizedType) {
        Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();
        for (Type type : genericTypes) {
          System.out.println("返回值泛型類型：" + type);
        }
      }

    } catch (NoSuchMethodException e) {
      e.printStackTrace();
    } catch (SecurityException e) {
      e.printStackTrace();
    }

  }

}

關于“java反射機制怎么實現”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業(yè)相關的知識，可以關注億速云行業(yè)資訊頻道，小編每天都會為大家更新不同的知識點。