Java反射笔记

记录一下学习Java反射过程中的需要记下来的部分

什么是反射？

反射是框架设计的灵魂

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

简单比较：曾经是在编译时就知道具体的类和方法等，通过使用反射，程序在编译时不知道具体是什么类，通过在运行时动态的改变具体的类的实例来完成相应的调用。

反射提供的功能：

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
在运行时获取泛型信息
在运行时处理注解
生成动态代理
……

要想解剖一个类,必须先要获取到该类的字节码文件对象Class。

注意：是Class而不是class

而反射使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。

反射的优点和缺点

优点：

可以实现动态创建对象和编译，体现出很大的灵活性

缺点：

对性能有影响。使用反射基本上是一种解释操作，我们可以告诉Jvm，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作

反射相关的主要API

java.lang.Class：代表一个类
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Constructor：代表类的构造器

反射的使用场景

Java编码时知道类和对象的具体信息，此时直接对类和对象进行操作即可，无需反射
如果编码时不知道类或者对象的具体信息，此时应该使用反射来实现。
比如类的名称放在配置文件中，属性和属性值放在配置文件中，需要在运行时读取配置文件，动态获取类的信息。

配置文件常见的比如.properties、.xml等

在编译时根本无法知道该对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息。从编译时转变为运行时。

这也是Java这个静态语言可称为准动态语言的关键。

Class类：代表一个类，是Java反射机制的起源和入口

用于获取与类相关的各种信息，提供了获取类信息的相关方法
Class类继承自Object类

Object类是所有类的共同的父类
Class类是所有类的共同的图纸

每个类有自己的对象，同时每个类也看做是一个对象，有共同的图纸Class,存放类的结构信息，能够通过相应方法取出相应的信息：类的名字、属性、方法、构造方法、父类和接口。Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有N多的实例每个类都有该Class对象。（包括基本数据类型）
Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

一个类在内存中只有一个Class对象，在被加载后，类的整个结构会封装在Class对象中。

正常是通过类来获取一个对象，而反射可以通过对象来获取这个类。对于每个类，JRE都为其保留一个不变的Class对象。

Class类有以下属性

Class本身也是一个类
Class对象只能由系统建立对象
一个加载的类在JVM中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个.class文件
每个类的实例都会记得自己是由哪个Class实例所生成
通过Class可以完整的得到一个类中的所有的被加载的结构
Class是Reflection的根源，针对任何你想动态加载、运行的类，唯有鲜活的相应的Class对象

Class类的常用方法

方法名	说明
static ClassforName(String name)	返回指定类名name的Class对象
Object newInstance()	调用缺省构造器，返回Class对象的一个实例
getName()	返回此Class对象所表示的实体（类、接口、数组类或vodi）的名称
Class getSuperClass()	返回当前Class对象的父类的Class对象
Class[] getinterfaces()	返回当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Constructor[] getConstructor()	返回一个包含某些Constructor对象的数组
Method getMethod(String name, Class.. T)	返回一个Method对象，此对象的形参类型为paramType
Field[] getDeclaredFields()	返回Field对象的一个数组

获取Class对象的方法

已知具体的类，通过类的.class属性获取，

该方法最安全可靠，性能最高

1	Class clazz = Person.class;

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

1	Class clazz = Person.getClass();

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

1	Class clazz = Class.forName("demo.Person");

内置基本数据类型可以直接用类名.TYPE

1	Class clazz = Integer.TYPE;

还可以利用ClassLoader

哪些类可以有Class对象

class：外部类，成员，内部类，匿名内部类
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void

Class c1 = Object.class; //类
Class c2 = Comparable.class; //接口
Class c3 = String[].class;  //数组
Class c4 = int[][].class;  //二维数组
Class c5 = Override.class;  //注解
Class c6 = ElementType.class;  //枚举
Class c7 = Integer.class;  //基本数据类型
Class c8 = void.class;  //无返回类型
Class c9 = Class.class;  //Class

toString的结果

只要类型一样，就是同一个Class对象，尽管不是同一个实例

JAVA内存分析

类的加载过程

什么时候类会发生初始化

new一个类

/**
 * 类的初始化过程
 */
public class Test02 {
    static {
        System.out.println("Main类初始化");
    }

    public static void main(String[] args) {
        // 1.主动引用
        Son son = new Son();
    }
}
class Father {
    static int a = 2;
    static {
        System.out.println("父类初始化");
    }
}
class Son extends Father {
    static final int b = 5;
    static {
        System.out.println("子类初始化");
    }
}

执行结果：

使用反射方法

public static void main(String[] args) throws ClassNotFoundException {
        // 2.反射引用
        Class.forName("reflect.Son");
}

结果相同：

类不会发生初始化的情况（使用子类引用父类的静态成员）

1
2
3

