【Mybatis源码分析】Mybatis中的反射(MetaObject)详细讲解

这篇具有很好参考价值的文章主要介绍了【Mybatis源码分析】Mybatis中的反射(MetaObject)详细讲解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、引入MetaObject

在使用Mybatis,编写DQL语句时,查询结果可能会是多个,多变量指定肯定是不现实的。而Mybatis可以进行映射,将JDBC返回的结果映射到实例类或者Map对象中,方便开发者直接使用返回对象,就可以得到从数据库取出来的结果。

映射原理大伙都知道是利用了反射(因为咱就只是通过resulttype或者resultmap给了返回值类型的全限定类名而已啊,底层不用反射,返回的对象哪来的啊🤞)。在Mybatis中,提供了一个很强大的工具类===》MetaObject,翻译为元对象,它可以使用pojo类中本有的getter,setter方法,即使是嵌套的对象也可以。当然也可以获取一些getter用到的属性名啊,setter用到的属性名,类型啊等等。

当然当我们使用Mybatis框架时,如果需要也可以去用它。

注意:上面说的工具类是因为我觉得它的构造函数是私有的,而且被开发者拿来使用,但是它可以通过其内部的静态方法forObject去得到其对象的。

二、MetaObject 源码分析

在具体分析之前,看看MetaObject中的构造函数和其内部属性(都是final类型的),MetaObject只提供了一个有参构造(私有的),如下:

private final Object originalObject;// 实体对象
private final ObjectWrapper objectWrapper;// 对象的封装,内部是一些属性名什么getset方法的封装
private final ObjectFactory objectFactory;// 对象工厂
private final ObjectWrapperFactory objectWrapperFactory;// 对象封装工厂,可拓展
private final ReflectorFactory reflectorFactory;// 用来构造Reflect对象的反射工厂

private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory,
      ReflectorFactory reflectorFactory) {
      // 属性赋值
    this.originalObject = object;
    this.objectFactory = objectFactory;
    this.objectWrapperFactory = objectWrapperFactory;
    this.reflectorFactory = reflectorFactory;

    if (object instanceof ObjectWrapper) {
      // 判断实例对象是否已经实现过了ObjectWrapper
      this.objectWrapper = (ObjectWrapper) object;
    }
    else if (objectWrapperFactory.hasWrapperFor(object)) {
      // 判断这个对象是不是mybatis内置的CustomCollection,或者是不是继承了Author实体类(这个最后还是用BeanWrapper处理的,感觉没啥用)
      // 当然这些判断是基于传过来的工厂对象的
      this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
    }
    else if (object instanceof Map) {
      // 如果是map及其实现的话,其使用封装为mapwrapper,但map只能是<String,Object>
      this.objectWrapper = new MapWrapper(this, (Map) object);
    }
    else if (object instanceof Collection) {
      // 这封装里面全是抛异常
      this.objectWrapper = new CollectionWrapper(this, (Collection) object);
    }
    else {
      // 其他实力类封装
      // 封装了MetaClass对象
      this.objectWrapper = new BeanWrapper(this, object);
    }
  }

可以看见是通过if-elseif-else去初始化objectWrapper对象的。

ObjectFactory继承结构

【Mybatis源码分析】Mybatis中的反射(MetaObject)详细讲解

Mybatis在核心配置中可以对ObjectFactory进行配置,在setting标签的子标签objectFactory进行配置,如果你觉得可以比源码写的好的话,当然也可以自己写一个对象工厂,去继承ObjectFactory,然后配置上去。(感觉意义不打,如果有用的话记得告诉小编😬)

下面是Mybatis官方文档的案例

【Mybatis源码分析】Mybatis中的反射(MetaObject)详细讲解下面再看看MetaObject提供的getValue和setValue,供外界使用的,用了PropertyTokenizer对象,用了迭代器设计模式。(简单看看不细说,具体实现比较简单,用了MetaClass中的Reflector对象…后面小编会去解析Reflector这个核心类)

  public Object getValue(String name) {
    // 这个属性分词器,就解析你字符串用的,解析成属性名
    // 得到属性名好执行反射对象中封装好的get方法
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (!prop.hasNext()) {
      return objectWrapper.get(prop);
    }
    // 获取对象内置属性
    MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
    if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
      return null;
    } else {
      return metaValue.getValue(prop.getChildren());
    }
  }

  public void setValue(String name, Object value) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
      if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
        if (value == null) {
          // don't instantiate child path if value is null
          return;
        }
        metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);
      }
      metaValue.setValue(prop.getChildren(), value);
    } else {
      objectWrapper.set(prop, value);
    }
  }

