MetaObject 提供了对象的属性值的获取与设置等方法，是对BaseWrapper操作的进一步增强

public class MetaObject {//原始的java对象private final Object originalObject;//对对象的包装，抽象了对象的属性信息，他定义了一系列查询对象属性信息的方法，以及更新属性的方法；private final ObjectWrapper objectWrapper;private final ObjectFactory objectFactory;private final ObjectWrapperFactory objectWrapperFactory;private final ReflectorFactory reflectorFactory;private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {this.originalObject = object;this.objectFactory = objectFactory;this.objectWrapperFactory = objectWrapperFactory;this.reflectorFactory = reflectorFactory;
//会根据object类型的不同创造相应的ObjectWrapper对象if (object instanceof ObjectWrapper) {this.objectWrapper = (ObjectWrapper) object;} else if (objectWrapperFactory.hasWrapperFor(object)) {this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);} else if (object instanceof Map) {this.objectWrapper = new MapWrapper(this, (Map) object);} else if (object instanceof Collection) {this.objectWrapper = new CollectionWrapper(this, (Collection) object);} else {this.objectWrapper = new BeanWrapper(this, object);}}
//静态方法，创造MetaObject对象public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) {if (object == null) {return SystemMetaObject.NULL_META_OBJECT;} else {return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory);}}public ObjectFactory getObjectFactory() {return objectFactory;}public ObjectWrapperFactory getObjectWrapperFactory() {return objectWrapperFactory;}public ReflectorFactory getReflectorFactory() {return reflectorFactory;}public Object getOriginalObject() {return originalObject;}public String findProperty(String propName, boolean useCamelCaseMapping) {return objectWrapper.findProperty(propName, useCamelCaseMapping);}public String[] getGetterNames() {return objectWrapper.getGetterNames();}public String[] getSetterNames() {return objectWrapper.getSetterNames();}public Class<?> getSetterType(String name) {return objectWrapper.getSetterType(name);}public Class<?> getGetterType(String name) {return objectWrapper.getGetterType(name);}public boolean hasSetter(String name) {return objectWrapper.hasSetter(name);}public boolean hasGetter(String name) {return objectWrapper.hasGetter(name);}
//获得指定属性的值public Object getValue(String name) {PropertyTokenizer prop = new PropertyTokenizer(name);if (prop.hasNext()) {MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());if (metaValue == SystemMetaObject.NULL_META_OBJECT) {return null;} else {return metaValue.getValue(prop.getChildren());}} else {return objectWrapper.get(prop);}}
//设置对应属性的值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 && prop.getChildren() != null) {// don't instantiate child path if value is nullreturn;} else {metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);}}metaValue.setValue(prop.getChildren(), value);} else {objectWrapper.set(prop, value);}}
//创建指定属性的MetaObject对象public MetaObject metaObjectForProperty(String name) {Object value = getValue(name);return MetaObject.forObject(value, objectFactory, objectWrapperFactory, reflectorFactory);}public ObjectWrapper getObjectWrapper() {return objectWrapper;}public boolean isCollection() {return objectWrapper.isCollection();}public void add(Object element) {objectWrapper.add(element);}public <E> void addAll(List<E> list) {objectWrapper.addAll(list);}}

SystemMetaObject 系统级的MetaObject对象，主要提供了 ObjectFactory、ObjectWrapperFactory、空 MetaObject 的单例

public final class SystemMetaObject {public static final ObjectFactory DEFAULT_OBJECT_FACTORY = new DefaultObjectFactory();public static final ObjectWrapperFactory DEFAULT_OBJECT_WRAPPER_FACTORY = new DefaultObjectWrapperFactory();public static final MetaObject NULL_META_OBJECT = MetaObject.forObject(NullObject.class, DEFAULT_OBJECT_FACTORY, DEFAULT_OBJECT_WRAPPER_FACTORY, new DefaultReflectorFactory());private SystemMetaObject() {// Prevent Instantiation of Static Class}private static class NullObject {}
//创建指定对象的MetaObject对象public static MetaObject forObject(Object object) {return MetaObject.forObject(object, DEFAULT_OBJECT_FACTORY, DEFAULT_OBJECT_WRAPPER_FACTORY, new DefaultReflectorFactory());}}

ParamNameUtil 参数名工具类，获得构造方法和普通方法的参数列表

public class ParamNameUtil {public static List<String> getParamNames(Method method) {return getParameterNames(method);}public static List<String> getParamNames(Constructor<?> constructor) {return getParameterNames(constructor);}private static List<String> getParameterNames(Executable executable) {final List<String> names = new ArrayList<>();final Parameter[] params = executable.getParameters();//获得参数名，并添加到names中for (Parameter param : params) {names.add(param.getName());}return names;}private ParamNameUtil() {super();}
}

ParamNameResolver 参数名解析器

public class ParamNameResolver {private static final String GENERIC_NAME_PREFIX = "param";//参数名映射，参数顺序：参数名private final SortedMap<Integer, String> names;
//是否有注解的参数private boolean hasParamAnnotation;public ParamNameResolver(Configuration config, Method method) {//得到参数的类型数组final Class<?>[] paramTypes = method.getParameterTypes();//得到参数的注解数组final Annotation[][] paramAnnotations = method.getParameterAnnotations();final SortedMap<Integer, String> map = new TreeMap<>();int paramCount = paramAnnotations.length;// get names from @Param annotationsfor (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {//如果是特殊参数就忽略if (isSpecialParameter(paramTypes[paramIndex])) {// skip special parameterscontinue;}String name = null;for (Annotation annotation : paramAnnotations[paramIndex]) {if (annotation instanceof Param) {hasParamAnnotation = true;name = ((Param) annotation).value();break;}}if (name == null) {// @Param was not specified.//获取真实的参数名if (config.isUseActualParamName()) {name = getActualParamName(method, paramIndex);}if (name == null) {// use the parameter index as the name ("0", "1", ...)// gcode issue #71//实在没有就用map的顺序name = String.valueOf(map.size());}}map.put(paramIndex, name);}names = Collections.unmodifiableSortedMap(map);}
//得到真实参数名称private String getActualParamName(Method method, int paramIndex) {if (Jdk.parameterExists) {return ParamNameUtil.getParamNames(method).get(paramIndex);}return null;}
//如果是RowBounds以及ResultHandler的子类则为特殊参数private static boolean isSpecialParameter(Class<?> clazz) {return RowBounds.class.isAssignableFrom(clazz) || ResultHandler.class.isAssignableFrom(clazz);}public String[] getNames() {return names.values().toArray(new String[0]);}//获得参数名与值的映射public Object getNamedParams(Object[] args) {final int paramCount = names.size();if (args == null || paramCount == 0) {return null;} else if (!hasParamAnnotation && paramCount == 1) {return args[names.firstKey()];} else {// 组合 1 ：KEY：参数名，VALUE：参数值// 组合 2 ：KEY：GENERIC_NAME_PREFIX + 参数顺序，VALUE ：参数值final Map<String, Object> param = new ParamMap<>();int i = 0;for (Map.Entry<Integer, String> entry : names.entrySet()) {param.put(entry.getValue(), args[entry.getKey()]);// add generic param names (param1, param2, ...)final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);// ensure not to overwrite parameter named with @Paramif (!names.containsValue(genericParamName)) {param.put(genericParamName, args[entry.getKey()]);}i++;}return param;}}
}

TypeParameterResolver 关于Type类型的解析器，主要关于泛型

public class TypeParameterResolver {/*** @return The field type as {@link Type}. If it has type parameters in the declaration,<br>*         they will be resolved to the actual runtime {@link Type}s.*///解析Field类型public static Type resolveFieldType(Field field, Type srcType) {//属性定义Type fieldType = field.getGenericType();//属性定义的类Class<?> declaringClass = field.getDeclaringClass();//解析类型return resolveType(fieldType, srcType, declaringClass);}//解析方法返回类型  public static Type resolveReturnType(Method method, Type srcType) {//返回属性类型Type returnType = method.getGenericReturnType();//返回属性类Class<?> declaringClass = method.getDeclaringClass();//解析类型return resolveType(returnType, srcType, declaringClass);}
//解析方法参数的类型数组public static Type[] resolveParamTypes(Method method, Type srcType) {Type[] paramTypes = method.getGenericParameterTypes();Class<?> declaringClass = method.getDeclaringClass();Type[] result = new Type[paramTypes.length];for (int i = 0; i < paramTypes.length; i++) {//逐个解析类型result[i] = resolveType(paramTypes[i], srcType, declaringClass);}return result;}
//解析Type类型private static Type resolveType(Type type, Type srcType, Class<?> declaringClass) {//类型变量if (type instanceof TypeVariable) {return resolveTypeVar((TypeVariable<?>) type, srcType, declaringClass);//参数化类型} else if (type instanceof ParameterizedType) {return resolveParameterizedType((ParameterizedType) type, srcType, declaringClass);//数组类型} else if (type instanceof GenericArrayType) {return resolveGenericArrayType((GenericArrayType) type, srcType, declaringClass);} else {return type;}}
//解析数组类型private static Type resolveGenericArrayType(GenericArrayType genericArrayType, Type srcType, Class<?> declaringClass) {//例如T[]，则为TType componentType = genericArrayType.getGenericComponentType();Type resolvedComponentType = null;if (componentType instanceof TypeVariable) {resolvedComponentType = resolveTypeVar((TypeVariable<?>) componentType, srcType, declaringClass);} else if (componentType instanceof GenericArrayType) {resolvedComponentType = resolveGenericArrayType((GenericArrayType) componentType, srcType, declaringClass);} else if (componentType instanceof ParameterizedType) {resolvedComponentType = resolveParameterizedType((ParameterizedType) componentType, srcType, declaringClass);}if (resolvedComponentType instanceof Class) {return Array.newInstance((Class<?>) resolvedComponentType, 0).getClass();} else {//封装return new GenericArrayTypeImpl(resolvedComponentType);}}
//解析参数化类型private static ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type srcType, Class<?> declaringClass) {//解析实例的泛型类型Class<?> rawType = (Class<?>) parameterizedType.getRawType();Type[] typeArgs = parameterizedType.getActualTypeArguments();Type[] args = new Type[typeArgs.length];for (int i = 0; i < typeArgs.length; i++) {if (typeArgs[i] instanceof TypeVariable) {args[i] = resolveTypeVar((TypeVariable<?>) typeArgs[i], srcType, declaringClass);} else if (typeArgs[i] instanceof ParameterizedType) {args[i] = resolveParameterizedType((ParameterizedType) typeArgs[i], srcType, declaringClass);} else if (typeArgs[i] instanceof WildcardType) {args[i] = resolveWildcardType((WildcardType) typeArgs[i], srcType, declaringClass);} else {args[i] = typeArgs[i];}}return new ParameterizedTypeImpl(rawType, null, args);}
//解析 WildcardType 类型private static Type resolveWildcardType(WildcardType wildcardType, Type srcType, Class<?> declaringClass) {//解析泛型表达式的下界（super）Type[] lowerBounds = resolveWildcardTypeBounds(wildcardType.getLowerBounds(), srcType, declaringClass);//解析泛型表达式的上届（extends）Type[] upperBounds = resolveWildcardTypeBounds(wildcardType.getUpperBounds(), srcType, declaringClass);return new WildcardTypeImpl(lowerBounds, upperBounds);}private static Type[] resolveWildcardTypeBounds(Type[] bounds, Type srcType, Class<?> declaringClass) {Type[] result = new Type[bounds.length];for (int i = 0; i < bounds.length; i++) {if (bounds[i] instanceof TypeVariable) {result[i] = resolveTypeVar((TypeVariable<?>) bounds[i], srcType, declaringClass);} else if (bounds[i] instanceof ParameterizedType) {result[i] = resolveParameterizedType((ParameterizedType) bounds[i], srcType, declaringClass);} else if (bounds[i] instanceof WildcardType) {result[i] = resolveWildcardType((WildcardType) bounds[i], srcType, declaringClass);} else {result[i] = bounds[i];}}return result;}private static Type resolveTypeVar(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass) {Type result = null;Class<?> clazz = null;if (srcType instanceof Class) {clazz = (Class<?>) srcType;} else if (srcType instanceof ParameterizedType) {ParameterizedType parameterizedType = (ParameterizedType) srcType;clazz = (Class<?>) parameterizedType.getRawType();} else {throw new IllegalArgumentException("The 2nd arg must be Class or ParameterizedType, but was: " + srcType.getClass());}if (clazz == declaringClass) {Type[] bounds = typeVar.getBounds();if(bounds.length > 0) {return bounds[0];}return Object.class;}Type superclass = clazz.getGenericSuperclass();result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superclass);if (result != null) {return result;}Type[] superInterfaces = clazz.getGenericInterfaces();for (Type superInterface : superInterfaces) {result = scanSuperTypes(typeVar, srcType, declaringClass, clazz, superInterface);if (result != null) {return result;}}return Object.class;}private static Type scanSuperTypes(TypeVariable<?> typeVar, Type srcType, Class<?> declaringClass, Class<?> clazz, Type superclass) {if (superclass instanceof ParameterizedType) {ParameterizedType parentAsType = (ParameterizedType) superclass;Class<?> parentAsClass = (Class<?>) parentAsType.getRawType();TypeVariable<?>[] parentTypeVars = parentAsClass.getTypeParameters();if (srcType instanceof ParameterizedType) {parentAsType = translateParentTypeVars((ParameterizedType) srcType, clazz, parentAsType);}if (declaringClass == parentAsClass) {for (int i = 0; i < parentTypeVars.length; i++) {if (typeVar == parentTypeVars[i]) {return parentAsType.getActualTypeArguments()[i];}}}if (declaringClass.isAssignableFrom(parentAsClass)) {return resolveTypeVar(typeVar, parentAsType, declaringClass);}} else if (superclass instanceof Class && declaringClass.isAssignableFrom((Class<?>) superclass)) {return resolveTypeVar(typeVar, superclass, declaringClass);}return null;}private static ParameterizedType translateParentTypeVars(ParameterizedType srcType, Class<?> srcClass, ParameterizedType parentType) {Type[] parentTypeArgs = parentType.getActualTypeArguments();Type[] srcTypeArgs = srcType.getActualTypeArguments();TypeVariable<?>[] srcTypeVars = srcClass.getTypeParameters();Type[] newParentArgs = new Type[parentTypeArgs.length];boolean noChange = true;for (int i = 0; i < parentTypeArgs.length; i++) {if (parentTypeArgs[i] instanceof TypeVariable) {for (int j = 0; j < srcTypeVars.length; j++) {if (srcTypeVars[j] == parentTypeArgs[i]) {noChange = false;newParentArgs[i] = srcTypeArgs[j];}}} else {newParentArgs[i] = parentTypeArgs[i];}}return noChange ? parentType : new ParameterizedTypeImpl((Class<?>)parentType.getRawType(), null, newParentArgs);}private TypeParameterResolver() {super();}
//封装参数化类型static class ParameterizedTypeImpl implements ParameterizedType {//例如Listprivate Class<?> rawType;
//这个属性的所有者private Type ownerType;
//<>中的实际类型private Type[] actualTypeArguments;public ParameterizedTypeImpl(Class<?> rawType, Type ownerType, Type[] actualTypeArguments) {super();this.rawType = rawType;this.ownerType = ownerType;this.actualTypeArguments = actualTypeArguments;}@Overridepublic Type[] getActualTypeArguments() {return actualTypeArguments;}@Overridepublic Type getOwnerType() {return ownerType;}@Overridepublic Type getRawType() {return rawType;}@Overridepublic String toString() {return "ParameterizedTypeImpl [rawType=" + rawType + ", ownerType=" + ownerType + ", actualTypeArguments=" + Arrays.toString(actualTypeArguments) + "]";}}
//实现类static class WildcardTypeImpl implements WildcardType {//下界private Type[] lowerBounds;
//上界private Type[] upperBounds;WildcardTypeImpl(Type[] lowerBounds, Type[] upperBounds) {super();this.lowerBounds = lowerBounds;this.upperBounds = upperBounds;}@Overridepublic Type[] getLowerBounds() {return lowerBounds;}@Overridepublic Type[] getUpperBounds() {return upperBounds;}}
//数组类型的实现类static class GenericArrayTypeImpl implements GenericArrayType {private Type genericComponentType;GenericArrayTypeImpl(Type genericComponentType) {super();this.genericComponentType = genericComponentType;}@Overridepublic Type getGenericComponentType() {return genericComponentType;}}
}

ArrayUtil 数组工具类

public class ArrayUtil {public static int hashCode(Object obj) {if (obj == null) {// for consistency with Arrays#hashCode() and Objects#hashCode()return 0;}//普通类final Class<?> clazz = obj.getClass();if (!clazz.isArray()) {return obj.hashCode();}//数组类型final Class<?> componentType = clazz.getComponentType();if (long.class.equals(componentType)) {return Arrays.hashCode((long[]) obj);} else if (int.class.equals(componentType)) {return Arrays.hashCode((int[]) obj);} else if (short.class.equals(componentType)) {return Arrays.hashCode((short[]) obj);} else if (char.class.equals(componentType)) {return Arrays.hashCode((char[]) obj);} else if (byte.class.equals(componentType)) {return Arrays.hashCode((byte[]) obj);} else if (boolean.class.equals(componentType)) {return Arrays.hashCode((boolean[]) obj);} else if (float.class.equals(componentType)) {return Arrays.hashCode((float[]) obj);} else if (double.class.equals(componentType)) {return Arrays.hashCode((double[]) obj);} else {return Arrays.hashCode((Object[]) obj);}}public static boolean equals(Object thisObj, Object thatObj) {if (thisObj == null) {return thatObj == null;} else if (thatObj == null) {return false;}final Class<?> clazz = thisObj.getClass();if (!clazz.equals(thatObj.getClass())) {return false;}//普通类if (!clazz.isArray()) {return thisObj.equals(thatObj);}//数组类final Class<?> componentType = clazz.getComponentType();if (long.class.equals(componentType)) {return Arrays.equals((long[]) thisObj, (long[]) thatObj);} else if (int.class.equals(componentType)) {return Arrays.equals((int[]) thisObj, (int[]) thatObj);} else if (short.class.equals(componentType)) {return Arrays.equals((short[]) thisObj, (short[]) thatObj);} else if (char.class.equals(componentType)) {return Arrays.equals((char[]) thisObj, (char[]) thatObj);} else if (byte.class.equals(componentType)) {return Arrays.equals((byte[]) thisObj, (byte[]) thatObj);} else if (boolean.class.equals(componentType)) {return Arrays.equals((boolean[]) thisObj, (boolean[]) thatObj);} else if (float.class.equals(componentType)) {return Arrays.equals((float[]) thisObj, (float[]) thatObj);} else if (double.class.equals(componentType)) {return Arrays.equals((double[]) thisObj, (double[]) thatObj);} else {return Arrays.equals((Object[]) thisObj, (Object[]) thatObj);}}/*** If the {@code obj} is an array, toString() method of {@link Arrays} is called. Otherwise* {@link Object#toString()} is called. Returns "null" if {@code obj} is <code>null</code>.* * @param obj*          An object. May be an array or <code>null</code>.* @return String representation of the {@code obj}.*/public static String toString(Object obj) {if (obj == null) {return "null";}final Class<?> clazz = obj.getClass();//普通类if (!clazz.isArray()) {return obj.toString();}//数组类final Class<?> componentType = obj.getClass().getComponentType();if (long.class.equals(componentType)) {return Arrays.toString((long[]) obj);} else if (int.class.equals(componentType)) {return Arrays.toString((int[]) obj);} else if (short.class.equals(componentType)) {return Arrays.toString((short[]) obj);} else if (char.class.equals(componentType)) {return Arrays.toString((char[]) obj);} else if (byte.class.equals(componentType)) {return Arrays.toString((byte[]) obj);} else if (boolean.class.equals(componentType)) {return Arrays.toString((boolean[]) obj);} else if (float.class.equals(componentType)) {return Arrays.toString((float[]) obj);} else if (double.class.equals(componentType)) {return Arrays.toString((double[]) obj);} else {return Arrays.toString((Object[]) obj);}}}

ExceptionUtil 异常工具类

public class ExceptionUtil {private ExceptionUtil() {// Prevent Instantiation}public static Throwable unwrapThrowable(Throwable wrapped) {//去掉包装后的异常Throwable unwrapped = wrapped;while (true) {if (unwrapped instanceof InvocationTargetException) {unwrapped = ((InvocationTargetException) unwrapped).getTargetException();} else if (unwrapped instanceof UndeclaredThrowableException) {unwrapped = ((UndeclaredThrowableException) unwrapped).getUndeclaredThrowable();} else {return unwrapped;}}}}