Mybatis 源码学习(7)-反射工具（ObjectWrapper & MetaObject）

最新推荐文章于 2023-11-24 10:24:45 发布
最新推荐文章于 2023-11-24 10:24:45 发布
阅读量575 收藏 3
点赞数 2
分类专栏： Mybatis 源码学习 文章标签： java mybatis  源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/teaandnoodle/article/details/103020278
版权

历史文章：
Mybatis 源码学习(6)-反射工具（MetaClass）

MetaClass 可以通过反射来解析类级别类型信息，而 ObjectWrapper 是对对象的包装，可以通过字符串操作和查询对象的属性。ObjectWrapper 类继承关系如下，它提供了 BaseWrapper、BeanWrapper、MapWrapper 和 CollectionWrapper。BaseWrapper 提供集合类型解析的抽象方法，BeanWrapper 提供普通 Bean 的 get、set 方法，MapWrapper 提供 Map 类型的 put 和 get 方法，CollectionWrapper 提供集合的 add 和 addAll 方法。
在这里插入图片描述

ObjectWrapper

ObjectWrapper 的接口定义如下：

public interface ObjectWrapper {
  // 获取指定的属性
  // 如果封装的是普通的 Bean  对象，则调用对应的 get 方法
  // 如果封装的是集合对象，则返回对应下标的 value
  // 如果封装的是 Map 对象，则返回 key 对应的 value
  Object get(PropertyTokenizer prop);

  // 设置指定的属性值
  // 如果封装的是普通的 Bean  对象，则调用对应的 set 方法
  // 如果封装的是集合对象，则设置对应下标的 value
  // 如果封装的是 Map 对象，则设置 key 对应的 value
  void set(PropertyTokenizer prop, Object value);

  // 查找属性表达式指定的属性
  // useCamelCaseMapping 表示是否忽略表达式中的下划线
  String findProperty(String name, boolean useCamelCaseMapping);

  // 获取可读属性的名称集合
  String[] getGetterNames();

  // 获取可写属性的名称集合
  String[] getSetterNames();

  // 解析属性表达式指定的属性对应的 set 方法的参数类型
  Class<?> getSetterType(String name);
  // 解析属性表达式指定的属性对应的 get 方法的返回值
  Class<?> getGetterType(String name);

  // 判断属性表达式指定属性是否有 set/get 方法 
  boolean hasSetter(String name);
  boolean hasGetter(String name);

  // 为属性表达式指定的属性创建相应的 MetaObject 对象
  MetaObject instantiatePropertyValue(String name, PropertyTokenizer prop, ObjectFactory objectFactory);
  
  // 判断封装对象是否是集合
  boolean isCollection();
  
  // 向集合中添加元素，调用 Collection.add 方法
  void add(Object element);
  // 向集合中添加一批元素，调用 Collection.addAll 方法
  <E> void addAll(List<E> element);
}

ObjectWrapperFactory 负责创建 ObjectWrapper，系统默认提供了 DefaultObjectWrapperFactory，但是该默认工厂类不提供任何实现，仅抛出异常。在实际使用时，可以通过配置 mybatis-config.xml 在配置中设置自定义的 ObjectWrapperFactory。

BaseWrapper

BaseWrapper 是 ObjectWrapper 的子类（抽象类），它封装了 MetaObject，并且提供三个集合类型的操作方法供子类使用：resolveCollection、getCollectionValue、setCollectionValue。
在这里插入图片描述
BaseWrapper.resolveCollection 方法会调用 MetaObject.getValue 解析属性表达式对应的属性（不过它一般被用来解析集合类型的属性，它能兼容普通 Bean）。
BaseWrapper.getCollectionValue 和 BaseWrapper.setCollectionValue 方法类似，它们能够解析 Map、List、数组，这三种集合类型的对象，并能够根据下标操作对应的集合中的元素。

