Java反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱爲Java語言的反射機制。
(功能、作用 -> 應用？)
1、Class是一個類，一個描述類的類（也就是描述類本身），封裝了描述方法的Method，描述字段的Filed，描述構造器的Constructor等屬性
2、對象照鏡子後（反射）可以得到的信息：某個類的數據成員名、方法和構造器、某個類到底實現了哪些接口。
3、對於每個類而言，JRE 都爲其保留一個不變的 Class 類型的對象。
一個 Class 對象包含了特定某個類的有關信息。
4、Class 對象只能由系統建立對象
5、一個類在 JVM 中只會有一個Class實例
package com.java.reflection;
public class Person {
String name;
private int age;
public Person() {
System.out.println("無參構造器");
}
public Person(String name, int age) {
System.out.println("有參構造器");
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
/**
* 反射機制獲取類有三種方法
*/
@Test
public void testGetClass() throws ClassNotFoundException {
Class clazz = null;
//1 直接通過類名.Class的方式得到
clazz = Person.class;
System.out.println("通過類名: " + clazz);
//2 通過對象的getClass()方法獲取,這個使用的少（一般是傳的是Object，不知道是什麼類型的時候才用）
Object obj = new Person();
clazz = obj.getClass();
System.out.println("通過getClass(): " + clazz);
//3 通過全類名獲取，用的比較多，但可能拋出ClassNotFoundException異常
clazz = Class.forName("com.java.reflection.Person");
System.out.println("通過全類名獲取: " + clazz);
}
| 通過類名: class com.java.reflection.Person 無參構造器 通過getClass(): class com.java.reflection.Person 通過全類名獲取: class com.java.reflection.Person |
3、利用newInstance創建對象：調用的類必須有無參的構造器
/**
* Class類的newInstance()方法，創建類的一個對象。
*/
@Test
public void testNewInstance()
throws ClassNotFoundException, IllegalAccessException, InstantiationException {
Class clazz = Class.forName("com.java.reflection.Person");
//使用Class類的newInstance()方法創建類的一個對象
//實際調用的類的那個 無參數的構造器（這就是爲什麼寫的類的時候，要寫一個無參數的構造器，就是給反射用的）
//一般的，一個類若聲明瞭帶參數的構造器，也要聲明一個無參數的構造器
Object obj = clazz.newInstance();
System.out.println(obj);
}
| 無參構造器 Person{name='null', age=0} |
/**
* ClassLoader類裝載器
*/
@Test
public void testClassLoader1() throws ClassNotFoundException, IOException {
//1、獲取一個系統的類加載器
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
System.out.println("系統的類加載器-->" + classLoader);
//2、獲取系統類加載器的父類加載器(擴展類加載器（extensions classLoader）)
classLoader = classLoader.getParent();
System.out.println("擴展類加載器-->" + classLoader);
//3、獲取擴展類加載器的父類加載器
//輸出爲Null,無法被Java程序直接引用
classLoader = classLoader.getParent();
System.out.println("啓動類加載器-->" + classLoader);
//
//4、測試當前類由哪個類加載器進行加載 ,結果就是系統的類加載器
classLoader = Class.forName("com.java.reflection.Person").getClassLoader();
System.out.println("當前類由哪個類加載器進行加載-->"+classLoader);
//5、測試JDK提供的Object類由哪個類加載器負責加載的
classLoader = Class.forName("java.lang.Object").getClassLoader();
System.out.println("JDK提供的Object類由哪個類加載器加載-->" + classLoader);
}
| 系統的類加載器-->sun.misc.Launcher$AppClassLoader@43be2d65 擴展類加載器-->sun.misc.Launcher$ExtClassLoader@7a9664a1 啓動類加載器-->null 當前類由哪個類加載器進行加載-->sun.misc.Launcher$AppClassLoader@43be2d65 JDK提供的Object類由哪個類加載器加載-->null |
4.1、getResourceAsStream方法
@Test
public void testGetResourceAsStream() throws ClassNotFoundException, IOException {
// 這麼寫的話，文件需要放到src目錄下
// InputStream in = new FileInputStream("test.properties");
//5、關於類加載器的一個主要方法
//調用getResourceAsStream 獲取類路徑下的文件對應的輸入流
InputStream in = this.getClass().getClassLoader()
.getResourceAsStream("com/java/reflection/test.properties");
System.out.println("in: " +in);
Properties properties = new Properties();
properties.load(in);
String driverClass = properties.getProperty("dirver");
String jdbcUrl = properties.getProperty("jdbcUrl");
//中文可能會出現亂碼，需要轉換一下
String user = new String(properties.getProperty("user").getBytes("ISO-8859-1"), "UTF-8");
String password = properties.getProperty("password");
System.out.println("diverClass: "+driverClass);
System.out.println("user: " + user);
}
test.properties內容如下：
| dirver=com.mysql.jdbc.Driver; jdbcUrl=jdbc:mysql://192.168.42.108:3306/test user=測試 password=993803 |
結果：
| in: java.io.BufferedInputStream@2aca0115 diverClass: com.mysql.jdbc.Driver; user: 測試 |
public class Person {
private String name;
private int age;
//新增一個私有方法
private void privateMthod(){
}
public Person() {
System.out.println("無參構造器");
}
public Person(String name, int age) {
System.out.println("有參構造器");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
*
* @param age 類型用Integer，不用int
*/
public void setName(String name , int age){
System.out.println("name: " + name);
System.out.println("age:"+ age);
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
@Test
public void testMethod() throws ClassNotFoundException, NoSuchMethodException,
IllegalAccessException, InstantiationException, InvocationTargetException {
Class clazz = Class.forName("com.java.reflection.Person");
//1、得到clazz 對應的類中有哪些方法,不能獲取private方法
Method[] methods =clazz.getMethods();
System.out.print(" getMethods: ");
for (Method method : methods){
System.out.print(method.getName() + ", ");
}
//2、獲取所有的方法(且只獲取當着類聲明的方法，包括private方法）
Method[] methods2 = clazz.getDeclaredMethods();
System.out.print("\ngetDeclaredMethods: ");
for (Method method : methods2){
System.out.print(method.getName() + ", ");
}
//3、獲取指定的方法
Method method = clazz.getDeclaredMethod("setName",String.class);//第一個參數是方法名，後面的是方法裏的參數
System.out.println("\nmethod : " + method);
Method method2 = clazz.getDeclaredMethod("setName",String.class ,int.class);//第一個參數是方法名，後面的是方法裏的參數
System.out.println("method2: " + method2);
//4、執行方法！
Object obj = clazz.newInstance();
method2.invoke(obj, "changwen", 22);
}
| getMethods: toString, getName, setName, setName, setAge, getAge, wait, wait, wait, equals, hashCode, getClass, notify, notifyAll, getDeclaredMethods: toString, getName, setName, setName, setAge, getAge, privateMthod, method : public void com.java.reflection.Person.setName(java.lang.String) method2: public void com.java.reflection.Person.setName(java.lang.String,int) 無參構造器 name: changwen age:22 |
public class PersonInvoke {
public PersonInvoke() {
}
private String method2() {
return "Person private String method2";
}
}
public class StudentInvoke extends PersonInvoke{
private void method1(Integer age) {
System.out.println("Student private void method1, age=:" +age);
}
}
獲取當前類的父類定義的私有方法
/**
* 獲取當前類的父類中定義的私有方法
* 直接調用getSuperclass()
*/
@Test
public void testGetSuperClass() throws Exception {
String className = "com.java.reflection.StudentInvoke";
Class clazz = Class.forName(className);
Class superClazz = clazz.getSuperclass();
System.out.println(superClazz);
//輸出結果：class com.java.reflection.PersonInvoke
}
另一種寫法
/**
* @param className 某個類的全類名
* @param methodName 類的一個方法的方法名，該方法也可能是私有方法
* @param args 調用該方法需要傳入的參數 ...可變參數的意思
* @return 調用方法後的返回值
*/
public Object invoke(String className, String methodName, Object ... args) {
Object obj = null;
try {
obj = Class.forName(className).newInstance();
return invoke(obj, methodName, args);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return invoke(null, methodName, args);
}
/**
* @param obj 方法執行的那個對象
* @param methodName 類的一個方法的方法名，該方法也可能是私有方法,還可能是該方法在父類中定義的私有方法
* @param args 調用該方法需要傳入的參數 ...可變參數的意思
* @return 調用方法後的返回值
*/
public Object invoke(Object obj, String methodName, Object ... args) {
//1、獲取Method對象
Class [] parameterTypes = new Class[args.length];
for (int i=0 ; i<args.length; i++){
parameterTypes[i] = args[i].getClass();
}
try {
//2、執行Method方法
Method method = getMethod(obj.getClass(), methodName,parameterTypes);
//通過反射執行private方法
method.setAccessible(true);
//3、返回方法的返回值
return method.invoke(obj,args);
} catch (Exception e) {
}
return null;
}
/**
* 獲取clazz 的methodName 方法， 該方法可能是私有方法，還可能是父類中的私有方法
*/
public Method getMethod(Class clazz, String methodName, Class ... parameterTypes) {
//注意這個循環裏的內容！！！
for (; clazz != Object.class; clazz = clazz.getSuperclass()){
try {
return clazz.getDeclaredMethod(methodName, parameterTypes);
} catch (Exception e) { //這裏要寫Exception，不然會出錯，應該是有部分異常沒有捕獲
}
}
return null;
}
測試：
@Test
public void testInvoke2() {
Object obj = new StudentInvoke();
invoke(obj, "method1", 10);
Object result = invoke(obj, "method2");
System.out.println(result);
}
| private void method1,age:10 Person private String method2 |
public class Person {
public String name;
private Integer age;
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
}
/**
* Field: 封裝了字段的信息
*/
@Test
public void testField() throws
ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
Class clazz = Class.forName("com.java.reflection.Person");
//1、獲取字段
//1.1 獲取Field的數組,私有字段也能獲取
Field[] fields = clazz.getDeclaredFields();
for (Field field: fields) {
System.out.print(field.getName() + ", ");
}
//1.2 獲取指定名字的Field（如果是私有的，見下面的4)
Field field = clazz.getDeclaredField("name");
System.out.println("\n獲取指定Field名=: " + field.getName());
Person person = new Person("ABC", 12);
//2、獲取指定對象的Field的值
Object val = field.get(person);
System.out.println("獲取指定對象字段'name'的Field的值=： " + val);
//3、設置指定對象的Field的值
field.set(person, "changwen2");
System.out.println("設置指定對象字段'name'的Field的值=: " + person.name);
//4、若該字段是私有的，需要調用setAccessible(true)方法
Field field2 = clazz.getDeclaredField("age");
field2.setAccessible(true);
System.out.println("獲取指定私有字段名=: " + field2.getName());
}
| name, age, 獲取指定Field名=: name 獲取指定對象字段'name'的Field的值=： ABC 設置指定對象字段'name'的Field的值=: changwen2 獲取指定私有字段名=: age |
/**
* 一個實例：
* 反射獲取一個繼承Person2的Student類
* 設置字段"age"=20(該字段可能爲私有，可能在其父類中）
*/
@Test
public void testClassField() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
String className = "com.java.reflection.Student";
String fieldName = "age"; //可能爲私有，可能在其父類中
Object val = 20;
//創建className 對應類的對象，併爲其fieldName賦值爲val
Class clazz = Class.forName(className);
Field field = null;
for (Class clazz2 = clazz; clazz2 != Object.class; clazz2 = clazz2.getSuperclass()){
try {
field = clazz2.getDeclaredField(fieldName);
} catch (Exception e) {
}
}
Object obj = clazz.newInstance();
assert field != null;
field.setAccessible(true);
field.set(obj, val);
Student stu = (Student) obj;
System.out.println("age = " + stu.getAge());
}
/**
* 構造器：開發用的比較少
*/
@Test
public void testConstructor() throws ClassNotFoundException, NoSuchMethodException,
IllegalAccessException, InvocationTargetException, InstantiationException {
String className = "com.java.reflection.Person";
Class<Person> clazz = (Class<Person>) Class.forName(className);
//1.獲取Constructor對象
Constructor<Person>[] constructors =
(Constructor<Person>[]) Class.forName(className).getConstructors();
for (Constructor<Person> constructor: constructors) {
System.out.println(constructor);
}
Constructor<Person> constructor = clazz.getConstructor(String.class, Integer.class);
System.out.println("指定的-->" + constructor);
//2.調用構造器的newInstance()方法創建對象
Object obj= constructor.newInstance("changwen", 11);
}
| public com.java.reflection.Person() public com.java.reflection.Person(java.lang.String,java.lang.Integer) 指定的-->public com.java.reflection.Person(java.lang.String,java.lang.Integer) |
•從 JDK5.0 開始,Java 增加了對元數據(MetaData)的支持,也就是Annotation(註釋)
•Annotation其實就是代碼裏的特殊標記,這些標記可以在編譯,類加載, 運行時被讀取,並執行相應的處理.通過使用Annotation,程序員可以在不改變原有邏輯的情況下,在源文件中嵌入一些補充信息.
•Annotation 可以像修飾符一樣被使用,可用於修飾包,類,構造器, 方法,成員變量, 參數,局部變量的聲明,這些信息被保存在Annotation的 “name=value”對中.
•Annotation能被用來爲程序元素(類,方法,成員變量等)設置元數據
基本的 Annotation
•使用 Annotation時要在其前面增加@符號,並把該Annotation 當成一個修飾符使用.用於修飾它支持的程序元素
•三個基本的Annotation:
–@Override:限定重寫父類方法,該註釋只能用於方法
–@Deprecated:用於表示某個程序元素(類,方法等)已過時
–@SuppressWarnings:抑制編譯器警告.
自定義 Annotation
•定義新的 Annotation類型使用@interface關鍵字
•Annotation 的成員變量在Annotation 定義中以無參數方法的形式來聲明.其方法名和返回值定義了該成員的名字和類型.
•可以在定義Annotation的成員變量時爲其指定初始值,指定成員變量的初始值可使用default關鍵字
•沒有成員定義的Annotation稱爲標記;包含成員變量的Annotation稱爲元數據Annotation
@Retention(RetentionPolicy.RUNTIME) //運行時檢驗
@Target(value = {ElementType.METHOD}) //作用在方法上
public @interface AgeValidator {
int min();
int max();
}
/**
* 通過反射才能獲取註解
*/
@Test
public void testAnnotation() throws Exception {
//這樣的方式不能使用註解
Person3 person3 = new Person3();
person3.setAge(10);*/
String className = "com.java.reflection.Person3";
Class clazz = Class.forName(className);
Object obj = clazz.newInstance();
Method method = clazz.getDeclaredMethod("setAge",Integer.class);
int val =40;
//獲取註解
Annotation annotation = method.getAnnotation(AgeValidator.class);
if (annotation != null){
if (annotation instanceof AgeValidator){
AgeValidator ageValidator = (AgeValidator) annotation;
if (val< ageValidator.min() || val>ageValidator.max()){
throw new RuntimeException("數值超出範圍");
}
}
}
method.invoke(obj, val);
System.out.println(obj);
}
提取 Annotation信息
•JDK5.0 在 java.lang.reflect包下新增了 AnnotatedElement接口,該接口代表程序中可以接受註釋的程序元素
•當一個 Annotation類型被定義爲運行時Annotation後,該註釋纔是運行時可見,當 class文件被載入時保存在 class文件中的 Annotation纔會被虛擬機讀取
•程序可以調用AnnotationElement對象的如下方法來訪問 Annotation信息
–獲取 Annotation實例：
•getAnnotation(Class<T> annotationClass)
•getDeclaredAnnotations()
•getParameterAnnotations()
JDK 的元Annotation
•JDK 的元Annotation 用於修飾其他Annotation 定義
•@Retention:只能用於修飾一個 Annotation定義,用於指定該 Annotation可以保留多長時間,@Rentention包含一個RetentionPolicy類型的成員變量,使用 @Rentention時必須爲該 value成員變量指定值:
–RetentionPolicy.CLASS:編譯器將把註釋記錄在 class文件中.當運行 Java程序時,JVM 不會保留註釋.這是默認值
–RetentionPolicy.RUNTIME:編譯器將把註釋記錄在class文件中. 當運行 Java 程序時, JVM 會保留註釋. 程序可以通過反射獲取該註釋
–RetentionPolicy.SOURCE:編譯器直接丟棄這種策略的註釋
•@Target: 用於修飾Annotation 定義,用於指定被修飾的 Annotation能用於修飾哪些程序元素.@Target 也包含一個名爲 value的成員變量.
•@Documented:用於指定被該元 Annotation修飾的 Annotation類將被 javadoc工具提取成文檔.
•@Inherited:被它修飾的 Annotation將具有繼承性.如果某個類使用了被@Inherited 修飾的Annotation, 則其子類將自動具有該註釋