关于java:框架的底层知识反射

家喻户晓，注解和反射是框架的底层常识，自己就是因为在 Spring 动静代理时学习时感觉很懵逼，特意回来重新学习了一下反射和注解，并整顿了相干笔记，心愿对你们会有所帮忙！

动静语言

是一类在运行时能够扭转其构造的语言：例如新的函数、对象、甚至代码能够被引进，已有的函数能够被删除或是其余构造上的变动。艰深点说就是在运行时代码能够依据某些条件扭转本身构造。
次要动静语言：Object-C、C#、JavaScript、PHP、Python 等

动态语言

与动静语言绝对应的，运行时构造不可变的语言就是动态语言。如：Java、C、C++。
Java 不是动静语言，但 Java 能够称之为“准动静语言”。即 Java 有肯定的动态性，咱们能够利用反射机制取得相似动静语言的个性。Java 的动态性让编程的时候更加灵便！

Reflection（反射）是 Java 被视为动静语言的要害，反射机制容许程序在执行期借助于 Reflection API 获得任何类的外部信息，并能间接操作任意对象的外部属性及办法。

Class c = Class.forName("java.lang.String")

加载完类之后，在堆内存的办法区就产生了一个 Class 类型的对象（一个类只有一个 Class 对象），这个对象就蕴含了残缺的类的构造信息。咱们能够通过这个对象看到类的构造。这个对象就像一面镜子，透过这个镜子看到类的构造，所以，咱们形象的称之为：反射！

失常形式：引入须要的包类名称 –> 通过 new 实例化 –> 获得实例化对象

反射形式：实例化对象 –> getClass()办法 –> 失去残缺的包类名称

Java 反射机制提供的性能

在运行时判断任意一个对象所属的类
在运行时结构任意一个类的对象
在运行时判断任意一个类所具备的成员变量和办法
在运行时获取泛型信息
在运行时调用任意一个对象的成员办法和变量
在运行时解决注解
生成动静代理【Spring AOP】
……

Java 反射长处和毛病

长处：

能够实现动静创建对象和编译，体现出很大的灵活性。

毛病：

对性能有影响。应用反射基本上是一种解释操作，咱们能够通知 JVM，咱们心愿做什么并且它满足咱们的要求。这类操作总是慢于间接执行雷同的操作。

Class 类：

对象照镜子后能够失去的信息：某个类的属性、办法和结构器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留了一个不变的 Class 类型对象。一个 Class 对象蕴含了特定某个构造（class/interface/enum/annotation/primitive type/void）的无关信息。

Class 自身也是一个类
Class 对象只能由零碎建设对象
一个加载的类在 JVM 中只会有一个 Class 实例
一个 Class 对象对应的是一个加载到 JVM 中的一个.class 文件
每个类的实例都会记得本人是由哪个 Class 实例所生成的
通过 Class 能够残缺的失去一个类中的所有被加载的构造
Class 类是 Reflection 的本源，针对任何你想动静加载、运行的类，唯有先取得相应的 Class 对象

获取 Class 类的实例

若已知具体的类，通过类的 class 属性获取，该办法 最为安全可靠，程序性能最高。

Class c1 = Person.class;

已知某个类的实例，调用该实例的 getClass()办法获取 Class 对象

Class c1 = Person.getClass();

已知一个类的全类名，且该类在门路下，看通过 Class 类的静态方法 forName()获取，可能抛出 ClassNotFoundException

Class c1 = Class.forName("demo01.Student");

内置根本数据类型 能够间接用.Type
还能够应用 ClassLoader

测试代码如下：

package cn.edu.zhku.reflection;

public class Test01 {public static void main(String[] args) throws ClassNotFoundException {Person person = new Student();
        System.out.println("这个人是" + person.name);

        // 形式一: 通过 getClass 的形式取得 Class 对象
        Class c1 = person.getClass();

        // 形式二: 通过 类名.class 的形式取得
        Class c2 = Student.class;

        // 形式三: 通过 forName 的形式取得
        Class c3 = Class.forName("cn.edu.zhku.reflection.Student");

        // 包装类型的获取
        Class<Integer> c4 = Integer.TYPE;

        // 判断取得的 class 对象是不是同一个对象
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4);
    }
}

class Person{
    public String name;