protected Object getCollectionValue(PropertyTokenizer prop, Object collection) {
  if (collection instanceof Map) { // 集合是 Map 类型，index 是 key
    return ((Map) collection).get(prop.getIndex());
  } else {
    int i = Integer.parseInt(prop.getIndex()); // 其他集合类型，index 是数值下标
    if (collection instanceof List) { // 确认集合的类型
      return ((List) collection).get(i); // 按照下标获取对应下标元素的值
    } else if (collection instanceof Object[]) {
      return ((Object[]) collection)[i];
    } else if (collection instanceof char[]) {
      return ((char[]) collection)[i];
    } else if (collection instanceof boolean[]) {
      return ((boolean[]) collection)[i];
    } else if (collection instanceof byte[]) {
      return ((byte[]) collection)[i];
    } else if (collection instanceof double[]) {
      return ((double[]) collection)[i];
    } else if (collection instanceof float[]) {
      return ((float[]) collection)[i];
    } else if (collection instanceof int[]) {
      return ((int[]) collection)[i];
    } else if (collection instanceof long[]) {
      return ((long[]) collection)[i];
    } else if (collection instanceof short[]) {
      return ((short[]) collection)[i];
    } else {
      throw new ReflectionException(“…”);
    }
  }
}

BeanWrapper

BeanWrapper 继承了 BaseWrapper，它封装了实际的 JavaBean 对象、该对象的 MetaClass、该对象的 MetaObject。除了类级别上的 findProperty、getGetterNames、getSetterNames、getSetterType、getGetterType、hasSetter、hasGetter方法外，BeanWrapper 还包含三个对象级别的操作方法：get、set、instantiatePropertyValue。

BeanWrapper.get、BeanWrapper.set 方法可以用来根据属性表达式获取和设置相应的属性值。

// 获取属性表达式对应的值
public Object get(PropertyTokenizer prop) {
  // 如果存在下标信息，则表示该表达式是集合类型
  if (prop.getIndex() != null) {
    // 通过 MetaObject.getValue 方法获取 object 对象中的指定集合属性；
    // 实际上 MetaObject.getValue 又重新调用了该方法，
    // 由于重新调用时不存在下标，则会直接调用 getBeanProperty 去解析属性
    Object collection = resolveCollection(prop, object);
    // 按照下标获取元素
    return getCollectionValue(prop, collection);
  } else {
    // 不存在索引，直接获取 Bean 属性
    // 直接调用属性的 Invoker.invoke，即可能存在 get 方法或者 Field 本身
    return getBeanProperty(prop, object);
  }
}

private Object getBeanProperty(PropertyTokenizer prop, Object object) {
  try {
    // 根据属性名称，查找 Reflector.getMethods 集合中相应的 GetFieldinvoker 或 Methodinvoker
    Invoker method = metaClass.getGetInvoker(prop.getName());
    try {
      // 通过反射获取属性值
      return method.invoke(object, NO_ARGUMENTS);
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  } catch (RuntimeException e) {
    throw e;
  } catch (Throwable t) {
    throw new ReflectionException(“…”);
  }
}

BeanWrapper.instantiatePropertyValue 可以创建属性表达式指定的属性实例（只能是该对象直接引用的属性），同时创建该实例对应的 MetaObject。

public MetaObject instantiatePropertyValue(String name, PropertyTokenizer prop, ObjectFactory objectFactory) {
  MetaObject metaValue;
  Class<?> type = getSetterType(prop.getName());  // 获取 getter 的返回值类型，即属性的类型
  try {
    Object newObject = objectFactory.create(type); // 构造一个属性的实例
    // 创建该实例的 MetaObject 以便后续通过 MetaObject 操作对象
    metaValue = MetaObject.forObject(newObject, metaObject.getObjectFactory(), metaObject.getObjectWrapperFactory(), metaObject.getReflectorFactory());
    // 将属性实例设置至对象中
    set(prop, newObject);
  } catch (Exception e) {
    throw new ReflectionException(“…”);
  }
  return metaValue;
}

MapWrapper

MapWrapper 是对 Map<String, Object> 的封装，它提供的 get、set 方法都是针对 key 做操作的。

CollectionWrapper

CollectionWrapper 是对 Collection 的封装，它不提供 get、set 方法，但是提供针对集合的 add 和 addAll 方法用于添加元素。

MetaObject

MetaObject 是对 ObjectWrapper 的封装，它提供实际对象的 getValue/setValue 方法，它的内部实现均依赖 ObjectWrapper。MetaObject 包含以下字段：

private final Object originalObject; // 原始 JavaBean 对象
private final ObjectWrapper objectWrapper; // 原始 JavaBean 对象对应的 ObjectWrapper
private final ObjectFactory objectFactory; // 负责实例化 originalObject 的 工厂对象
private final ObjectWrapperFactory objectWrapperFactory; // 负责创建ObjectWrapper的工厂对象
private final ReflectorFactory reflectorFactory; // 用于创建并缓存 Reflector 对象的工厂对象

MetaObject 的初始化需要传入原始对象、对象工厂 ObjectFactory 等，并在构造器内完成 ObjectWrapper 的初始化。

// private 修饰，避免外部创建对象
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)) {
    // 若 ObjectWrapperFactory 能够为该原始对象创建对应的 ObjectWrapper 对象，则优先使用 ObjectWrapperFactory
    // 默认的 DefaultObjectWrapperFactory.hasWrapperFor 返回值是 false 因此不能被使用
    this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
  } else if (object instanceof Map) {
    // 处理 Map 类型
    this.objectWrapper = new MapWrapper(this, (Map) object);
  } else if (object instanceof Collection) {
    // 处理 Collection 类型
    this.objectWrapper = new CollectionWrapper(this, (Collection) object);
  } else {
    // 如果是普通 JavaBean，则创建 BeanWrapper
    this.objectWrapper = new BeanWrapper(this, object);
  }
}

