mybatis-反射模块
Posted siye1989
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了mybatis-反射模块相关的知识，希望对你有一定的参考价值。
1. 概述
本文，我们来分享 MyBatis 的反射模块，对应 reflection 包。如下图所示：
- 相比
parsing包来说，reflection包的代码量大概是 2-3 倍。当然，不要慌，都是比较简单的代码。 - 当然，这是一篇非常非常非常长的博客，因为笔者基本贴了这个模块所有的代码。如果想要比较好的理解这个模块，胖友一定要基于 MyBatis 提供的这个模块的单元测试，多多调试。
在 《精尽 MyBatis 源码解析 —— 项目结构一览》 中，简单介绍了这个模块如下：
Java 中的反射虽然功能强大，但对大多数开发人员来说，写出高质量的反射代码还是 有一定难度的。MyBatis 中专门提供了反射模块，该模块对 Java 原生的反射进行了良好的封装，提了更加简洁易用的 API，方便上层使调用，并且对反射操作进行了一系列优化，例如缓存了类的元数据，提高了反射操作的性能。
下面，我们就来看看具体的源码。因为 reflection 是基础支持层，所以建议胖友在我们讲解到的类和方法中，打折断点一起来了解。
2. Reflector
org.apache.ibatis.reflection.Reflector ，反射器，每个 Reflector 对应一个类。Reflector 会缓存反射操作需要的类的信息，例如：构造方法、属性名、setting / getting 方法等等。代码如下：
// Reflector.java
|
type属性，每个 Reflector 对应的类。defaultConstructor属性，默认无参构造方法。在<1>处初始化，详细解析，见 「2.1 addDefaultConstructor」 。getMethods、getTypes属性，分别为属性对应的 getting 方法、getting 方法的返回类型的映射。在<2>处初始化，详细解析，见 「2.2 addGetMethods」 。setMethods、setTypes属性，分别为属性对应的 setting 方法、setting 方法的参数类型的映射。在<3>处初始化，详细解析，见 「2.3 addSetMethods」 。<4>处，初始化getMethods+getTypes和setMethods+setTypes，通过遍历 fields 属性。详细解析，见 「2.4 addFields」 。<5>处，初始化readablePropertyNames、writeablePropertyNames、caseInsensitivePropertyMap属性。
2.1 addDefaultConstructor
#addDefaultConstructor(Class<?> clazz) 方法，查找默认无参构造方法。代码如下：
// Reflector.java
|
2.2 addGetMethods
#addGetMethods(Class<?> cls) 方法，初始化 getMethods 和 getTypes ，通过遍历 getting 方法。代码如下：
// Reflector.java
|
<1>处，conflictingGetters变量，属性与其 getting 方法的映射。因为父类和子类都可能定义了相同属性的 getting 方法，所以VALUE会是个数组。<2>处，调用#getClassMethods(Class<?> cls)方法，获得所有方法。详细解析，见 「2.2.1 getClassMethods」 。<3>处，遍历所有方法，挑选符合的 getting 方法，添加到conflictingGetters中。-
<3.1>处，方法参数大于 0 ，说明不是 getting 方法，忽略。 -
<3.2>处，方法名以 get 和 is 方法名开头，说明是 getting 方法。 -
<3.3>处，调用PropertyNamer#methodToProperty(String name)方法，获得属性名。详细解析，见 「6.3 PropertyNamer」 。 -
<3.4>处，调用#addMethodConflict(Map<String, List<Method>> conflictingMethods, String name, Method method)方法，添加到conflictingGetters中。代码如下：// Reflector.java
private void addMethodConflict(Map<String, List<Method>> conflictingMethods, String name, Method method)
List<Method> list = conflictingMethods.computeIfAbsent(name, k -> new ArrayList<>());
list.add(method);- JDK8 编写这样的逻辑，真心方便。
-
<4>处，调用#resolveGetterConflicts(Map<String, List<Method>>)方法，解决 getting 冲突方法。详细解析，见 「2.2.2 resolveGetterConflicts」 。
2.2.1 getClassMethods
#getClassMethods(Class<?> cls) 方法，获得所有方法。代码如下：
// Reflector.java
|
-
代码比较简单，胖友自己看注释。
-
<1>和<2>处，会调用#addUniqueMethods(Map<String, Method> uniqueMethods, Method[] methods)方法，添加方法数组到uniqueMethods中。代码如下：// Reflector.java
private void addUniqueMethods(Map<String, Method> uniqueMethods, Method[] methods)
for (Method currentMethod : methods)
if (!currentMethod.isBridge()) // 忽略 bridge 方法，参见 https://www.zhihu.com/question/54895701/answer/141623158 文章
// <3> 获得方法签名
String signature = getSignature(currentMethod);
// check to see if the method is already known
// if it is known, then an extended class must have
// overridden a method
// 当 uniqueMethods 不存在时，进行添加
if (!uniqueMethods.containsKey(signature))
// 设置方法可访问
if (canControlMemberAccessible())
try
currentMethod.setAccessible(true);
catch (Exception e)
// Ignored. This is only a final precaution, nothing we can do.
// 添加到 uniqueMethods 中
uniqueMethods.put(signature, currentMethod);
-
<3>处，会调用#getSignature(Method method)方法，获得方法签名。代码如下：// Reflector.java
private String getSignature(Method method)
StringBuilder sb = new StringBuilder();
// 返回类型
Class<?> returnType = method.getReturnType();
if (returnType != null)
sb.append(returnType.getName()).append(‘#‘);
// 方法名
sb.append(method.getName());
// 方法参数
Class<?>[] parameters = method.getParameterTypes();
for (int i = 0; i < parameters.length; i++)
if (i == 0)
sb.append(‘:‘);
else
sb.append(‘,‘);
sb.append(parameters[i].getName());
return sb.toString();- 格式：
returnType#方法名:参数名1,参数名2,参数名3。 - 例如：
void#checkPackageAccess:java.lang.ClassLoader,boolean。
- 格式：
-
2.2.2 resolveGetterConflicts
#resolveGetterConflicts(Map<String, List<Method>>) 方法，解决 getting 冲突方法。最终，一个属性，只保留一个对应的方法。代码如下：
// Reflector.java
|
-
总体比较简单，胖友自己瞅瞅。我们只说两个关键点哈。
-
<1>处，基于返回类型比较。重点在<1.1>和<1.2>的情况，因为子类可以修改放大返回值，所以在出现这个情况时，选择子类的该方法。例如，父类的一个方法的返回值为 List ，子类对该方法的返回值可以覆写为 ArrayList 。代码如下：public class A
List<String> getXXXX();
public class B extends A
ArrayList<String> getXXXX(); // 选择它 -
<2>处，调用#addGetMethod(String name, Method method)方法，添加方法到getMethods和getTypes中。代码如下：// Reflector.java
private void addGetMethod(String name, Method method)
// <2.1> 判断是合理的属性名
if (isValidPropertyName(name))
// <2.2> 添加到 getMethods 中
getMethods.put(name, new MethodInvoker(method));
// <2.3> 添加到 getTypes 中
Type returnType = TypeParameterResolver.resolveReturnType(method, type);
getTypes.put(name, typeToClass(returnType));
-
<2.1>处，调用#isValidPropertyName(String name)方法，判断是合理的属性名。代码如下：// Reflector.java
private boolean isValidPropertyName(String name)
return !(name.startsWith("$") || "serialVersionUID".equals(name) || "class".equals(name));- x
-
<2.2>处，添加到getMethods中。此处，我们可以看到一个 MethodInvoker 类，详细解析，见 「4.3 MethodInvoker」 。 -
<2.3>处，添加到getTypes中。-
此处，我们可以看到一个 TypeParameterResolver 类，详细解析，见 「14. TypeParameterResolver」 。
-
#typeToClass(Type src)方法，获得java.lang.reflect.Type对应的类。代码如下：// Reflector.java
private Class<?> typeToClass(Type src)
Class<?> result = null;
// 普通类型，直接使用类
if (src instanceof Class)
result = (Class<?>) src;
// 泛型类型，使用泛型
else if (src instanceof ParameterizedType)
result = (Class<?>) ((ParameterizedType) src).getRawType();
// 泛型数组，获得具体类
else if (src instanceof GenericArrayType)
Type componentType = ((GenericArrayType) src).getGenericComponentType();
if (componentType instanceof Class) // 普通类型
result = Array.newInstance((Class<?>) componentType, 0).getClass();
else
Class<?> componentClass = typeToClass(componentType); // 递归该方法，返回类
result = Array.newInstance(componentClass, 0).getClass();
// 都不符合，使用 Object 类
if (result == null)
result = Object.class;
return result;- 代码比较简单，就是寻找 Type 真正对应的类。
-
-
2.3 addSetMethods
#addSetMethods(Class<?> cls) 方法，初始化 setMethods 和 setTypes ，通过遍历 setting 方法。代码如下：
// Reflector.java
|
- 总体逻辑和
#addGetMethods(Class<?> cls)方法差不多。主要差异点在<1>和<2>处。因为<1>一眼就能明白，所以我们只看<2>，调用#resolveSetterConflicts(Map<String, List<Method>> conflictingSetters)方法，解决 setting 冲突方法。详细解析，见 「2.3.1 resolveSetterConflicts」 中。
2.3.1 resolveSetterConflicts
#resolveSetterConflicts(Map<String, List<Method>> conflictingSetters) 方法，解决 setting 冲突方法。代码如下：
// Reflector.java
|
-
总体比较简单，胖友自己瞅瞅。我们只说两个关键点哈。
-
<1>处，解决冲突 setting 方法的方式，实际和 getting 方法的方式是不太一样的。首先，多的就是考虑了对应的getterType为优先级最高。其次，#pickBetterSetter(Method setter1, Method setter2, String property)方法，选择一个更加匹配的，和 getting 方法是相同的，因为要选择精准的方法。代码如下：// Reflector.java
private Method pickBetterSetter(Method setter1, Method setter2, String property)
if (setter1 == null)
return setter2;
Class<?> paramType1 = setter1.getParameterTypes()[0];
Class<?> paramType2 = setter2.getParameterTypes()[0];
if (paramType1.isAssignableFrom(paramType2))
return setter2;
else if (paramType2.isAssignableFrom(paramType1))
return setter1;
throw new ReflectionException("Ambiguous setters defined for property ‘" + property + "‘ in class ‘"
+ setter2.getDeclaringClass() + "‘ with types ‘" + paramType1.getName() + "‘ and ‘"
+ paramType2.getName() + "‘.");- 胖友在体会体会。感谢【闷油壶】同学指出问题。
-
<2>处，调用#addSetMethod(String name, Method method)方法，添加到setMethods和setTypes中。代码如下：// Reflector.java
private void addSetMethod(String name, Method method)
if (isValidPropertyName(name))
// 添加到 setMethods 中
setMethods.put(name, new MethodInvoker(method));
// 添加到 setTypes 中
Type[] paramTypes = TypeParameterResolver.resolveParamTypes(method, type);
setTypes.put(name, typeToClass(paramTypes[0]));
- 比较简单，和
#addGetMethod(String name, Method method)方法是类似的。
- 比较简单，和
2.4 addFields
#addFields(Class<?> clazz) 方法，初始化 getMethods + getTypes 和 setMethods + setTypes ，通过遍历 fields 属性。实际上，它是 #addGetMethods(...) 和 #addSetMethods(...) 方法的补充，因为有些 field ，不存在对应的 setting 或 getting 方法，所以直接使用对应的 field ，而不是方法。代码如下：
// Reflector.java
|
-
<1>处，若setMethods不存在，则调用#addSetField(Field field)方法，添加到setMethods和setTypes中。代码如下：// Reflector.java
private void addSetField(Field field)
// 判断是合理的属性
if (isValidPropertyName(field.getName()))
// 添加到 setMethods 中
setMethods.put(field.getName(), new SetFieldInvoker(field));
// 添加到 setTypes 中
Type fieldType = TypeParameterResolver.resolveFieldType(field, type);
setTypes.put(field.getName(), typeToClass(fieldType));
- 注意，此处创建的是 SetFieldInvoker 对象。详细解析，见 「4.2 SetFieldInvoker」 。
-
<2>处，若getMethods不存在，则调用#addGetField(Field field)方法，添加到getMethods和getTypes中。代码如下：// Reflector.java
private void addGetField(Field field)
// 判断是合理的属性
if (isValidPropertyName(field.getName()))
// 添加到 getMethods 中
getMethods.put(field.getName(), new GetFieldInvoker(field));
// 添加到 getMethods 中
Type fieldType = TypeParameterResolver.resolveFieldType(field, type);
getTypes.put(field.getName(), typeToClass(fieldType));
- 注意，此处创建的是 GetFieldInvoker 对象。详细解析，，见 「4.1 GetFieldInvoker」 。
2.5 其它方法
Reflector 中，还有其它方法，用于对它的属性进行访问。比较简单，感兴趣的胖友，自己来瞅瞅。例如：
// Reflector.java
|
3. ReflectorFactory
org.apache.ibatis.reflection.ReflectorFactory ，Reflector 工厂接口，用于创建和缓存 Reflector 对象。代码如下：
// ReflectorFactory.java
|
3.1 DefaultReflectorFactory
org.apache.ibatis.reflection.DefaultReflectorFactory ，实现 ReflectorFactory 接口，默认的 ReflectorFactory 实现类。代码如下：
// DefaultReflectorFactory.java
|
- 代码比较简单，胖友一眼就能看懂。
4. Invoker
org.apache.ibatis.reflection.invoker.Invoker ，调用者接口。代码如下：
// Invoker.java
|
- 核心是
#invoke(Object target, Object[] args)方法，执行一次调用。而具体调用什么方法，由子类来实现。
4.1 GetFieldInvoker
org.apache.ibatis.reflection.invoker.GetFieldInvoker ，实现 Invoker 接口，获得 Field 调用者。代码如下：
// GetFieldInvoker.java
|
4.2 SetFieldInvoker
org.apache.ibatis.reflection.invoker.SetFieldInvoker ，实现 Invoker 接口，设置 Field 调用者。代码如下：
// SetFieldInvoker.java
|
4.3 MethodInvoker
org.apache.ibatis.reflection.invoker.MethodInvoker ，实现 Invoker 接口，指定方法的调用器。代码如下：
// MethodInvoker.java
|
5. ObjectFactory
org.apache.ibatis.reflection.factory.ObjectFactory ，Object 工厂接口，用于创建指定类的对象。代码如下：
// ObjectFactory.java
|
- 比较简单，一共有三类方法。
5.1 DefaultObjectFactory
org.apache.ibatis.reflection.factory.DefaultObjectFactory ，实现 ObjectFactory、Serializable 接口，默认 ObjectFactory 实现类。
5.1.1 create
#create(Class<T> type, ...) 方法，创建指定类的对象。代码如下：
// DefaultObjectFactory.java
|
-
<1>处，调用#resolveInterface(Class<?> type)方法，获得需要创建的类。代码如下：// DefaultObjectFactory.java
protected Class<?> resolveInterface(Class<?> type)
Class<?> classToCreate;
if (type == List.class || type == Collection.class || type == Iterable.class)
classToCreate = ArrayList.class;
else if (type == Map.class)
classToCreate = HashMap.class;
else if (type == SortedSet.class) // issue #510 Collections Support
classToCreate = TreeSet.class;
else if (type == Set.class)
classToCreate = HashSet.class;
else
classToCreate = type;
return classToCreate;- 对于我们常用的集合接口，返回对应的实现类。
-
<1>处，调用#instantiateClass(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs)方法，创建指定类的对象。代码如下：// DefaultObjectFactory.java
private <T> T instantiateClass(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs)
try
Constructor<T> constructor;
// <x1> 通过无参构造方法，创建指定类的对象
if (constructorArgTypes == null || constructorArgs == null)
constructor = type.getDeclaredConstructor();
if (!constructor.isAccessible())
constructor.setAccessible(true);
return constructor.newInstance();
// <x2> 使用特定构造方法，创建指定类的对象
constructor = type.getDeclaredConstructor(constructorArgTypes.toArray(new Class[constructorArgTypes.size()]));
if (!constructor.isAccessible())
constructor.setAccessible(true);
return constructor.newInstance(constructorArgs.toArray(new Object[constructorArgs.size()]));
catch (Exception e)
// 拼接 argTypes
StringBuilder argTypes = new StringBuilder();
if (constructorArgTypes != null && !constructorArgTypes.isEmpty())
for (Class<?> argType : constructorArgTypes)
argTypes.append(argType.getSimpleName());
argTypes.append(",");
argTypes.deleteCharAt(argTypes.length() - 1); // remove trailing ,
// 拼接 argValues
StringBuilder argValues = new StringBuilder();
if (constructorArgs != null && !constructorArgs.isEmpty())
for (Object argValue : constructorArgs)
argValues.append(String.valueOf(argValue));
argValues.append(",");
argValues.deleteCharAt(argValues.length() - 1); // remove trailing ,
// 抛出 ReflectionException 异常
throw new ReflectionException("Error instantiating " + type + " with invalid types (" + argTypes + ") or values (" + argValues + "). Cause: " + e, e);
- 代码比较简单，分成
<x1>、<x2>两种情况。
- 代码比较简单，分成
5.1.2 isCollection
#isCollection(Class<T> type) 方法，判断指定类是否为集合类。代码如下：
// DefaultObjectFactory.java
|
- 判断是否为
java.util.Collection的子类。
5.1.3 setProperties
#setProperties(Properties properties) 方法，设置 Properties 。代码如下：
// DefaultObjectFactory.java
|
- 目前是个空实现。所以，暂时可以忽略这个方法。
6. Property 工具类
org.apache.ibatis.reflection.property 包下，提供了 PropertyCopier、PropertyNamer、PropertyTokenizer 三个属性相关的工具类。接下来，我们逐小节来解析。
6.1 PropertyCopier
org.apache.ibatis.reflection.property.PropertyCopier ，属性复制器。代码如下：
// PropertyNamer.java
|
- 比较简单，胖友一眼看懂。
6.2 PropertyNamer
org.apache.ibatis.reflection.property.PropertyNamer ，属性名相关的工具类方法。代码如下：
public final class PropertyNamer
|
- 比较简单，胖友一眼看懂。
6.3 PropertyTokenizer
org.apache.ibatis.reflection.property.PropertyTokenizer ，实现 Iterator 接口，属性分词器，支持迭代器的访问方式。
举个例子，在访问 "order[0].item[0].name" 时，我们希望拆分成 "order[0]"、"item[0]"、"name" 三段，那么就可以通过 PropertyTokenizer 来实现。
6.3.1 构造方法
// PropertyTokenizer.java
|
name属性，当前字符串。children属性，剩余字符串。<1>处，初始化name、children字符串，使用‘.‘作为分隔。indexedName属性，索引的name属性，因为name如果存在index会被更改。<2>处，记录当前name。index属性，编号。分成两种情况：name为数组item[0]时，则index为"0"。name为 Mapmap[key]时，则index为"key"。
<3>处，初始化index，并修改name字符串，使用‘[‘作为分隔符。
6.3.2 next
#next() 方法，迭代获得下一个 PropertyTokenizer 对象。代码如下：
// PropertyTokenizer.java
|
- 酱紫，它又会执行「6.3.1 构造方法」 的流程。
6.3.3 hasNext
#hasNext() 方法，判断是否有下一个元素。代码如下：
// PropertyTokenizer.java
|
6.3.4 其它方法
PropertyTokenizer 中，还有其它方法，比较简单，感兴趣的胖友，自己来瞅瞅。
7. MetaClass
org.apache.ibatis.reflection.MetaClass ，类的元数据，基于 Reflector 和 PropertyTokenizer ，提供对指定类的各种骚操作。
7.1 构造方法
// MetaClass.java
|
- 通过构造方法，我们可以看出，一个 MetaClass 对象，对应一个 Class 对象。
目前有两个方法会涉及到调用该构造方法:
-
①
#forClass(Class<?> type, ReflectorFactory reflectorFactory)静态方法，创建指定类的 MetaClass 对象。代码如下：// MetaClass.java
public static MetaClass forClass(Class<?> type, ReflectorFactory reflectorFactory)
return new MetaClass(type, reflectorFactory); -
②
#metaClassForProperty(String name)方法，创建类的指定属性的类的 MetaClass 对象。代码如下：// MetaClass.java
public MetaClass metaClassForProperty(String name)
// 获得属性的类
Class<?> propType = reflector.getGetterType(name);
// 创建 MetaClass 对象
return MetaClass.forClass(propType, reflectorFactory);
7.2 findProperty
#findProperty(String name, boolean useCamelCaseMapping) 方法，根据表达式，获得属性。代码如下：
// MetaClass.java
|
-
useCamelCaseMapping属性，是否要下划线转驼峰 。但是，在<1>处，我们仅仅看到_被替换成了空串。这是为什么呢？继续往下看。 -
<2>处，调用#findProperty(String name)方法，根据表达式，获得属性。代码如下：// MetaClass.java
public String findProperty(String name)
// <3> 构建属性
StringBuilder prop = buildProperty(name, new StringBuilder());
return prop.length() > 0 ? prop.toString() : null;<3>处，调用#buildProperty(String name, StringBuilder builder)方法，构建属性。代码如下：
// MetaClass.java
|
* 创建 PropertyTokenizer 对象，对 `name` 进行**分词**。当有子表达式，继续递归调用 `#buildProperty(String name, StringBuilder builder)` 方法，并将结果添加到 `builder` 中；否则，结束，直接添加到 `builder` 中。 * 在两个 `<4>` 处，解决“下划线转驼峰”的关键是，通过 `Reflector.caseInsensitivePropertyMap` 属性，忽略大小写。代码如下：
// Reflector.java
|
* x 如果胖友，你有点懵逼，可以运行下 MetaClassTest#shouldFindPropertyName() 这个单元测试方法。
7.3 hasGetter
#hasGetter(String name) 方法，判断指定属性是否有 getting 方法。代码如下：
// MetaClass.java
|
-
思路和
#findProperty((String name, ...)方法是一样的，所以胖友自己看下。 -
<1>处，调用#metaClassForProperty(PropertyTokenizer prop)方法，创建 创建 MetaClass 对象。代码如下：// MetaClass.java
private MetaClass metaClassForProperty(PropertyTokenizer prop)
// 【调用】获得 getting 方法返回的类型
Class<?> propType = getGetterType(prop);
// 创建 MetaClass 对象
return MetaClass.forClass(propType, reflectorFactory);
private Class<?> getGetterType(PropertyTokenizer prop)
// 获得返回类型
Class<?> type = reflector.getGetterType(prop.getName());
// 如果获取数组的某个位置的元素，则获取其泛型。例如说：list[0].field ，那么就会解析 list 是什么类型，这样才好通过该类型，继续获得 field
if (prop.getIndex() != null && Collection.class.isAssignableFrom(type))
// 【调用】获得返回的类型
Type returnType = getGenericGetterType(prop.getName());
// 如果是泛型，进行解析真正的类型
if (returnType instanceof ParameterizedType)
Type[] actualTypeArguments = ((ParameterizedType) returnType).getActualTypeArguments();
if (actualTypeArguments != null && actualTypeArguments.length == 1) // 为什么这里判断大小为 1 呢，因为 Collection 是 Collection<T> ，至多一个。
returnType = actualTypeArguments[0];
if (returnType instanceof Class)
type = (Class<?>) returnType;
else if (returnType instanceof ParameterizedType)
type = (Class<?>) ((ParameterizedType) returnType).getRawType();
return type;
private Type getGenericGetterType(String propertyName)
try
// 获得 Invoker 对象
Invoker invoker = reflector.getGetInvoker(propertyName);
// 如果 MethodInvoker 对象，则说明是 getting 方法，解析方法返回类型
if (invoker instanceof MethodInvoker)
Field _method = MethodInvoker.class.getDeclaredField("method");
_method.setAccessible(true);
Method method = (Method) _method.get(invoker);
return TypeParameterResolver.resolveReturnType(method, reflector.getType());
// 如果 GetFieldInvoker 对象，则说明是 field ，直接访问
else if (invoker instanceof GetFieldInvoker)
Field _field = GetFieldInvoker.class.getDeclaredField("field");
_field.setAccessible(true);
Field field = (Field) _field.get(invoker);
return TypeParameterResolver.resolveFieldType(field, reflector.getType());
catch (NoSuchFieldException | IllegalAccessException ignored)
return null;- 代码比较长，胖友跟着代码注释，运行下。另外，每个上面的方法， 会调用下面的方法，也就说
metaClassForProperty => getGetterType => getGenericGetterType。
- 代码比较长，胖友跟着代码注释，运行下。另外，每个上面的方法， 会调用下面的方法，也就说
另外，#hasSetter(String name) 方法，判断指定属性是否有 setting 方法。逻辑上，和 #hasGetter(String name) 方法类似，胖友可以自己瞅瞅。
7.4 getGetterType
#getGetterType(String name) 方法，获得指定属性的 getting 方法的返回值的类型。代码如下：
// MetaClass.java
|
- 和
#hasGetter(String name)方法类似，胖友可以自己瞅瞅。
另外，#getSetterType(String name) 方法，判断指定属性是否有 setting 方法。逻辑上，和 #getGetterType(String name) 方法类似，胖友可以自己瞅瞅。
7.5 其它方法
MetaClass 还有其它方法，比较简单，是基于 Reflector 方法的封装，感兴趣的胖友，可以自己看看。
8. ObjectWrapper
org.apache.ibatis.reflection.wrapper.ObjectWrapper ，对象包装器接口，基于 MetaClass 工具类，定义对指定对象的各种操作。或者可以说，ObjectWrapper 是 MetaClass 的指定类的具象化。代码如下：
// ObjectWrapper.java
|
- 从接口中，我们可以看到，主要是对 MetaObject 方法的调用。
ObjectWrapper 的子类实现如下图：
8.1 BaseWrapper
org.apache.ibatis.reflection.wrapper.BaseWrapper ，实现 ObjectWrapper 接口，ObjectWrapper 抽象类，为子类 BeanWrapper 和 MapWrapper 提供属性值的获取和设置的公用方法。代码如下：
// BaseWrapper.java |