1. 使用MetaObject

可以看看具体怎么个使用(不出意外,也用不上)。但感觉如果自己写什么小框架方便开发的,小编觉得它是好工具。

    @Test
    public void testMetaObject(){
        /**
         * user中的属性
         *     private Integer id;
         *     private String username;
         *     private String password;
         *     private List<Integer> list;
         *     private Student stu;
         */
        User user = new User();
        MetaObject metaObject = MetaObject.forObject(user,
                new DefaultObjectFactory(),
                new DefaultObjectWrapperFactory(),
                new DefaultReflectorFactory());
        metaObject.setValue("id",1);
        metaObject.setValue("username","林奕");
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        metaObject.setValue("list",list);
        // collection集合、map集合、数组都是用[索引]的形式
        System.out.println(metaObject.getValue("list[0]"));
        Student stu = new Student();
        stu.setName("美琪");
        metaObject.setValue("stu",stu);
        // 如果内部还有其他实例对象,会创建其MetaObject,再次调用getValue
        // 可以假设理解为递归调用了getValue,但实际不是同一个对象调用的
        System.out.println(metaObject.getValue("stu.name"));
        System.out.println(user);
    }

三、BeanWrapper源码分析

在初始化objectwrapper对象封装对象的时候,要么是实体类封装,要么是map封装,map封装前面做过了判断,用得更多的还是映射到实体类的属性上,而其所做的封装都得归功于BeanWrapper。所以这里对BeanWrapper类进行源码分析。

下面是BeanWrapper继承结构

【Mybatis源码分析】Mybatis中的反射(MetaObject)详细讲解下面是BeanWrapper类中的属性和构造函数(其他方法都是对ObjectWrapper方法的实现)

  private final Object object;// 传过来的实例对象
  private final MetaClass metaClass;// 元字节码对象(内部封装了reflector对象,用于获取所需getter方法,setter方法,或属性等等)

  public BeanWrapper(MetaObject metaObject, Object object) {
    super(metaObject);
    this.object = object;
    // 通过MetaClass中的forClass获取MetaClass对象,和MetaObject对象获取方式一样
    // MetaClass构造方法私有
    this.metaClass = MetaClass.forClass(object.getClass(), metaObject.getReflectorFactory());
  }

下面看看metaClass对象是干啥的,可以看见获取MetaClass对象需要俩参数:

  1. 通过实例对象获取的Class对象
  2. 通过metaObject获取的ReflectorFactory反射工厂对象

1. MetaClass

下面是其属性和构造方法及forClass方法

// 方法很简单,就是去new MetaClass对象
public static MetaClass forClass(Class<?> type, ReflectorFactory reflectorFactory) {
    return new MetaClass(type, reflectorFactory);
  }

  private final ReflectorFactory reflectorFactory;// 反射工厂,用于得到reflector对象的。
  private final Reflector reflector;// 反射对象

  private MetaClass(Class<?> type, ReflectorFactory reflectorFactory) {
    this.reflectorFactory = reflectorFactory;
    // 通过反射工厂去获取reflector对象
    this.reflector = reflectorFactory.findForClass(type);
  }

2. ReflectorFactory

reflectorFactory反射工厂还提供缓存,开始支持高并发的,然后去除了。
【Mybatis源码分析】Mybatis中的反射(MetaObject)详细讲解可以看看其默认实现的反射工厂代码,它是利用ConcurrentHashMap对象,保障了在多线程环境下的安全。当然也提供了缓存的作用,如果对应的type存在就直接给出反射对象,不存在会存入reflectMap,会得到重新new的反射对象。

【Mybatis源码分析】Mybatis中的反射(MetaObject)详细讲解
这个反射工厂也可供外界使用,而且可拓展。

3. Reflector