// 静态工厂方法
public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {
  if (object == null) {
    // 若 object 为 null ，则返回 SystemMetaObject .NULL_META_OBJECT 作为 null 对象
    return SystemMetaObject.NULL_META_OBJECT;
  } else {
    return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
  }
}

MetaObject 和 ObjectWrapper 中关于类级别的方法，例如 hasGetter、hasSetter、findProperty 等方法，都是直接调用 MetaClass 的对应方法实现的。而 MetaObject 关于对象的方法，例如 getValue、setValue 都是调用 ObjectWrapper 的方法实现的。

public Object getValue(String name) {
  // 解析属性表达式
  PropertyTokenizer prop = new PropertyTokenizer(name);
  if (prop.hasNext()) { // 处理子表达式
    // 根据解析后的表达式创建 MetaObject
    MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
    if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
      return null;
    } else {
      return metaValue.getValue(prop.getChildren()); // 递归处理子表达式
    }
  } else {
    return objectWrapper.get(prop); // 通过 ObjectWrapper 获取指定的属性（递归出口）
  }
}

public MetaObject metaObjectForProperty(String name) {
  Object value = getValue(name); // 获取指定的属性
  // 创建属性对应的 MetaObject
  return MetaObject.forObject(value, objectFactory, objectWrapperFactory, reflectorFactory);
}

如果存在以下类结构：

public class A {
    List<B> lists;
}

public class B {
    private String name;
}

