• 长篇图解java反射机制及其应用场景

    一、什么是java反射？

    在java的面向对象编程过程中，通常我们需要先知道一个Class类，然后 new 类名() 方式来获取该类的对象。也就是说我们需要在写代码的时候（编译期或者编译期之前）就知道我们要实例化哪一个类，运行哪一个方法，这种通常被称为 静态的类加载 。

    但是在有些场景下，我们事先是不知道我们的代码的具体行为的。比如，我们定义一个服务任务工作流，每一个服务任务都是对应的一个类的一个方法。

    • 服务任务B执行哪一个类的哪一个方法，是由服务任务A的执行结果决定的
    • 服务任务C执行哪一个类的哪一个方法，是由服务任务A和B的执行结果决定的
    • 并且用户不希望服务任务的功能在代码中写死，希望通过配置的方式执行不同的程序

    面对这个情况，我们就不能用代码 new 类名() 来实现了，因为你不知道用户具体要怎么做配置，这一秒他希望服务任务A执行Xxxx类的x方法，下一秒他可能希望执行Yyyy类的y方法。当然你也可以说提需求嘛，用户改一次需求，我改一次代码。这种方式也能需求，但对于用户和程序员个人而言都是痛苦，那么有没有一种方法 在运行期动态的改变程序的调用行为的方法 呢？这就是要为大家介绍的“ java反射机制 ”。

    那么java的反射机制能够做那些事呢？大概是这样几种：

    • 在程序运行期动态的根据 package名.类名 实例化类对象

    • 在程序运行期动态获取类对象的信息，包括对象的成本变量和方法

    • 在程序运行期动态使用对象的成员变量属性

    • 在程序运行期动态调用对象的方法（私有方法也可以调用）

    二、Hello World

    我们定义一个类叫做Student

    1. package com.zimug.java.reflection;
    2.  
    3. public class Student {
    4.     public String nickName;
    5.     private Integer age;
    6.  
    7.     public void dinner(){
    8.         System.out.println("吃晚餐！");
    9.     }
    10.  
    11.     private void sleep(int minutes){
    12.         System.out.println("睡" + minutes + "分钟");
    13.     }
    14. }

    如果不用反射的方式，我相信只要学过java的朋友肯定会调用dinner方法

    1. Student student = new Student();
    2. student.dinner();

    如果是反射的方式我们该怎么调用呢？

    1. //获取Student类信息
    2. Class cls = Class.forName("com.zimug.java.reflection.Student");
    3. //对象实例化
    4. Object obj = cls.getDeclaredConstructor().newInstance();
    5. //根据方法名获取并执行方法
    6. Method dinnerMethod = cls.getDeclaredMethod("dinner");
    7. dinnerMethod.invoke(obj);  //打印：吃晚餐！

    通过上面的代码我们看到，com.zimug.java.reflection.Student类名和dinner方法名是字符串。既然是字符串我们就可以通过配置文件，或数据库、或什么其他的灵活配置方法来执行这段程序了。这就是反射最基础的使用方式。

    三、类加载与反射关系

    java的类加载机制还是挺复杂的，我们这里为了不混淆重点，只为大家介绍和“反射”有关系的一部分内容。

    java执行编译的时候将java文件编译成字节码class文件,类加载器在类加载阶段将class文件加载到内存，并实例化一个java.lang.Class的对象。比如：对于Student类在加载阶段

    • 在内存(方法区或叫代码区)中实例化一个Class对象，注意是Class对象不是Student对象
    • 一个Class类（字节码文件）对应一个Class对象
    • 该Class对象保存了Student类的基础信息，比如这个Student类有几个字段（Filed）？有几个构造方法（Constructor）？有几个方法（Method）？有哪些注解（Annotation）？等信息。

    有了上面的关于Student类的基本信息对象（java.lang.Class对象）,在运行期就可以根据这些信息来实例化Student类的对象。

    • 在运行期你可以直接new一个Student对象
    • 也可以使用反射的方法构造一个Student对象

    但是无论你new多少个Student对象，不论你反射构建多少个Student对象，保存Student类信息的java.lang.Class对象都只有一个。下面的代码可以证明。

    1. Class cls = Class.forName("com.zimug.java.reflection.Student");
    2. Class cls2 = new Student().getClass();
    3.  
    4. System.out.println(cls == cls2); //比较Class对象的地址，输出结果是true

    四、操作反射的java类

    了解了上面的这些基础信息，我们就可以更深入学习反射类相关的类和方法了：

    • java.lang.Class: 代表一个类
    • java.lang.reflect.Constructor: 代表类的构造方法
    • java.lang.reflect.Method: 代表类的普通方法
    • java.lang.reflect.Field: 代表类的成员变量
    • Java.lang.reflect.Modifier: 修饰符，方法的修饰符，成员变量的修饰符。
    • java.lang.annotation.Annotation：在类、成员变量、构造方法、普通方法上都可以加注解

    4.1.获取Class对象的三种方法

    1. Class.forName() 方法获取Class对象
    2.  
    3. /**
    4. * Class.forName方法获取Class对象，这也是反射中最常用的获取对象的方法，因为字符串传参增强了配置实现的灵活性
    5. */
    6. Class cls = Class.forName("com.zimug.java.reflection.Student");
    7. 类名.class 获取Class对象
    8.  
    9. /**
    10. * `类名.class`的方式获取Class对象
    11. */
    12. Class clz = User.class;
    13. 类对象.getClass() 方式获取Class对象
    14.  
    15. /**
    16. * `类对象.getClass()`方式获取Class对象
    17. */
    18. User user = new User();
    19. Class clazz = user.getClass();
     

    虽然有三种方法可以获取某个类的Class对象，但是只有第一种可以被称为“反射”。
     

    4.2.获取Class类对象的基本信息
     

    1. Class cls = Class.forName("com.zimug.java.reflection.Student");
    2.  
    3. //获取类的包名+类名
    4. System.out.println(cls.getName());          //com.zimug.java.reflection.Student
    5. //获取类的父类
    6. Class cls = Class.forName("com.zimug.java.reflection.Student");
    7. //这个类型是不是一个注解？
    8. System.out.println(cls.isAnnotation());     //false
    9. //这个类型是不是一个枚举？
    10. System.out.println(cls.isEnum());      //false
    11. //这个类型是不是基础数据类型？
    12. System.out.println(cls.isPrimitive()); //false
     

    Class类对象信息中几乎包括了所有的你想知道的关于这个类型定义的信息，更多的方法就不一一列举了。还可以通过下面的方法
     

    • 获取Class类对象代表的类实现了哪些接口： getInterfaces()
    • 获取Class类对象代表的类使用了哪些注解： getAnnotations()
    

    4.3. 获得Class对象的成员变量
     

    结合上文中的Student类的定义理解下面的代码
     

    1. Class cls = Class.forName("com.zimug.java.reflection.Student");
    2.  
    3. Field[] fields = cls.getFields();
    4. for (Field field : fields) {
    5. System.out.println(field.getName());      //nickName
    6. }
    7.  
    8. fields = cls.getDeclaredFields();
    9. for (Field field : fields) {
    10. System.out.println(field.getName());      //nickName 换行  age
    11. }
     

    • getFields()方法获取类的非私有的成员变量，数组，包含从父类继承的成员变量
    • getDeclaredFields方法获取所有的成员变量，数组，但是不包含从父类继承而来的成员变量
    

    4.4.获取Class对象的方法
     

    • getMethods() : 获取Class对象代表的类的所有的非私有方法，数组， 包含从父类继承而来的方法
    • getDeclaredMethods() : 获取Class对象代表的类定义的所有的方法，数组， 但是不包含从父类继承而来的方法
    • getMethod(methodName): 获取Class对象代表的类的指定方法名的非私有方法
    • getDeclaredMethod(methodName): 获取Class对象代表的类的指定方法名的方法
    

    C
     

    1. lass cls = Class.forName("com.zimug.java.reflection.Student");
    2.  
    3.         Method[] methods = cls.getMethods();
    4.         System.out.println("Student对象的非私有方法");
    5.         for (Method m : methods) {
    6.             System.out.print(m.getName() + ",");
    7.         }
    8.         System.out.println("  end");
    9.  
    10.  
    11.         Method[] allMethods = cls.getDeclaredMethods();
    12.         System.out.println("Student对象的所有方法");
    13.         for (Method m : allMethods) {
    14.             System.out.print(m.getName() + ",");
    15.         }
    16.         System.out.println("  end");
    17.  
    18.  
    19.         Method dinnerMethod = cls.getMethod("dinner");
    20.         System.out.println("dinner方法的参数个数" + dinnerMethod.getParameterCount());
    21.  
    22.         Method sleepMethod = cls.getDeclaredMethod("sleep",int.class);
    23.         System.out.println("sleep方法的参数个数" + sleepMethod.getParameterCount());
    24.         System.out.println("sleep方法的参数对象数组" + Arrays.toString(sleepMethod.getParameters()));
    25.         System.out.println("sleep方法的参数返回值类型" + sleepMethod.getReturnType());
     

    上面代码的执行结果如下：
     

    1. Student对象的非私有方法
    2. dinner,wait,wait,wait,equals,toString,hashCode,getClass,notify,notifyAll,  end
    3.  
    4. Student对象的所有方法
    5. dinner,sleep,  end
    6.  
    7. dinner方法的参数个数0
    8. sleep方法的参数个数1
    9. sleep方法的参数对象数组[int arg0]
    10. sleep方法的参数返回值类型void
     

    可以看到getMethods获取的方法中包含Object父类中定义的方法，但是不包含本类中定义的私有方法sleep。另外我们还可以获取方法的参数及返回值信息：
     

    • 获取参数相关的属性： 
  
      • 获取方法参数个数：getParameterCount()
      • 获取方法参数数组对象：getParameters() ，返回值是java.lang.reflect.Parameter数组
    • 获取返回值相关的属性 
  
      • 获取方法返回值的数据类型：getReturnType()
    

    4.5.方法的调用
     

    实际在上文中已经演示了方法的调用，如下invoke调用dinner方法
     

    1. Method dinnerMethod = cls.getDeclaredMethod("dinner");
    2. dinnerMethod.invoke(obj);  //打印：吃晚餐！
     

    dinner方法是无参的那么有参数的方法怎么调用?看看invoke方法定义，第一个参数是Method对象，无论后面 Object... args 有多少参数就按照方法定义依次传参就可以了。
     

    public Object invoke(Object obj, Object... args)
     

    4.6.创建类的对象(实例化对象)
     

    1. //获取Student类信息
    2. Class cls = Class.forName("com.zimug.java.reflection.Student");
    3. //对象实例化
    4. Student student = (Student)cls.getDeclaredConstructor().newInstance();
    5. //下面的这种方法是已经Deprecated了，不建议使用。但是在比较旧的JDK版本中仍然是唯一的方式。
    6. //Student student = (Student)cls.newInstance();
     

    五、反射的常用场景
     

    • 通过配置信息调用类的方法
    • 结合注解实现特殊功能
    • 按需加载jar包或class
    

    5.1. 通过配置信息调用类的方法
     

    将上文的hello world中的代码封装一下，你知道类名className和方法名methodName是不是就可以调用方法了？至于你将className和 methodName配置到文件，还是nacos，还是数据库，自己决定吧！
     

    1. public void invokeClassMethod(String className,String methodName) throws ClassNotFoundException, 
    2.             NoSuchMethodException, 
    3.             InvocationTargetException, 
    4.             InstantiationException, 
    5.             IllegalAccessException {
    6.         //获取类信息
    7.         Class cls = Class.forName(className);
    8.         //对象实例化
    9.         Object obj = cls.getDeclaredConstructor().newInstance();
    10.         //根据方法名获取并执行方法
    11.         Method dinnerMethod = cls.getDeclaredMethod(methodName);
    12.         dinnerMethod.invoke(obj);
    13. }
     

    5.2.结合注解实现特殊功能
     

    大家如果学习过mybatis plus都应该学习过这样的一个注解TableName，这个注解表示当前的实例类Student对应的数据库中的哪一张表。如下问代码所示，Student所示该类对应的是t_student这张表。
     

    1. @TableName("t_student")
    2. public class Student {
    3.     public String nickName;
    4.     private Integer age;
    5. }
     

    下面我们自定义TableName这个注解
     

    1. @Target(ElementType.TYPE)  //表示TableName可作用于类、接口或enum Class, 或interface
    2. @Retention(RetentionPolicy.RUNTIME) //表示运行时由JVM加载
    3. public @interface TableName {
    4.        String value() ;   //则使用@TableName注解的时候： @TableName(”t_student”);
    5. }
     

    有了这个注解，我们就可以扫描某个路径下的java文件，至于类注解的扫描我们就不用自己开发了，引入下面的maven坐标就可以
     

    2.     org.reflections
    3.     reflections
    4.     0.9.10
     

    看下面代码：先扫描包，从包中获取标注了TableName注解的类，再对该类打印注解value信息
     

    1. // 要扫描的包
    2. String packageName = "com.zimug.java.reflection";
    3. Reflections f = new Reflections(packageName);
    4. // 获取扫描到的标记注解的集合
    5. Set> set = f.getTypesAnnotatedWith(TableName.class);
    6. for (Class c : set) {
    7. // 循环获取标记的注解
    8. TableName annotation = c.getAnnotation(TableName.class);
    9. // 打印注解中的内容
    10. System.out.println(c.getName() + "类，TableName注解value=" + annotation.value());
     

    输出结果是：
     

    com.zimug.java.reflection.Student类，TableName注解value=t_student
     

    有的朋友会问这有什么用？这有大用处了。有了类定义与数据库表的对应关系，你还能通过反射获取类的成员变量，之后你是不是就可以根据表明t_student和字段名nickName，age构建增删改查的SQL了？全都构建完毕，是不是就是一个基础得Mybatis plus了？
     

    反射和注解结合使用，可以演化出许许多多的应用场景，特别是在架构优化方面，等待你去发觉啊！
     

    5.3.按需加载jar包或class
     

    在某些场景下，我们可能不希望JVM的加载器一次性的把所有的jar包装载到JVM虚拟机中，因为这样会影响项目的启动和初始化效率，并且占用较多的内存。我们希望按需加载，需要用到哪些jar，按照程序动态运行的需求取加载这些jar。
     

    1. //按路径加载jar包
    2. File file = new File("D:/com/zimug/commons-lang3.jar");
    3. URL url = file.toURI().toURL();
    4. //创建类加载器
    5. ClassLoader classLoader = new URLClassLoader(new URL[]{url});
    6.  
    7. Class cls = classLoader.loadClass("org.apache.commons.lang3.StringUtils");
     

    同样的把.class文件放在一个路径下，我们也是可以动态加载到的
     

    1. //java的.class文件所在路径
    2. File file = new File("D:/com/zimug");
    3. URL url = file.toURI().toURL();
    4. //创建类加载器
    5. ClassLoader classLoader = new URLClassLoader(new URL[]{url});
    6. //加载指定类，package全路径
    7. Class cls = classLoader.loadClass("com.zimug.java.reflection.Student");
     

    类的动态加载能不能让你想到些什么？是不是可以实现代码修改，不需要重新启动容器？对的，就是这个原理，因为一个类的Class对象只有一个，所以不管你重新加载多少次，都是使用最后一次加载的class对象（上文讲过哦）。
     

    六、反射的优缺点
     

    • 优点：自由，使用灵活，不受类的访问权限限制。可以根据指定类名、方法名来实现方法调用，非常适合实现业务的灵活配置。
    • 缺点： 
  
      • 也正因为反射不受类的访问权限限制，其安全性低，很大部分的java安全问题都是反射导致的。
      • 相对于正常的对象的访问调用，反射因为存在类和方法的实例化过程，性能也相对较低
      • 破坏java类封装性，类的信息隐藏性和边界被破坏
    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
查出来这个表中evaluation_num字段中以2023开头的最大的尾数是几，instr用法                            
    
神经网络训练过程详解,神经网络的训练算法                            
    
神经网络模型复杂度分析                            
    
算法专题1——动态规划 Dynamic Programming，DP                            
    
Java基础知识篇02——Java基本语法                            
    
3Blue1Brown 安装教程                            
    
Linux 安装 Docker +Docker Compose + cucker/get_command_4_run_container                            
    
【linux命令讲解大全】016 .Git：分布式版本控制系统的先驱和常用命令清单(五)                            
    
【C语言进阶（13）】文件操作                            
    
敏捷项目管理完整流程及实践管理方法                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/guanshengg/article/details/126340324
                
    •