Java 反射（一）反射简介、原理和应用场景

目录

• 一、动态语言和动态语言的比较
  • 动态语言
  • 静态语言
• 二、反射
  • 简介
  • 反射的常见使用
    • 1. 代码编辑器
    • 2. Spring等框架的IoC容器
    • 3. 和注解的配合使用
  • 原理
  • 反射优缺点
  • 调试查看
  • Class类
  • 获取Class实例的方式
    • 1. 通过对象获得
    • 2. 通过Class.forname获得
    • 3. 通过类名.class获得
    • 4.基本内置类型的包装类用Type属性获得
    • 5. 一个Class实例通过.getSuperclass()获得父类的Class实例
  • 哪些类型可以有Class对象
  • java内存分析

一、动态语言和动态语言的比较

动态语言

➢ 是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。

➢ 主要动态语言: Object-C、C#、 JavaScript、 PHP、Python等。

一个具体例子：

# test.py
a=1
s = "print(a)"
eval(s)
======运行结果======
1

可以看出，在python这种动态语言中，一个字符串拼接成的代码可以被直接运行，这在c++这些静态语言中是完全无法做到的，因为运行的机器代码在编译完成那一刻就不再改变了。

静态语言

➢ 与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、 C、C++.

➢ Java不是动态语言，但Java可以称之为“准动态语言”.。即Java有一定的动态性,我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

二、反射

简介

Reflection (反射)是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

得到任何类的内部信息可以：

➢ 在运行时判断任意一个对象所属的类

➢ 在运行时构造任意一个类的对象了

➢ 在运行时获取任意一个类所具有的成员变量和方法

➢ 在运行时获取泛型信息

➢ 在运行时调用任意一个对象的成员变量和方法

➢ 在运行时处理注解

➢ 生成动态代理

因此利用反射机制，在运行时我们就能通过一个类名（字符串）来调用一个类的构造函数生成实例对象，甚至可以拼接出类的成员方法使用反射进行相应的调用等等。

反射的常见使用

1. 代码编辑器

反射最常见的使用莫过于我们编写java程序需要依赖的代码编辑器了，这里用IDEA为例，当我们输入‘对象.’时，即会显示出对象的各个成员方法的提示框，如：



代码编辑器正是通过反射机制获取到对象所在类的成员方法，进而以UI的方式展示在用户的面前。

2. Spring等框架的IoC容器

此外使用Spring框架的IoC容器时，若我们使用xml文件设置JavaBean，就会发现它需要我们填入全类名，然后会在运行时在容器中保存该对象，其背后的原理就是Spring框架从xml文件中读取到类名字符串，然后通过反射取到对应的类，进而调用该类中的构造函数新建出实例对象保存起来。

Spring中xml配置的bean：

<bean id="hello" class="pojo.Hello"> <--！填入全类名-->
    <property name="str" value="Spring"/>
</bean>

3. 和注解的配合使用

如前面写的注解文章所说，注解相当于程序的tag，需要一个读取的工具查看tag中的信息，进而进行不同的操作。而这个读取的工具就是反射。

例如在SpringBoot框架中，我们希望生成一个类的实例对象（单例）并将其放置到IoC容器中，只需要在哪个类打上@Component等注解即可，SpringBoot正是通过反射读取到xx类中表明了这个注解才会将其放置到IoC容器中进行管理：

@Service <---
public class EmployeesServiceImpl extends ServiceImpl<EmployeesMapper, Employees> implements EmployeesService {
}

原理

java虚拟机在加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子， 透过这个镜子看到类的结构，所以，我们形象的称之为：反射

反射优缺点

优点:

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

缺点:

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

调试查看

我们先使用IDE进行调试查看一下Class对象的内部信息：

// 使用全类名获取到对应类的Class对象
Class c1 = Class.forName("reflection.User");


可以看到这个对象中确实包含了许多这个类的内部信息。

tips:

1. 一个类在内存中只有一个Class对象
2. 一个类被加载后，类的结构都被封装在Class对象中

Class类

对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

➢Class本身也是一个类

➢Class 对象只能由系统建立对象

➢一个加载的类在JVM中只会有一个Class实例

➢一个Class对象对应的是一个加载到JVM中的一个class文件

➢每个类的实例都会记得自己是由哪个Class实例所生成

➢通过Class可以完整地得到一个类中的所有被加载的结构

➢Class类是Reflection的根源， 针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

获取Class实例的方式

1. 通过对象获得

// 方式一：通过对象获得
Person person = new Student();
Class c1 = person.getClass();

常用的方式是某个方法接收的参数是一个抽象类或接口，然后通过这种方式可以得到输入的参数所在的实现类或子类。

2. 通过Class.forname获得

// 方式二：通过Class.forname获得
Class c2 = Class.forName("reflection.Student");

输入一个全类名，可以获得类（.class文件）对应的Class对象。

3. 通过类名.class获得

// 方式三：通过类名.class获得
Class c3 = Student.class;

4.基本内置类型的包装类用Type属性获得

Class c4 = Integer.TYPE;

5. 一个Class实例通过.getSuperclass()获得父类的Class实例

Class c5 = c1.getSuperclass();

后面还有Class[] getInterfaces()等，这里不再赘述。

哪些类型可以有Class对象

➢class: 外部类，成员(成员内部类，静态内部类), 局部内部类，匿名内部类。

➢interface: 接口

➢[]:数组

➢enum:枚举

➢annotation: 注解@interface

➢primitive type: (基本数据类型）

➢void

测试：

public static void main(String[] args) {
    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;          //void
    Class c9 = Class.class;         //Class
	// 打印...
}

=================运行结果=================
class java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Integer
void

java内存分析

类的加载过程：



➢加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构,

然后生成一个代表这个类的java.lang.Class对象.

➢链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。

• ➢验证：确保加载的类信息符合JVM规范，没有安全方面的问题
• ➢准备：正式为类变量(static) 分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
• ➢解析：虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。

➢初始化:

• ➢执行类构造器< clinit> ()方法的过程。类构造器< clinit> ()方法是由编译期自动收集类中所有类变量的赋值动作和静态
  
  代码块中的语句合并产生的。(类构造 器是构造类信息的，不是构造该类对象的构造器)。
• ➢当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
• ➢虚拟机会保证一个类的< clinit> ()方法在多线程环境中被正确加锁和同步。

测试例：

public class Test05 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
        /*
        1. 加载到内存，会产生一个类对应的Class对象
        2. 链接，链接结束后 m=0（初始值）
        3. 初始化
            <clint>(){
                System.out.println("A类静态代码块初始化");
                m=300;
                m = 100;
            }
            m==100
        */
    }
}
class A{
    static {
        System.out.println("A类静态代码块初始化");
        m=300;
    }
    static int m = 100;
    public A(){
        System.out.println("A类的无参构造初始化");
    }
}
========================运行结果========================
A类静态代码块初始化
A类的无参构造初始化
100

下一部分：Java 反射（二）运行时获取类的信息