public static void main(String[] args) {
        System.out.println(Son.a);
}

执行结果

定义数组时

1
2
3

public static void main(String[] args) {
        Son[] sons = new Son[5];
}

执行结果

调用常量时

1
2
3

public static void main(String[] args) {
        System.out.println(Son.b);
}

执行结果

总结

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

类加载器

类加载器的作用

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

类加载器的类型

Java 中的类加载器大致可以分成两类，一类是系统提供的，另外一类则是由 Java 应用开发人员编写的。系统提供的类加载器主要有下面三个：

引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码（C/C++）来实现的，并不继承自 java.lang.ClassLoader。
扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。
系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。

除了系统提供的类加载器以外，开发人员可以通过继承 java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求。

public static void main(String[] args) throws ClassNotFoundException {
        //当前类的类加载器
        ClassLoader classLoader = Class.forName("reflect.Test03").getClassLoader();
        System.out.println(classLoader);
        //内置类的类加载器
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);
}

结果：

1 2	jdk.internal.loader.ClassLoaders$AppClassLoader@1f89ab83 null //引导类加载器无法直接获取

获取系统类加载器可以加载的路径：System.getProperty("java.class.path");

双亲委派机制

什么是双亲委派机制

当某个类加载器需要加载某个.class文件时，它首先把这个任务委托给他的上级类加载器，递归这个操作，如果上级的类加载器没有加载，自己才会去加载这个类。

为什么要设计这种机制

这种设计有个好处是，如果有人想替换系统级别的类：String.java。篡改它的实现，在这种机制下这些系统的类已经被Bootstrap classLoader加载过了（为什么？因为当一个类需要加载的时候，最先去尝试加载的就是BootstrapClassLoader），所以其他类加载器并没有机会再去加载，从一定程度上防止了危险代码的植入。

获取运行时类的完整结构

通过反射获取运行时类的完整结构

Field、Method、Constructor、Superclass、Interface、Annotation

实现的全部接口
继承的父类
全部的构造器
全部的方法
全部的成员
注解
。。。

获得类的信息

public static void main(String[] args) throws ClassNotFoundException {
   Class c1 = Class.forName("reflect.User");
    //c1 = new User().getClass();
}

获得类名

//获得全限定类名
System.out.println(c1.getName());
//获得类名
System.out.println(c1.getSimpleName());

获得类的属性

//只能得到public修饰的属性
Field[] fields = c1.getFields();
//得到全部属性
fields = c1.getDeclaredFields();
//获得指定属性
Field name = c1.getDeclaredField("name");

获得类的方法

//获得本类和父类的public方法
Method[] methods = c1.getMethods();
//获得本类的所有方法
methods = c1.getDeclaredMethods();
//获得指定方法
//重载
Method getName = c1.getMethod("getName", null);
Method setName = c1.getMethod("setName", String.class);

获得类的构造器

//获得本类和父类的public构造器
Constructor[] constructors = c1.getConstructors();
//获得本类的所有构造器
constructors = c1.getDeclaredConstructors();
//指定的构造器
Constructor constructor = c1.getDeclaredConstructor(int.class, String.class);

反射创建对象

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
    //获得CLass对象
    Class c1 = Class.forName("reflect.User");
}

通过无参构造器构造对象

1
2
3

//构造对象，通过无参构造
User user = (User) c1.getDeclaredConstructor().newInstance();
//System.out.println(user);

通过有参构造器构造对象

1
2
3

//有参构造
User user1 = (User) c1.getDeclaredConstructor(int.class, String.class).newInstance(1, "对象");
//System.out.println(user1);

调用方法

//通过反射调用方法
Method setName = c1.getDeclaredMethod("setName", String.class);
//invoke(对象,"参数")
setName.invoke(user,"对象");
//System.out.println(user);

直接操作属性

//通过反射操作属性
Field name = c1.getDeclaredField("name");
//操作私有属性需要取消安全检测
name.setAccessible(true);
name.set(user, "对象2");

Tip：关闭类型检查可以提高反射效率，防止重复检查

setAccessible

Method、Field和Constructor对象都有setAccessible方法
setAccessible是启动和禁用访问安全检查的开关
参数值为true则表示反射的对象在使用时取消Java语言访问检查.
- 提高反射的效率。如果代码中必须用反射，而该代码需要频繁的被调用，那么设置为true
- 使原本无法访问的私有成员也可以访问
参数值为false则表示反射的对象实施Java访问检查

反射的执行效率

反射带来了编程的灵活性，但是他的执行效率相比于常规调用要低。（禁用安全检查可以稍微缓解）

所以最好是在必须得用反射的情况下再用反射。

以如下代码为例，通过三种方式调用某个方法10e次

普通方式

