學過框架的必看—Java反射

反射作爲 Java 的高級特性，很多框架中都用到了反射的知識，如 Spring，Hibernate等，通過配置就可以動態干預程序的運行，那麼什麼是反射呢？

要想理解 Java 反射，首先要弄清類的加載過程，比如這行代碼 Person p = new Person();，我們想要創建一個 Person 對象，並用 p 作爲對象的引用。在 Java 虛擬機會先執行類的加載，然後才生成對象（分配內存空間）。在類的加載過程中，類加載器負責把類編譯好的 class （字節碼）文件加入到內存中，並創建一個 Class 對象，這個對象是類 Class 的實例。也就是說，上面的一行的代碼看似只是創建了一個 Person 對象，但是如果是第一次使用該類，也即類加載器還未把該類的 class 文件加載到內存中時，還會創建一個 Class 對象。

在 Java 中，一切都是對象。類是對一類對象的抽象，類是一個概念，而類本身也是一種對象，在 Java 中，它們是 Class 類的對象，當然方法、屬性、註解也分別是 Method、Field、Annotation 的對象。這些類都是和反射相關的類，在 java.lang.reflect 包中可以找到。

我們怎麼能干預程序運行期做的事情呢？比如創建一個在編譯期不能確定的類。

我們用反射就可以做到了，反射是在運行期獲取自身的信息，比如某個類的信息，從而可以動態的創建某個類的對象。上面的問題其實就是一個類在編譯期是未知的，在運行期才能知道它究竟是什麼類。JDBC 操作數據庫第一步加載數據庫驅動， Class.forName("com.mysql.jdbc.Driver");，這裏是 MySQL 數據庫，假如某一天我們想換成 Oracle 數據庫，你可能會修改 forName() 方法中的參數爲 Oracle 數據庫驅動名。但其實我們還可以在不修改代碼的情況下實現修改，就像大多數框架那樣，我們可以使用個寫個配置文件，forName() 方法中的參數在配置文件中動態讀取，編譯好的代碼完全不用動，這裏其實就是反射的一個應用。另外在我們寫代碼時，在對象後面敲一個 . ，IDE（如 Eclipse）就會自動幫我們列出該對象有的方法，這裏其實就是IDE使用了反射，通過對象找到該類對應的 Class 對象，從而就可以找到類中的屬性和方法。

1、獲取 Class 對象的三種方法

從上面的介紹中，可以看到這個 Class 對象是我們使用反射的關鍵，而得到這個對象有下面三種方式。

1、調用 Class 類的 forName() 靜態方法 public static Class<?> forName(String className)

Class.forName("Person")

上面 JDBC 那裏就是使用的這種方法。

2、調用類的隱藏類屬性 class。

Person.class

3、使用對象來獲取，調用祖先類 Object 中的方法，public final native Class<?> getClass()

Person p = new Person();
p.getClass();

無論是否顯式聲明繼承，所有類都直接或間接繼承自 Object。

推薦使用第二種方式來獲取 Class 對象，因爲在編譯期就會檢查該類是否存在，更加安全，並且因爲沒有方法調用，使用的是屬性，所以性能也更高。

2、Class 對象中的方法

可以說我們得到了 Class 對象，就得到了這個類的所有信息了。想一想我們編寫的類中有什麼信息？如下面這個類

如果我們得到了 Class 對象，我們就得到了這個對象的一切信息，包括構造方法、屬性、方法、註解。

1、獲取屬性的方法

public Field getField(String name)
public Field[] getFields()
public Field getDeclaredField(String name)
public Field[] getDeclaredFields()

name 爲屬性的名稱

2、獲取構造函數的方法

public Constructor<T> getConstructor(Class<?>... parameterTypes)
public Constructor<?>[] getConstructors()
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
public Constructor<?>[] getDeclaredConstructors()

構造器在 Java 中也有對應的類 Constructor，parameterTypes 爲參數的 Class 對象，這是一個可變參數。

3、獲取普通函數的方法

public Method getMethod(String name, Class<?>... parameterTypes)
public Method[] getMethods()
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
public Method[] getDeclaredMethods()

name 爲方法的名稱，parameterTypes 爲參數的 Class 對象，這是一個可變參數。

4、獲取註解的方法

public boolean isAnnotation()
public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
public Annotation[] getAnnotations()
public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass)
public Annotation[] getDeclaredAnnotations()
public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationClass)
public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationClass)

annotationClass 爲對應的註解類。

5、其他常用方法