    public Person() {}

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person{public Student(){this.name = "学生";}
}

输入后果：

这个人是学生
1229416514
1229416514
1229416514
int

当程序被动应用某个类时，如果该类还未被加载到内存中，则零碎会通过如下三个步骤来对该类进行初始化。

类的加载和 ClassLoader 的了解

加载：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成办法区的运行时数据结构，而后生成一个代表这个类的 java.lang.Class 对象。
链接：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程。
- 验证：确保加载的类信息合乎 JVM 标准，没有平安方面的问题。
- 筹备：正式为类变量（static）分配内存并设置类变量默认初始化的阶段，这些内存都将在办法区中进行调配。
- 解析：虚拟机常量池内的符号援用（变量名）替换为间接援用（地址）的过程。
初始化：
- 执行类结构器 <clinit> () 办法的过程。类结构器 <clinit> () 是由编译期间主动收集类中所有类变量的赋值动作和动态代码块中的语句合并产生的。（类结构器是结构该类的信息，不是结构该类对象的结构器）
- 当初始化一个类的时候，如果发现其父类还没有初始化，则须要先触发其父类的初始化。
- 虚构机会保障一个类的 <clinit> () 在多线程环境中被正确加锁和同步。

测试代码

public class Test02 {public static void main(String[] args) {A a = new A();
        System.out.println(a.m);
    }
}

class A{
    static {System.out.println("这是动态代码块");
        m = 300;
    }
    
    /*
        m = 300
        m = 100 
        进行笼罩了
    */
    static int m = 100;

    public A() {System.out.println("这是构造方法");
    }
}

输入后果：

这是动态代码块
这是构造方法
100

剖析执行步骤：

加载到内存，会产生一个类对应 Class 的对象
通过链接初始化变量，m = 0

初始化clinit()

先执行动态代码块

clinit(){System.out.println("这是动态代码块");
    // 而后 
    m = 300;
}


2.  而后执行构造方法

```java
System.out.println("这是构造方法");
```

3.  而后执行 static int m = 100；对之前的 m 的值进行了笼罩。

什么时候会产生类初始化

类的被动援用（肯定会产生类的初始化）
- 当虚拟机启动，先初始化 main 办法所在的类
- new 一个类的对象
- 调用类的动态成员（除了 final 常量）和静态方法
- 应用 java.lang.reflect 包的办法对类进行 反射调用
- 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
类的被动援用（不会产生类的初始化）
- 当拜访一个动态域时，只有真正申明这个域的类才会被初始化。如：当通过子类援用父类的动态变量，不会导致子类初始化
- 通过数组定义类援用，不会触发此类的初始化
- 援用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

测试代码如下：

public class Test03 {
    static {System.out.println("Main 被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {//Son son = new Son();
        /**
         * 输入后果:
         *        Main 被加载
         *        父类被加载
         *        子类被加载
         */

        // 通过反射进行类初始化
        //Class.forName("cn.edu.zhku.reflection.Son");
        /**
         * 输入后果:
         *        Main 被加载
         *        父类被加载
         *        子类被加载
         */

        //System.out.println(Son.father);
        /**
         * 输入后果:
         *        Main 被加载
         *        父类被加载
         *        1
         */

        System.out.println(Son.SON);
        /**
         * 输入后果:
         *        Main 被加载
         *        50
         */
    }
}

class Father{
    static {System.out.println("父类被加载");
    }
    static int father = 1;
}

class Son extends Father{
    static {System.out.println("子类被加载");
        son = 300;
    }

    static int son = 100;
    static final int SON = 50;
}

类加载器的作用：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成办法区的运行时数据结构，而后在堆中生成一个代表这个类的 java.lang.Class 对象，作为办法区中类数据的拜访入口。
类缓存：规范的 JavaSE 类加载器能够按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过 JVM 垃圾回收机制能够回收这些 Class 对象

类加载器作用是用来把 class 装载进内存的。JVM 标准定义了如下类型的类的加载器。

Java 外围库在 rt.jar 中

测试代码：

// 类加载器
public class Test04 {public static void main(String[] args) throws ClassNotFoundException {

        // 获取零碎类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        // 获取零碎类加载器的父类加载器 --> 扩大类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        // 获取扩大类加载器的父类加载器 --> 根加载器(C/C++ 写的)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        // 测试以后类是哪个类加载加载的
        ClassLoader classLoader = Class.forName("cn.edu.zhku.reflection.Test04").getClassLoader();
        System.out.println(classLoader);

        // 测试 jdk 外部类是哪个类加载加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);
        
    }
}

输入后果如下：

sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@49476842
null
sun.misc.Launcher$AppClassLoader@18b4aac2
null

执行步骤：用户加载器（AppClassLoader）–> 扩大加载器（ExtClassLoader）–> 根加载器（RootClassLoader）

通过反射获取运行时类的残缺构造包含以下这些：

Field、Method、Constructor、SuperClass、Interface、Annotation

实现的全副接口
所继承的父类
全副的结构器
全副的办法
全副的 Field
注解

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

// 取得类的信息
public class Test05 {public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {Class c1= Class.forName("cn.edu.zhku.reflection.User");

        // 取得类的名字 包名 + 类名
        System.out.println(c1.getName());
        // 取得类的简略名字 类名
        System.out.println(c1.getSimpleName());

