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

最新推荐文章于 2024-02-28 09:29:12 发布

武林是大腿

最新推荐文章于 2024-02-28 09:29:12 发布

阅读量377

点赞数

分类专栏： Java基础专栏文章标签： java

原文链接：https://blog.csdn.net/war_233/article/details/119238066?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_utm_term~default-1-119238066-blog-121229695.pc_relevant_default&spm=1001.2101.3001.4242.2&utm_relevant_index=4

版权

Java基础专栏专栏收录该内容

10 篇文章 0 订阅

订阅专栏

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

动态语言

➢ 是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
➢ 主要动态语言: 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: 
 
  
  一个类在内存中只有一个Class对象
一个类被加载后，类的结构都被封装在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

转载自：

https://blog.csdn.net/war_233/article/details/119238066?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_utm_term~default-1-119238066-blog-121229695.pc_relevant_default&spm=1001.2101.3001.4242.2&utm_relevant_index=4