public String getName() // 返回 Class 對象表示的類型(類、接口、數組或基本類型)的完整路徑名字符串
public T newInstance() // 此方法是 Java 語言 instanceof 操作的動態等價方法
public ClassLoader getClassLoader() // 獲取該類的類加載器
public Class<? super T> getSuperclass() // 返回表示此 Class 所表示的實體（類、接口、基本類型或 void）的超類的 Class
public boolean isArray() // 如果 Class 對象表示一個數組則返回 true, 否則返回 false
public boolean isInterface() // 判定指定的 Class 對象是否表示一個接口類型
public boolean isPrimitive() // 判定指定的 Class 對象是否表示一個 Java 的基本類型

下面是測試代碼：

Animal 類

public class Animal {
    public String name;
    protected String sex;
    private int age;

    public Animal() {

    }

    public void run() {
        System.out.println("動物在跑");
    }
}

Dog 類

public class Dog extends Animal{
    public String color;
    protected String heart;
    private String unknown;

    public Dog() {

    }

    private Dog(String color) {
        this.color = color;
    }

    @Override
    public void run() {
        super.run();
        System.out.println("狗在跑");
    }

    void test() {
        System.out.println("test方法");
    }

    private void fanzhi() {
        System.out.println("生小狗");
    }
}

AnimalTest 類

import org.junit.Test;

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

public class AnimalTest {
    @Test
    // 構造方法
    public void constructorTest() throws NoSuchMethodException {
        Class dog = Dog.class;
        System.out.println("獲取指定的public構造方法");
        System.out.println(dog.getConstructor(String.class));
        System.out.println("獲取全部的public構造方法");
        Constructor[] constructors1 = dog.getConstructors();
        for(Constructor constructor : constructors1) {
            System.out.println(constructor);
        }
        System.out.println("獲取指定的構造方法，不受訪問修飾符的限制");
        System.out.println(dog.getDeclaredConstructor(String.class));
        System.out.println("獲取全部的構造方法，不受訪問修飾符限制");
        Constructor[] constructors2 = dog.getDeclaredConstructors();
        for(Constructor constructor : constructors2) {
            System.out.println(constructor);
        }
    }

    @Test
    // 屬性
    public void filedTest() throws NoSuchFieldException {
        Class dog = Dog.class;
        System.out.println("獲取指定的public屬性");
        System.out.println(dog.getField("color"));
        System.out.println("獲取全部的public屬性");
        Field[] fields1 = dog.getFields();
        for(Field field : fields1) {
            System.out.println(field);
        }
        System.out.println("獲取指定的屬性，不受訪問修飾符的限制");
        System.out.println(dog.getDeclaredField("unknown"));
        System.out.println("獲取全部的屬性，不受訪問修飾符限制");
        Constructor[] constructors2 = dog.getDeclaredConstructors();
        Field[] fields2 = dog.getDeclaredFields();
        for(Field field : fields2) {
            System.out.println(field);
        }
    }

    @Test
    // 方法
    public void mothodTest() throws NoSuchMethodException {
        Class dog = Dog.class;
        System.out.println("獲取指定的public方法");
        System.out.println(dog.getMethod("run"));
        System.out.println("獲取全部的public方法");
        Method[] methods1 = dog.getMethods();
        for(Method method: methods1) {
            System.out.println(method);
        }
        System.out.println("獲取指定的方法，不受訪問修飾符的限制");
        System.out.println(dog.getDeclaredMethod("fanzhi"));
        System.out.println("獲取全部的屬性，不受訪問修飾符限制");
        Method[] methods2 = dog.getDeclaredMethods();
        for(Method method: methods2) {
            System.out.println(method);
        }
    }

    @Test
    // 其他測試
    public void otherTest() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        Class dogClass = Dog.class;
        Dog dog = (Dog) dogClass.newInstance();
        // 調用私有方法
        Method fanzhi = dogClass.getDeclaredMethod("fanzhi");
        System.out.println(fanzhi.isAccessible()); // 是否取消了權限檢查
        fanzhi.setAccessible(true); //  取消權限檢查
        System.out.println(fanzhi.getModifiers()); // 權限符對應的數字 default：0，public：1，private：2，protected：4,
        fanzhi.invoke(dog); // 執行方法
    }
}

從上面的代碼中可以看到，使用反射可以取消權限檢查，使平時用一般方式不能訪問的方法，可以訪問並執行，但這也破壞了類的封裝性。

總結：反射可以使我們的代碼更具靈活性，但是反射也會消耗更多的系統資源，所以如果不需要動態創建一個對象，那麼就不需要用到反射。

學過框架的必看—Java反射

技術趣味史-Java語言的身世

如何高效學習編程技術？

Python日誌庫logging總結-可能是目前爲止將logging庫總結的最好的一篇文章

一文讀懂SpringMVC工作流程

代碼塊相關的題，特麼再也不會做錯了！

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結