        // 取得类的属性
        /**
         * getFields(); 只能获取 public 属性
         * getDeclaredFields(); 能够获取全副的属性
         */
        System.out.println("===================");
        Field[] fields = c1.getFields();
        fields = c1.getDeclaredFields();
        for (Field field : fields) {System.out.println(field);
        }

        // 取得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        // 取得类的办法
        System.out.println("===================");
        Method[] methods = c1.getMethods();// 取得本类及其父类的全副 public 办法
        for (Method method : methods) {System.out.println("失常的:" + method);
        }
        methods = c1.getDeclaredMethods(); // 取得本类的所有办法
        for (Method method : methods) {System.out.println("getDeclaredMethods" + method);
        }

        // 取得指定办法
        Method getName = c1.getDeclaredMethod("getName", null);
        System.out.println(getName);
        Method setName = c1.getDeclaredMethod("setName", String.class);
        System.out.println(setName);

        // 取得指定的结构器
        System.out.println("===================");
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {System.out.println(constructor);
        }
        constructors = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {System.out.println("----" + constructor);
        }

        // 取得指定的结构器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("指定的结构器" + declaredConstructor);
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class User{
    private String name;
    private int id;
    private int age;

小结：

在理论的操作中，获得类的信息的操作代码，并不会常常开发。
肯定要相熟 java.lang.reflect 包的作用，反射机制。
如何获得属性、办法、结构器的名称，修饰符等。

有了 Class 对象，能做什么？

创立类的对象：调用 Class 对象的 newInstance()办法
- 类必须有一个无惨结构器。
- 类的结构器的拜访权限须要足够

测试代码：

User.java

@Data
@AllArgsConstructor
@NoArgsConstructor
class User{
    private String name;
    private int id;
    private int age;
}

Test06.java

// 动静的创建对象, 通过反射
public class Test06 {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {Class c1 = Class.forName("cn.edu.zhku.reflection.User");

        // 结构一个对象
        User user = (User) c1.newInstance(); // 实质上是调用了类的无参结构器
        System.out.println(user);
    }
}

输入后果：

User(name=null, id=0, age=0)

思考？

难道没有无参的结构器就不能创建对象了吗？把生成无参结构器的这个注解 @NoArgsConstructor 去掉后，测试发现抛出了异样信息java.lang.InstantiationException

怎么解决呢？

其实只有在操作的时候明确的调用类中的结构器并将参赛传递进去之后，才能够实例化操作。

步骤如下：

通过 Class 类的 getDeclaredConstructor(Class … parameterTypes)获得本类的指定形参类型的结构器。
向结构器的形参中传递一个对象数组进去，外面蕴含了结构器中所需的各个参数。
通过 Constructor 实例化对象。

测试代码如下：

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

// 动静的创建对象, 通过反射
public class Test06 {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {Class c1 = Class.forName("cn.edu.zhku.reflection.User");

        // 通过结构器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user = (User) constructor.newInstance("白衣",001,18);
        System.out.println(user);
    }
}

输入后果：

User(name= 白衣, id=1, age=18)

通过反射操作类对应的属性

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

// 动静的创建对象, 通过反射
public class Test06 {public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {Class c1 = Class.forName("cn.edu.zhku.reflection.User");

        // 通过反射调用一般办法
        User user = (User) c1.newInstance();
        // 通过反射取得一个办法
        Method setName = c1.getDeclaredMethod("setName", String.class);

        // invoke: 激活, 调用的意思 (对象,"办法的值")
        setName.invoke(user, "白衣");
        System.out.println(user.getName());

        // 通过反射操作属性
        System.out.println("=============");
        User user2 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");

        // 不能间接操作公有属性, 咱们须要关闭程序的平安监测, 须要设置 setAccessible(true) 才能够
        name.setAccessible(true);
        name.set(user2,"白衣 2");
        System.out.println(user2);
    }
}

小结：

当咱们程序如果有无参结构时，能够间接应用 newInstance()办法进行创建对象
如果没有无参结构时，须要通过 Class 类的 getDeclaredConstructor(Class … parameterTypes)获得本类的指定形参类型的结构器。向结构器的形参中传递一个对象数组进去，外面蕴含了结构器中所需的各个参数。通过 Constructor 实例化对象。
如果对应的字段为公有属性时，须要应用 setAccessible(true)进行禁止拜访平安开关。

Method 和 Field、Constructor 对象都有 setAccessible()办法。
setAccessible 作用是启动和禁用拜访安全检查的办法。
参数值为 true 则批示反射的对象在应用时应该勾销 Java 语言拜访查看。
- 进步反射的效率。如果代码中必须应用反射，而该句代码须要频繁的被调用，那么请设置为 true。
- 使得本来无法访问的公有成员也能够被拜访。
参数值为 false 则批示反射的对象应该施行 Java 语言拜访查看。

依据一般形式、反射形式、反射形式 + 敞开检测进行性能剖析：

测试代码：

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

// 剖析性能问题
public class Test07 {
    // 一般形式调用
    public static void test01(){User user = new User();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {user.getName();
        }
        long endTime = System.currentTimeMillis();

        System.out.println("一般形式执行 10 亿次:" + (endTime - startTime) + "ms");
    }

    // 反射形式调用
    public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {getName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();

        System.out.println("反射形式执行 10 亿次:" + (endTime - startTime) + "ms");
    }

    // 反射形式调用 敞开检测

    public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {User user = new User();
        Class c1 = user.getClass();

        Method getName = c1.getDeclaredMethod("getName", null);
        getName.setAccessible(true);

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {getName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();

        System.out.println("敞开资源形式执行 10 亿次:" + (endTime - startTime) + "ms");
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {test01();
        test02();
        test03();}
}

测试后果：

一般形式执行 10 亿次:4ms
反射形式执行 10 亿次:2664ms
敞开资源形式执行 10 亿次:1666ms

Java 采纳泛型擦除的机制来引入泛型，Java 中的泛型仅仅是给编译器 javac 应用的，确保数据的安全性和免去强制类型转换问题，然而，一旦编译实现，所有和泛型无关的类型全副擦除
为了通过反射操作这些类型，Java 新增了 ParameterizedType，GenericArrayType，TypeVariable 和 WildcardType 几种类型来代表不能被归一到 Class 类中的类型然而又和原始类型齐名的类型。
ParameterizedType：示意一种参数化类型，比方 Collection<String>
GenericArrayType：示意一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable：是各种类型变量的公关父接口
WildcardType：代表一种通配符类型表达式

测试代码：

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 Test08 {public void test01(Map<String,User> map, List<User> list){System.out.println("test01");
    }

    public Map<String,User> test02(){System.out.println("test02");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {Method method = Test08.class.getMethod("test01", Map.class, List.class);

        Type[] genericParameterTypes = method.getGenericParameterTypes();

        for (Type genericParameterType : genericParameterTypes) {System.out.println("#" + genericParameterType);
            if (genericParameterType instanceof ParameterizedType){Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {System.out.println(actualTypeArgument);
                }
            }
        }

        method = Test08.class.getMethod("test02", null);
        Type genericReturnType = method.getGenericReturnType();

        if (genericReturnType instanceof ParameterizedType){Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {System.out.println(actualTypeArgument);
            }
        }
    }
}

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

// 练习反射操作注解
public class Test09 {public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {Class c1 = Class.forName("cn.edu.zhku.reflection.Student2");

        // 通过反射取得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {System.out.println(annotation); // @cn.edu.zhku.reflection.TableTest(value=db_student)
        }

        // 取得注解的 value 值
        TableTest tableTest = (TableTest) c1.getAnnotation(TableTest.class);
        System.out.println(tableTest.value()); //db_student

        // 取得类指定注解
        Field name = c1.getDeclaredField("name");
        FieldTest annotation = name.getAnnotation(FieldTest.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
        /**
         * 输入后果
         * db_name
         * String
         * 3
         */
    }
}

@TableTest("db_student")
class Student2{@FieldTest(columnName = "db_id",type = "int",length = 10)
    private int id;
    @FieldTest(columnName = "db_age",type = "int",length = 10)
    private int age;
    @FieldTest(columnName = "db_name",type = "String",length = 3)
    private String name;

    public Student2() {}

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

// 类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableTest{String value();
}

// 属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldTest{String columnName();
    String type();
    int length();}

小结：

如果想要取得类的注解，那么就是通过类的反射进行获取
获取类对应注解的值，须要通过 Class.getAnnotation(“注解名称”).value 进行获取
如果想要获取类指定属性的注解，须要先通过Class.getDeclaredField(属性名).getAnnotation(字段对应的注解名)。

如果对您有帮忙，请别忘了给我点个赞！

关于java:框架的底层知识反射

2、反射机制

1、动态 VS 动静语言

2、Java Reflection

3、失去 Class 的几种形式

4、类加载内存剖析

5、剖析类初始化

6、类加载器的作用

7、取得类的运行时构造

8、动静创建对象执行办法

setAccessible

9、性能比照剖析

10、反射操作泛型

11、反射操作注解

Just My Socks（注册教程内含优惠码）

关于java:框架的底层知识反射

2、反射机制

1、动态 VS 动静语言

2、Java Reflection

3、失去 Class 的几种形式

4、类加载内存剖析

5、剖析类初始化

6、类加载器的作用

7、取得类的运行时构造

8、动静创建对象执行办法

setAccessible

9、性能比照剖析

10、反射操作泛型

11、反射操作注解

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）