Java反射面试总结(二)

news2024/11/27 16:52:32

为什么引入反射概念?反射机制的应用有哪些?

我们来看一下 Oracle 官方文档中对反射的描述:

从 Oracle 官方文档中可以看出,反射主要应用在以下几方面:

  • 反射让开发人员可以通过外部类的全路径名创建对象,并使用这些类,实现一些扩展的功能。
  • 反射让开发人员可以枚举出类的全部成员,包括构造函数、属性、方法。以帮助开发者写出正确的代码。
  • 测试时可以利用反射 API 访问类的私有成员,以保证测试代码覆盖率。

也就是说,Oracle 希望开发者将反射作为一个工具,用来帮助程序员实现本不可能实现的功能。

引入反射的概念是为了让程序能够在运行时获取类的信息,并且可以动态地创建对象、调用方法、获取字段等操作,具有很高的灵活性和扩展性。

反射机制的应用有以下几个方面:

  1. 动态加载类:在程序运行时可以根据需要动态加载类,而不必提前知道该类的名称,从而实现更加灵活的编程。

  2. 动态创建对象:反射可以在运行时根据类信息动态创建对象,从而实现更加灵活的对象构建,比如通过读取配置文件来创建对象。

  3. 动态调用方法:反射可以在运行时动态地调用任意方法,无论是公共方法还是私有方法,从而实现更加灵活的方法调用。

  4. 动态获取和设置属性:反射可以在运行时动态地获取和设置对象属性的值,从而实现对对象属性的灵活操作。

  5. JavaBean内省:反射可以自动识别JavaBean的属性以及对应的get和set方法,从而快速获取或设置对象的属性值。

总之,反射机制可以很好地增强Java程序的灵活性和可扩展性,但是由于反射操作比较耗时,因此需要谨慎使用。


其中第一点我不是很理解,这里举一个例子:

一个常用的例子是读取配置文件的方式动态加载指定的类。假设我们有一个配置文件,包含了需要加载的类的全路径名,比如:

# 配置文件 classes.properties
com.example.MyClass1=com.example.impl.MyClass1Impl
com.example.MyClass2=com.example.impl.MyClass2Impl

其中,左边的是我们在程序中指定的类名,右边是实际需要加载的类的全路径名。我们可以在程序中读取该配置文件,并使用反射机制加载右边的类。示例代码如下:

Properties props = new Properties();
props.load(new FileInputStream("classes.properties"));
String className = props.getProperty("com.example.MyClass1");

Class<?> clazz = Class.forName(className);
Object instance = clazz.newInstance();
MyClass1 obj = (MyClass1) instance;

在上面的示例代码中,我们读取了配置文件,获取到了需要加载的类名,并使用 Class.forName() 方法加载类。然后,使用 newInstance() 方法创建类的实例,并将其转换成了 MyClass1 类型的对象。这样,我们就成功地动态加载了需要的类,无需在代码中手动指定该类的名称。

这里的根据需要动态加载类,而不必提前知道类名,我一开始是不太理解的,现在想想,应该类似占位符或者形参之类的,只不过这个是把类全路径名卸载了配置文件里(方便更改,有种动态替换的感觉)。大抵如此吧,如果有更好的理解,大家可以在评论区@我。


第一种:JDBC 的数据库的连接

在JDBC 的操作中,如果要想进行数据库的连接,则必须按照以上的几步完成

  1. 通过Class.forName()加载数据库的驱动程序 (通过反射加载,前提是引入相关了Jar包);
  2. 通过 DriverManager 类进行数据库的连接,连接的时候要输入数据库的连接地址、用户名、密码;
  3. 通过Connection 接口接收连接。
public class ConnectionJDBC {  
  
    /** 
     * @param args 
     */  
    //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //连接地址是由各个数据库生产商单独提供的,所以需要单独记住  
    public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
    //连接数据库的用户名  
    public static final String DBUSER = "root";  
    //连接数据库的密码  
    public static final String DBPASS = "root";  
      
      
    public static void main(String[] args) throws Exception {  
        Connection con = null; //表示数据库的连接对象  
        Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序 ,反射机制的体现 
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
        System.out.println(con);  
        con.close(); // 3、关闭数据库  
    }  

第二种:Spring 框架的使用,最经典的就是xml的配置模式。

Spring 通过 XML 配置模式装载 Bean 的过程:

  1. 将程序内所有 XML 或 Properties 配置文件加载入内存中;
  2. Java类里面解析xml或properties里面的内容,得到对应实体类的字节码字符串以及相关的属性信息;
  3. 使用反射机制,根据这个字符串获得某个类的Class实例;
  4. 动态配置实例的属性。

Spring这样做的好处是:

  1. 不用每一次都要在代码里面去new或者做其他的事情;
  2. 以后要改的话直接改配置文件,代码维护起来就很方便了;
  3. 有时为了适应某些需求,Java类里面不一定能直接调用另外的方法,可以通过反射机制来实现。

模拟 Spring 加载 XML 配置文件:

public class BeanFactory {
       private Map<String, Object> beanMap = new HashMap<String, Object>();
       /**
       * bean工厂的初始化.
       * @param xml xml配置文件
       */
       public void init(String xml)  {
              try {
                     //读取指定的配置文件
                     SAXReader reader = new SAXReader();
                     ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
                     //从class目录下获取指定的xml文件
                     InputStream ins = classLoader.getResourceAsStream(xml);
                     Document doc = reader.read(ins);
                     Element root = doc.getRootElement();  
                     Element foo;
                    
                     //遍历bean
                     for (Iterator i = root.elementIterator("bean"); i.hasNext();) {  
                            foo = (Element) i.next();
                            //获取bean的属性id和class
                            Attribute id = foo.attribute("id");  
                            Attribute cls = foo.attribute("class");
                           
                            //利用Java反射机制,通过class的名称获取Class对象
                            Class bean = Class.forName(cls.getText());
                           
                            //获取对应class的信息
                            java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);
                            //获取其属性描述
                            java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
                            //设置值的方法
                            Method mSet = null;
                            //创建一个对象
                            Object obj = bean.newInstance();
                           
                            //遍历该bean的property属性
                            for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {  
                                   Element foo2 = (Element) ite.next();
                                   //获取该property的name属性
                                   Attribute name = foo2.attribute("name");
                                   String value = null;
                                  
                                   //获取该property的子元素value的值
                                   for(Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {
                                          Element node = (Element) ite1.next();
                                          value = node.getText();
                                          break;
                                   }
                                  
                                   for (int k = 0; k < pd.length; k++) {
                                          if (pd[k].getName().equalsIgnoreCase(name.getText())) {
                                                 mSet = pd[k].getWriteMethod();
                                                 //利用Java的反射极致调用对象的某个set方法,并将值设置进去
                                                 mSet.invoke(obj, value);
                                          }
                                   }
                            }
                           
                            //将对象放入beanMap中,其中key为id值,value为对象
                            beanMap.put(id.getText(), obj);
                     }
              } catch (Exception e) {
                     System.out.println(e.toString());
              }
       }
      
       //other codes
}

反射机制的原理是什么?

Class actionClass=Class.forName(MyClass);
Object action=actionClass.newInstance();
Method method = actionClass.getMethod(“myMethod”,null);
//普通成员方法是属于对象的,只有类方法才属于类,所以这里执行方法需要对象参数,以确定是哪一个对象实例的方法
method.invoke(action,null);

上面就是最常见的反射使用的例子,前两行实现了类的装载、链接和初始化(newInstance方法实际上也是使用反射调用了方法),后两行实现了从class对象中获取到method对象然后执行反射调用。

反射原理简要描述如下:

  1. 反射获取类实例 Class.forName(),并没有将实现留给了java,而是交给了jvm去加载!主要是先获取 ClassLoader, 然后调用 native 方法,获取信息,加载类则是回调 java.lang.ClassLoader。最后,jvm又会回调 ClassLoader 进类加载!

  2. newInstance() 主要做了三件事:

    • 权限检测,如果不通过直接抛出异常;
    • 查找无参构造器,并将其缓存起来;
    • 调用具体方法的无参构造方法,生成实例并返回。
  3. 获取Method对象

在这里插入图片描述
上面的Class对象是在加载类时由JVM构造的,JVM为每个类管理一个独一无二的Class对象,这份Class对象里维护着该类的所有Method,Field,Constructor的cache,这份cache也可以被称作根对象。

每次getMethod获取到的Method对象都持有对根对象的引用,因为一些重量级的Method的成员变量(主要是MethodAccessor),我们不希望每次创建Method对象都要重新初始化,于是所有代表同一个方法的Method对象都共享着根对象的MethodAccessor,每一次创建都会调用根对象的copy方法复制一份:

 Method copy() { 

        Method res = new Method(clazz, name, parameterTypes, returnType,

                                exceptionTypes, modifiers, slot, signature,

                                annotations, parameterAnnotations, annotationDefault);

        res.root = this;

        res.methodAccessor = methodAccessor;

        return res;

    }
  1. 调用invoke()方法。调用invoke方法的流程如下:

在这里插入图片描述
调用Method.invoke之后,会直接去调MethodAccessor.invoke。MethodAccessor就是上面提到的所有同名method共享的一个实例,由ReflectionFactory创建。

创建机制采用了一种名为inflation的方式(JDK1.4之后):如果该方法的累计调用次数<=15,会创建出NativeMethodAccessorImpl,它的实现就是直接调用native方法实现反射;如果该方法的累计调用次数>15,会由java代码创建出字节码组装而成的MethodAccessorImpl。(是否采用inflation和15这个数字都可以在jvm参数中调整) 以调用MyClass.myMethod(String s)为例,生成出的MethodAccessorImpl字节码翻译成Java代码大致如下:

public class GeneratedMethodAccessor1 extends MethodAccessorImpl {    
    public Object invoke(Object obj, Object[] args)  throws Exception {
        try {
            MyClass target = (MyClass) obj;
            String arg0 = (String) args[0];
            target.myMethod(arg0);
        } catch (Throwable t) {
            throw new InvocationTargetException(t);
        }
    }
}

解释一下这句话:每次getMethod获取到的Method对象都持有对根对象的引用,因为一些重量级的Method的成员变量(主要是MethodAccessor),我们不希望每次创建Method对象都要重新初始化,于是所有代表同一个方法的Method对象都共享着根对象的MethodAccessor,每一次创建都会调用根对象的copy方法复制一份。

这句话描述的是为什么在Java反射机制中,每次调用getMethod方法都会返回一个新的Method对象,但是这些Method对象共享一个MethodAccessor对象。

在Java反射机制中,每个Method对象包含了一些重要的成员变量,其中一个是MethodAccessor。MethodAccessor通常由JVM自动生成且是比较重量级的对象。因此,为了提高性能,我们不希望每当调用getMethod方法时都重新创建一个MethodAccessor对象。

为了实现MethodAccessor对象的共享,Java反射机制采用了一种策略:每个Method对象都会持有对根对象的引用。这个根对象是在第一次调用getMethod方法时创建的,它包含了所有该类的方法的MethodAccessor对象。

因此,每当我们调用同一个类的不同方法时,虽然返回的Method对象是不同的,但是它们都共享着这个根对象的MethodAccessor对象。这样,当我们通过Method对象调用方法时,就不用每次都重新创建MethodAccessor,从而提高了性能。

注意,每当我们创建一个新的Method对象时,会调用根对象的copy方法,这样就可以复制一个新的MethodAccessor对象。这保证了不同的Method对象之间修改MethodAccessor对象时不会相互影响。

解释一下这句话:注意,每当我们创建一个新的Method对象时,会调用根对象的copy方法,这样就可以复制一个新的MethodAccessor对象。这保证了不同的Method对象之间修改MethodAccessor对象时不会相互影响。

这句话指出,为了确保不同的Method对象之间修改MethodAccessor对象时不会相互影响,每次创建新的Method对象时,都需要调用根对象的copy方法来复制一个新的MethodAccessor对象。

在Java反射机制中,每个Method对象都持有一个对根对象的引用,而根对象包含了所有方法的MethodAccessor对象。当我们通过Method对象调用方法时,实际上是使用MethodAccessor对象来执行方法。因此,如果多个Method对象共享同一个MethodAccessor对象,它们之间可能会相互影响,导致程序出现异常。

为了避免这种情况,Java反射机制在创建新的Method对象时就会复制一个新的MethodAccessor对象。这个过程是通过调用根对象的copy方法实现的,所以每个Method对象都会有一个独立的MethodAccessor对象,不会相互影响。

总之,通过调用根对象的copy方法来复制新的MethodAccessor对象,可以确保不同的Method对象之间修改MethodAccessor对象时不会相互影响,从而保障程序的正确性和稳定性。


本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/428865.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

详解C语言结构体内存对齐:你知道如何快速计算结构体大小吗?

本篇博客会讲解C语言结构体的内存对齐&#xff0c;并且给出一种快速计算结构体大小的方式。主要讲解下面几点&#xff1a; 结构体的内存对齐是什么&#xff1f;如何快速计算结构体的大小&#xff1f;如何利用内存对齐节省结构体占用的内存空间&#xff1f;为什么结构体要内存对…

分布式数据库架构路线大揭秘

文章目录分布式数据库是如何演进的&#xff1f;数据库与分布式中间件有什么区别&#xff1f;如何处理分布式事务&#xff0c;提供外部一致性&#xff1f;如何处理分布式SQL&#xff1f;如何实现分布式一致性&#xff1f;数据库更适合金融政企的未来这些年大家都在谈分布式数据库…

MySQL-中间件mycat(一)

目录 &#x1f341;mycat基础概念 &#x1f341;Mycat安装部署 &#x1f343;初始环境 &#x1f343;测试环境 &#x1f343;下载安装 &#x1f343;修改配置文件 &#x1f343;启动mycat &#x1f343;测试连接 &#x1f990;博客主页&#xff1a;大虾好吃吗的博客 &#x1f9…

边缘网关thingsboard-gateway DTU902

thingsboard-gateway是一个采用python语言编写的开放源代码网关程序&#xff0c;用于将传统或第三方系统的设备与thingsboard平台连接。 支持 采集Modbus slaves、CAN、MQTT 、OPC-UA servers, Sigfox Backend。 除了具备普通 网关外&#xff0c;还具备可配置的边缘能力&…

rabbitmq深入实践

生产者&#xff0c;交换机&#xff0c;队列&#xff0c;消费者 交换机和队列通过 rounting key 绑定者&#xff0c;rounting key 可以是#.,*.这类topic模式&#xff0c; 生产者发送消息内容 rountingkey&#xff0c; 到达交换机后交换机检查与之绑定的队列&#xff0c; 如果能匹…

Yolov5之common.py文件解读

深度学习训练营原文链接前言0.导入需要的包以及基本配置1.基本组件1.1 autopad1.2 ConvDWConv模块1.3TransformerLayer模块1.4 Bottleneck和BottleneckCSPBottleneck模型结构1.5 CrossConv模块1.6 C3模块基于C3的改进1.7SPP1.8Focus模块1.9 Concat模块1.10 Contract和Expand1.1…

好东西!!!多亏几位大牛整理的面试题,让我成功上岸!!

凡事预则立&#xff0c;不预则废。相信很多程序员朋友在跳槽前都会临阵磨枪&#xff0c;在网络上搜集一些面试题进行准备。 然而&#xff0c;当机会来临时&#xff0c;却发现这些面试题往往“不快也不光”.... 由于Java面试涉及的范围很广&#xff0c;很杂&#xff0c;而且技…

使用MyBatis实现简单查询

文章目录一&#xff0c;创建数据库与表&#xff08;一&#xff09;在Navicat里创建MySQL数据库testdb&#xff08;二&#xff09;创建用户表 - t_user&#xff08;三&#xff09;在用户表里插入3条记录二&#xff0c;案例演示MyBatis基本使用&#xff08;一&#xff09;创建Mav…

解决idea每次打开新的项目都需要重新配置maven

原理&#xff1a;就是通过 idea 来进行全局配置【非当前工程配置】 IDEA 版本&#xff1a;2023.1 如何查看版本信息 &#xff1f; 【主菜单】——【帮助】——【关于】 我在网上查找了许多文章 &#xff0c;我混淆了一点&#xff01;当前工程的设置 & 全局设置 不在一个地方…

马斯克掷重金收购英

人前主义&#xff0c;人后生意。在带领一众科技圈大佬签署了呼吁暂停研发比GPT-4更强AI模型的公开信后不久&#xff0c;马斯克却转头豪掷千金收购了10000块英伟达GPU。 一些网友吐槽&#xff0c;以马老板的格局而言&#xff0c;这次价值过亿的投资绝对不是为了借着AI概念火爆来…

2021年 团体程序设计天梯赛——题解集

Hello各位童学大家好&#xff01;&#x1f60a;&#x1f60a;&#xff0c;茫茫题海你我相遇即是缘分呐&#xff0c;或许日复一日的刷题已经让你感到疲惫甚至厌倦了&#xff0c;但是我们真的真的已经达到了我们自身极限了吗&#xff1f;少一点自我感动&#xff0c;没有结果前别太…

[FREERTOS] 任务的创建、删除、调度与状态

1.什么是任务&#xff1f; 我的理解是&#xff1a;任务像是进程/线程&#xff0c;创建一个任务就会开辟一个空间&#xff0c;每一个任务都是独立的执行相应的动作互不干扰&#xff0c;就比如玩游戏&#xff0c;陪女朋友&#xff0c;任务通常都会有一个while(1)死循环 2.与任务创…

使用cloudflare代理flask启用https服务

原文来自&#xff1a;使用cloudflare代理flask启用https服务 | 夜空中最亮的星 欢迎大家留言讨论 问题1&#xff1a;使用cloudflare的dns回源服务器的时候&#xff0c;出现了http和https不断反复重定向 问题2: flask只能启用http服务&#xff0c;需要启用https 步骤 服务器&…

浅谈[Linux搭建GitLab私有仓库,并内网穿透实现公网访问]

转载自远控源码文章&#xff1a;Linux搭建GitLab私有仓库&#xff0c;并内网穿透实现公网访问 前言 GitLab 是一个用于仓库管理系统的开源项目&#xff0c;使用Git作为代码管理工具&#xff0c;并在此基础上搭建起来的Web服务。 Gitlab是被广泛使用的基于git的开源代码管理平…

报错解决:Python ‘NoneType‘ object is not subscriptable , 获取到的数据为None,需要保留数据

人生苦短&#xff0c;我用python 爬取某DB电影数据的时候&#xff0c; 在获取内容的时候出现 NoneType object is not subscriptablePython 资料报错交流:点击此处跳转文末名片获取 获取数据的部分代码是&#xff1a; writer_avatars (writers_list[wi][avatars][small]) …

Linux0.11 信号(十二)

系列文章目录 Linux 0.11启动过程分析&#xff08;一&#xff09; Linux 0.11 fork 函数&#xff08;二&#xff09; Linux0.11 缺页处理&#xff08;三&#xff09; Linux0.11 根文件系统挂载&#xff08;四&#xff09; Linux0.11 文件打开open函数&#xff08;五&#xff09…

前端webpack项目性能优化——体积压缩和compression-webpack-plugin的使用

前端webpack项目性能优化——体积压缩和compression-webpack-plugin的使用需求优化结果需求 脚手架搭建的项目&#xff0c;会默认开启sourceMap&#xff0c;此时打包下来的包会很大&#xff0c;如图&#xff1a;map文件比所有js文件都大&#xff0c;会导致包整体体积过大&…

NIFI大数据进阶_Json内容转换为Hive支持的文本格式_操作方法说明_01_EvaluteJsonPath处理器---大数据之Nifi工作笔记0031

然后我们再来看一下如何把json内容,转换成hive支持的文本格式,其实还是一个格式转换对吧 首先看一下用到的处理器,可以看到这里我们用到了evaluateJsonPath处理器,这个处理器用来提取json中的熟悉,然后ReplaceText处理器用来替换掉FlowFile中的属性的内容 首先看一下这个Evalua…

【Python-Conda】Conda操作解读 pip 和 conda 的区别

【Python-Conda】Conda操作解读 & conda与pip的区别 文章目录【Python-Conda】Conda操作解读 & conda与pip的区别1. 介绍2. conda 操作2.1 创建环境2.2 查看conda已创建的环境2.3 删除环境2.3.1 删除虚拟环境中的包2.4 激活&#xff08;失活&#xff09;环境2.4.1 激活…

OpenAI Embedding:快速实现聊天机器人(三)

theme: orange 本文正在参加「金石计划」 接上文OpenAI Embedding&#xff1a;快速实现聊天机器人(二)有讲到聊天机器人的架构和流程&#xff0c;这篇开始通过代码讲讲具体实现。 前言 这篇文章为了降低实现的难度&#xff0c;下图中提供存储和向量相似度搜索的Redis(Redis Sea…