public static void test01() {
    User user = new User();
    long startTime = System.currentTimeMillis();
    //10e次
    for (int i = 0; i < 1000000000; i++) {
        user.getName();
    }

    long endTime = System.currentTimeMillis();
    System.out.println("普通执行10e次需要："+(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();
    //10e次
    for (int i = 0; i < 1000000000; i++) {
        getName.invoke(user,null);
    }

    long endTime = System.currentTimeMillis();
    System.out.println("反射执行10e次需要："+(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();
    //10e次
    for (int i = 0; i < 1000000000; i++) {
        getName.invoke(user,null);
    }

    long endTime = System.currentTimeMillis();
    System.out.println("关闭检测后，执行10e次需要："+(endTime-startTime)+"ms");

}

观察结果

可以发现，普通方式的执行效率是最高的，但是不太灵活

通过反射的话则需要3.6s，而关闭安全检查后，效率大大提高了。

反射操作泛型

Java采用类型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器使用的确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
为了通过反射操作这些类型，java新增了 ParameterizedType， GenericArrayType， TypeVariable和 Wildcard Type几种类型来代表不能被归一到 Class类中的类型但是又和原始类型齐名的类型.
ParameterizedType:表示一种参数化类型比如CollectionString
GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable:是各种类型变量的公共父接口
WildcardType:代表一种通配符类型表达式

泛型作为参数

如下，当泛型作为参数时

1
2
3

public void test01(Map<String,User> map, List<User> users) {
    System.out.println("test01");
}

可以使用getGenericParameterTypes()方法来获得泛型参数类型列表，然后通过判断parameterType instanceof ParameterizedType来把parameterType强转为ParameterizedType后通过getActualTypeArguments()方法来获得泛型中指定的具体类型，代码如下

public void test01(Map<String,User> map, List<User> users) {
    System.out.println("test01");
}

public static void main(String[] args) throws NoSuchMethodException {
    Method method = Test07.class.getMethod("test01", Map.class, List.class);
    Type[] parameterTypes = method.getGenericParameterTypes();
    for (Type parameterType : parameterTypes) {
        System.out.println("#"+parameterType);
        if (parameterType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) parameterType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

泛型作为返回值

方法同上，直接放代码和上方观察即可，不懂可以私信或者评论区问

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

public static void main(String[] args) throws NoSuchMethodException {
    Method method = Test07.class.getMethod("test02");
    Type genericReturnType = method.getGenericReturnType();
    if (genericReturnType instanceof ParameterizedType) {
        Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
        for (Type actualTypeArgument : actualTypeArguments) {
            System.out.println(actualTypeArgument);
        }
    }
}

最后的执行结果

反射获取注解信息

先自定义注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
    String value();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Field{
    String columnName();
    String type();
    int length();
}

然后使用注解编写实体类

@Table("db_stu")
@Data
class Student{
    @Field(columnName = "db_id",type = "int",length = 10)
    private int id;
    @Field(columnName = "db_age",type = "int",length = 10)
    private int age;
    @Field(columnName = "db_name",type = "varchar",length = 3)
    private String name;

    public Student() {
    }

    public Student(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
}

在main中获得注解信息

Class c1 = Class.forName("reflect.Student");
//通过反射获得注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
    System.out.println(annotation);
}
//获得注解的value
Table annotation = (Table)c1.getAnnotation(Table.class);
String value = annotation.value();
System.out.println(value);

获取类中的注解

//获得类指定的注解
java.lang.reflect.Field name = c1.getDeclaredField("name");
Field nameAnnotation = name.getAnnotation(Field.class);
System.out.println(nameAnnotation.columnName());
System.out.println(nameAnnotation.length());
System.out.println(nameAnnotation.type());

执行结果

END

本文采用署名-非商业性使用-相同方式共享 4.0 国际许可协议，转载请注明出处。

什么是反射？

反射是框架设计的灵魂

反射提供的功能：

反射的优点和缺点

反射相关的主要API

反射的使用场景

Class类 ：代表一个类，是Java反射机制的起源和入口

获取Class对象的方法

哪些类可以有Class对象

JAVA内存分析

类的加载过程

什么时候类会发生初始化

new一个类

使用反射方法

定义数组时

调用常量时

总结

类加载器

类加载器的作用

类加载器的类型

双亲委派机制

什么是双亲委派机制

为什么要设计这种机制

获取运行时类的完整结构

获得类的信息

获得类名

获得类的属性

获得类的方法

获得类的构造器

反射创建对象

通过无参构造器构造对象

通过有参构造器构造对象

调用方法

直接操作属性

setAccessible

反射的执行效率

普通方式

反射方式

反射方式。关闭检测

反射操作泛型

泛型作为参数

泛型作为返回值

最后的执行结果

反射获取注解信息

END

Class类：代表一个类，是Java反射机制的起源和入口