通过MetaObject setvalue,getvalue方法去操作实体对象是依赖于objectwrapper对象的,objectwrapper利用了多态,调用其中的方法实际是调用BeanWrapper对象中的(拿BeanWrapper举例),而BeanWrapper对象依赖于MetaClass对象,而MetaClass对象依赖于Reflector对象。核心反射实现最后还是到了Reflector类,其余是一层一层的调用。下面对Reflector进行源码分析。

下面是其构造函数及其属性

  private static final MethodHandle isRecordMethodHandle = getIsRecordMethodHandle();
  private final Class<?> type;
  // get方法中用到的属性
  private final String[] readablePropertyNames;
  // set方法中用到的属性
  private final String[] writablePropertyNames;
  // 与get类似的操作
  private final Map<String, Invoker> setMethods = new HashMap<>();
  // 封装get方法,key是get后的名(会将第一个字符转小写),value是方法
  private final Map<String, Invoker> getMethods = new HashMap<>();
  // 与get一样的操作
  private final Map<String, Class<?>> setTypes = new HashMap<>();
  // 封装get方法的返回值,key是get后的名(会将第一个字符转小写),value是返回值类型字节码
  private final Map<String, Class<?>> getTypes = new HashMap<>();
  private Constructor<?> defaultConstructor;

  // 这个是把getter、setter 方法中用到的属性名进行大写转换然后封装起来
  // key是大写转换后的,value是属性名
  private final Map<String, String> caseInsensitivePropertyMap = new HashMap<>();

  public Reflector(Class<?> clazz) {
    type = clazz;
    // 这里是获取无参构造
    addDefaultConstructor(clazz);
    Method[] classMethods = getClassMethods(clazz);
    if (isRecord(type)) {
      addRecordGetMethods(classMethods);
    } else {
      addGetMethods(classMethods);// get方法封装
      addSetMethods(classMethods);// set方法的封装
      addFields(clazz);
    }
    readablePropertyNames = getMethods.keySet().toArray(new String[0]);
    writablePropertyNames = setMethods.keySet().toArray(new String[0]);
    for (String propName : readablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
    for (String propName : writablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
  }

下面拿get方法封装举例。(再往下就是反射操作了)

  private void addGetMethods(Method[] methods) {
    // 因为存在getXX,isXX吧,所以用List作为value
    Map<String, List<Method>> conflictingGetters = new HashMap<>();
    // 这里filter需要有返回值的,需要满足getter条件的,就是以get或is开头的方法
    Arrays.stream(methods).filter(m -> m.getParameterTypes().length == 0 && PropertyNamer.isGetter(m.getName()))
      // 获取属性名(get后面的,is后面的,首字符转小写)
      // 还得不能冲突,及首字符不让用$,还有属性名不能是class......
        .forEach(m -> addMethodConflict(conflictingGetters, PropertyNamer.methodToProperty(m.getName()), m));
    // 解析这个conflictingGetters
    // 将满足条件的存入到getMethods,getTypes中
    resolveGetterConflicts(conflictingGetters);
  }

四、总结

  • 可以通过MetaObject对象对实例对象属性赋值和获取;

  • ObjectFactory工厂对象可拓展;

  • PropertyTokenizer类用了迭代器设计模式,对属性名进行操作迭代;

  • BeanWrapper依赖MetaClass,MetaClass依赖反射工厂对象和反射对象;

  • Reflector对象是对实例对象构造器、getter、setter方法、属性名等的封装;

  • 编写Bean对象的时候,应该遵循Bean规范,使得get后和set后可以和属性名对应上,从而好进行操作。本质是不管你属性名对不对应的上,反正get后和set后的名得和数据库列名对应上。文章来源地址https://www.toymoban.com/news/detail-400337.html

到了这里,关于【Mybatis源码分析】Mybatis中的反射(MetaObject)详细讲解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Reflection java反射源码分析

    Java的反射(reflection)机制是指在程序的运行状态中,可以构造任意一个类的对象,可以了解任意一个对象所属的类,可以了解任意一个类的成员变量和方法,可以调用任意一个对象的属性和方法。这种 动态获取程序信息 以及 动态调用对象的功能 称为Java语言的反射机制。反

    2024年02月02日
    浏览(45)
  • Java注解源码分析,实现自定义注解通过反射获取

    JDK5.0 引入,可以通过反射机制动态获取,大量应用于java框架中 内置注解 @Override 重写父类方法时 @Deprecated 使用它存在风险,可能导致错误 可能在未来版本中不兼容 可能在未来版本中删除 一个更好和更高效的方案已经取代它 @SuppressWarnings 告诉编译器忽略指定的警告,不用在

    2024年02月03日
    浏览(43)
  • Java反射机制,动态代理,hook以及在Retrofit源码中的应用

    1.反射的基础知识: Java的反射机制是指在程序的运行状态中,可以构造任意一个类的对象,可以了解任意一个对象所属的类,可以了解任意一个类的成员变量和方法,可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机

    2024年02月13日
    浏览(44)
  • 【JaveWeb教程】(27)Mybatis的XML配置文件与Mybatis动态SQL 详细代码示例讲解

    Mybatis的开发有两种方式: 注解 XML 使用Mybatis的注解方式,主要是来完成一些简单的增删改查功能。如果需要实现复杂的SQL功能,建议使用XML来配置映射语句,也就是将SQL语句写在XML配置文件中。 在Mybatis中使用XML映射文件方式开发,需要符合一定的规范: XML映射文件的名称

    2024年02月01日
    浏览(46)
  • mybatis源码学习之mybatis执行流程分析

    mybatis全局配置文件中涉及的标签如下图所示 下面我们来进行源码分析。 配置文件的解析创建SqlSessionFactory 配置文件的解析主要涉及到的类如下:XMLConfigBuilder、XPathParser、XPath、XNode,其中XPath、XNode是对 1、build方法内部首先会根据输入流等信息创建XMLConfigBuilder类的实例对象,

    2024年02月07日
    浏览(49)
  • 【JaveWeb教程】(26) Mybatis基础操作(新增、修改、查询、删除) 详细代码示例讲解(最全面)

    学习完mybatis入门后,我们继续学习mybatis基础操作。 需求说明: 根据资料中提供的《tlias智能学习辅助系统》页面原型及需求,完成员工管理的需求开发。 通过分析以上的页面原型和需求,我们确定了功能列表: 查询 根据主键ID查询 条件查询 新增 更新 删除 根据主键ID删除

    2024年01月17日
    浏览(52)
  • MyBatis底层源码分析

    🎄欢迎来到@边境矢梦°的csdn博文🎄 🎄本文主要梳理MyBatis底层源码分析 🎄 🌈我是边境矢梦°,一个正在为秋招和算法竞赛做准备的学生🌈 🎆喜欢的朋友可以关注一下 🫰🫰🫰 ,下次更新不迷路🎆 Ps: 月亮越亮说明知识点越重要 (重要性或者难度越大)🌑🌒🌓🌔🌕 

    2024年02月08日
    浏览(49)
  • MyBatis 源码分析(五):异常模块

    上一篇我们解了Mybatis解析器模块,本篇我们来了解反射模块。本文,我们来分享 MyBatis 的异常模块。 对应  exceptions  包,如下图所示: 在 MyBatis源码分析(二):项目结构 中,简单介绍了这个模块: 定义了 MyBatis 专有的 PersistenceException 和 TooManyResultsException 异常。 实际上

    2024年02月01日
    浏览(44)
  • MyBatis源码分析_ResultSetHandler(7)

    目录 1. 传统JDBC 2. Mybatis访问数据库 2.1  Statement访问数据库 2.2  火枪手 ResultSetHandler 出现 3. ResultSetHandler处理结果集 3.1 首先就是进入 handleResultSets 方法 3.2 handleResultSet 方法根据映射规则(resultMap)对结果集进行转化 3.3 handleRowValuesForSimpleResultMap 方法对行进行映射处理 4.  

    2024年02月15日
    浏览(46)
  • Mybatis源码分析_日志模块 (1)

    不得不承认,学习MyBatis的时间成本要比学习Spring低很多,Mybatis是我所了解过的代码量最小、整体架构最简单,但是又是最具有学习价值的一个框架。如果,你想快速的阅读一个框架的源码,并且掌握这个框架的精髓,那么Mybatis一定是你的首选。 在开始我们的源码阅读之前,

    2024年02月10日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包