以 metaObject.getValue("lists[0].name”) 为例，其中 metaObject 是对象 A 的一个实例对应的 MetaObject 对象：

  1. 调用 metaObject.getValue 将属性占位符解析为name = lists，indexName= lists[0]，children = name；
  2. 调用 metaObjectForProperty 处理表达式 lists[0]，通过间接调用 metaObject.getValue -> objectWrapper.get，会实际调用 BeanWrapper.get 方法，解析集合类型对象，之后触发 resolveCollection 和 getCollectionValue 解析集合中的元素；
  3. 得到对象 B 后，继续解析表达式 name，即调用表示 B 对象的 metaValue.getValue(“name”) 的属性值。

MetaObject.setValue 的逻辑和 MetaObject.getValue 的逻辑一致，但是如果需要设置的值不为空，会通过 BeanWrapper.instantiatePropertyValue 创建路径上的空对象（但是如果使用下标指定集合对象，则无法创建对应下标指向的对象）。BeanWrapper.instantiatePropertyValue 内部使用 DefaultObjectFactory.create 方法通过反射创建对象：

public MetaObject instantiatePropertyValue(String name, PropertyTokenizer prop, ObjectFactory objectFactory) {
  MetaObject metaValue;
  // 获取属性 getter 方法的返回值类型
  Class<?> type = getSetterType(prop.getName());
  try {
     // 通过反射创建属性对象
    Object newObject = objectFactory.create(type);
    // 创建对象对应的 MetaObject
    metaValue = MetaObject.forObject(newObject, metaObject.getObjectFactory(), metaObject.getObjectWrapperFactory(), metaObject.getReflectorFactory());
    // 将创建后的对象设置到对应的属性或集合中
    set(prop, newObject);
  } catch (Exception e) {
    throw new ReflectionException(“…”);
  }
  return metaValue;
}

总结

ObjectWrapper 和 MetaObject 都是对对象的封装，ObjectWrapper 是一系列类，它提供对 JavaBean、Map、Collection 实例的操作封装，能够很方便的操作这些类型的属性、元素。MetaObject 是对 ObjectWrapper 的封装，它可以实现对任意类型的对象，通过属性表达式直接操作，而无需明确实例化对象。


参考文档：《Mybatis 技术内幕》

本文的基本脉络参考自《Mybatis 技术内幕》，编写文章的原因是希望能够系统地学习 Mybatis 的源码，但是如果仅阅读源码或者仅从官方文档很难去系统地学习，因此希望参考现成的文档，按照文章的脉络逐步学习。

欢迎关注我的公众号：我的搬砖日记，我会定时分享自己的学习历程。
在这里插入图片描述

凉茶方便面
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
工厂模式 —— mybatis
Xi__Yuan的专栏
09-04 547
源码解析-设计模式
mybatis-3.4.1-all & mybatis-spring-1.3.0
10-27
7. **错误处理和调试**：学习如何识别和解决 MyBatis 在运行时可能出现的问题，如 SQL 执行异常、映射文件配置错误等。 总之，这个压缩包提供了 MyBatis 3.4.1 和 MyBatis-Spring 1.3.0 的完整环境，结合 MySQL 5.7...
MyBatis ObjectWrapper
seasonsbin的专栏
06-03 441
MyBatais ObjectWrapper
mybatis底层组件介绍-ObjectWrapper
lxlneversettle的博客
01-31 809
ObjectWrapper ObjectWrapper的主要作用就是对一个对象进行了包裹，方便通过这个类来对对象进行属性的设置以及读取属性 然后根据被包裹对象的类型，分别使用不同的子类来进行包裹 可以看到，主要有三种类型： BeanWrapper，主要处理Bean的属性读写 MapWrapper，主要处理Map的属性读写 CollectionWrapper，主要处理集合的属性读写 常用的方法如下 public interface ObjectWrapper { Object get(Proper
Mybatis MetaObject和ObjectWrapper设计概念
10-22 262
ObjectWrapper 该类的作用是对象的包装，对对象属性的操作，其行为有 BaseWrapper 具备了MetaObject，对象包装的公共父类，主要处理集合类型 BeanWrapper 具备了储存对象的Object和MetaClass @Override public Object get(PropertyTokenizer prop) { ...
MyBatis之ObjectFactory
weixin_33721344的博客
10-25 2264
关于在MyBatis中的ObjectFactory有什么用，在官方文档中有这样的描述（大多数网上的博客都是直接引用这一描述）：MyBatis 每次创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成。 默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认构造方法，要么在参数映射存在的时候通过参数构造方法来实例化。 如果想覆盖对象工厂的默认行为，则可以通过创建自己...
mybatis-plus源码（mybatis-plus-3.5.1.zip）
03-03
此源码包`mybatis-plus-3.5.1.zip`包含了MyBatis-Plus 3.5.1版本的全部源代码，有助于我们深入理解其内部实现机制和工作原理。 MyBatis-Plus的主要功能包括： 1. **CRUD操作**：MyBatis-Plus提供了简化版的CRUD...
mybatis-plus-boot-starter-3.1.0.jar
最新发布
04-13
mybatis-plus-boot-starter.jar 各个版本下载， ...Mybatis-Plus（简称MP）是一个基于MyBatis的增强工具库，它简化了与数据库的交互操作并提供了一系列增强功能，使开发者能够更加方便快捷地进行数据库访问。
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.zip）
02-07
MyBatis 是一款著名的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使你更好地专注于使用 SQL 来编写业务逻辑，而不需要...
Mybatis源码学习-代码+笔记
07-11
在深入学习Mybatis源码的过程中，我们可以了解到它的工作原理，更好地优化数据库交互，提高程序性能。 1. **Mybatis概述** Mybatis 源码的学习可以帮助开发者理解其内部机制，包括动态SQL的解析、SQL映射文件与...
android object转实体类_MyBatis-Plus返回map自动转驼峰配置object-wrapper-factory
weixin_39531688的博客
11-20 519
## 问题场景：很多时候我们工作中查询很多字段的时候一般是返回一个VO来接收，这个时候我们只要在yml中配置了map-underscore-to-camel-case: true就会自动将查询数据库的字段带下划线的属性转成对应实体类VO中驼峰命名的属性。但是会经常有这种场景：例如我们只查询2个字段要返回给前端，这时候我们还需要新建一个VO，很是麻烦，我们只需要查询返回一个Map来接收就可以了 ,但...
【Mybatis源码分析】Mybatis中的反射（MetaObject）详细讲解
qq_63691275的博客
04-01 2235
文章总结：可以通过MetaObject对象对实例对象属性赋值和获取；ObjectFactory工厂对象可拓展；PropertyTokenizer类用了迭代器设计模式，对属性名进行操作迭代；BeanWrapper依赖MetaClass，MetaClass依赖反射工厂对象和反射对象；Reflector对象是对实例对象构造器、getter、setter方法、属性名等的封装；编写Bean对象的时候，应该遵循Bean规范，使得get后和set后可以和属性名
MyBatis的ObjectWrapperFactory配置
Zn昕的博客
03-13 6881
MyBatis 的 ObjectWrapperFactory 配置 对象加工工厂 MyBatis 提供在构造对象的时候，对于指定的对象进行特殊的加工，其配置方式如下 <objectWrapperFactory type="com.yczuoxin.objectwrapperfactory.MapWrapperFactory"/> ObjectWrapperFactory 接口 pub...
mybatis 中 ObjectWrapperFactory的使用
m0_56362438的博客
11-24 645
对对象进行处理，我们看一下mybatis源码是如何匹配上具体的 ObjectWrapperFactory。下面就是获取到具体的ObjectWrapperFactory源码，其实也很简单根据我们在xml中节点配置就可以读取到注入进来了。ObjectWrapperFactory用于对对象进行包装后处理，在mybatis中用于对结果对象的处理。配置了以后得结果，下划线已经消失了，可以看出objectWrapperFactory配置已经生效了。，下面是我配置的自定义map，key去除下划线的处理。
mybatis+mybatisplus源码学习（十四）objectWrapperFactory
码易的博客
07-10 2035
目录前言一、MybatisMapWrapperFactory二、原理总结 前言 objectWrapperFactory用于对对象进行包装和后处理操作，在mybatis中用于对结果对象的处理。 一、MybatisMapWrapperFactory 用于对Map进行包装，创建包装器MybatisMapWrapper （1）MybatisMapWrapperFactory public class MybatisMapWrapperFactory implements ObjectWrapperFac..
Mybatis源码阅读之十一——反射
D的博客
03-07 792
跟Mybatis学习反射
mybatis（七）对象工厂（objectFactory）插件（plugins）
SuperCrrazy的博客
01-02 619
对象工厂（objectFactory）MyBatis 每次创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成。 默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认构造方法，要么在参数映射存在的时候通过参数构造方法来实例化。 如果想覆盖对象工厂的默认行为，则可以通过创建自己的对象工厂来实现。比如：// ExampleObjectFactory.java pub
Mybatis_review之配置文件中的objectFactory节点内容说明
似水流年
08-05 2863
Mybatis中有一个默认的创建类的对象，名字叫做DefaultObjectFactory，这个类用于负责创建对象实体类。从这个类的外部看，这个类的主要作用就是根据一个类的类型得到该类的一个实体对象，比如，我们给他一个Tiger的type，他将会给我们一个Tiger的实体对象，我们给他一个java.lang.List对象，他将会给我们一个List的实体对象。这个其实从它的名字上就能看出来。 这个
Spring boot + mybatis plus 通过反射实现动态Wrapper
斗战圣佛91的博客
12-26 1782
目的 后台管理系统，存在很多的配置表（单表）的crud操作，查询条件非固定，如果需求变化频率很高的话，每次增加一个字段需要单独增加查询字段，很是麻烦 效果 实现步骤 1、构建查询规则实体类 package com.middol.appserver.core.base; import com.middol.appserver.core.enums.SearchConditionTypeEnum; import lombok.Data; /** * @Description: 查询条件
mybatis-plus-boot-starter和mybatis-plus-generator
03-01
mybatis-plus-boot-starter是MyBatis-Plus框架的一个启动器，它简化了MyBatis-Plus的配置和集成过程。通过引入mybatis-plus-boot-starter依赖，我们可以快速地集成MyBatis-Plus框架，并且可以使用MyBatis-Plus提供的各种增强功能，如自动填充、逻辑删除、乐观锁等。 mybatis-plus-generator是MyBatis-Plus框架提供的代码生成器工具，它可以根据数据库表结构自动生成对应的实体类、Mapper接口、Service接口以及Controller类等。使用mybatis-plus-generator可以大大减少手动编写重复的CRUD代码的工作量，提高开发效率。 通过mybatis-plus-generator，我们只需要配置好数据库连接信息和需要生成代码的表名，然后运行代码生成器，即可自动生成相应的代码文件。生成的代码文件可以根据需要进行修改和扩展，从而快速构建出符合业务需求的基础代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值