public class XPathParser {
  	private final Document document;
  	private boolean validation;
  	private EntityResolver entityResolver;	// 用于加载本地DTD文件
  	private Properties variables;			// mybatis-config.xml中<properties>标签定义的键值对集合
  	private XPath xpath;					// XPath对象
}

public class XMLMapperEntityResolver implements EntityResolver {
    // 指定mybatis-config文件和映射文件对应的DTD的systemId
    private static final String IBATIS_CONFIG_SYSTEM = "ibatis-3-config.dtd";
    private static final String IBATIS_MAPPER_SYSTEM = "ibatis-3-mapper.dtd";
    private static final String MYBATIS_CONFIG_SYSTEM = "mybatis-3-config.dtd";
    private static final String MYBATIS_MAPPER_SYSTEM = "mybatis-3-mapper.dtd";

    // 指定mybatis-config文件和映射文件对应的DTD的具体位置
    private static final String MYBATIS_CONFIG_DTD = "org/apache/ibatis/builder/xml/mybatis-3-config.dtd";
    private static final String MYBATIS_MAPPER_DTD = "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd";

    @Override
    public InputSource resolveEntity(String publicId, String systemId) throws SAXException {
        try {
            if (systemId != null) {
                String lowerCaseSystemId = systemId.toLowerCase(Locale.ENGLISH);
                // 查找systemId对应的DTD文档，并读取
                if (lowerCaseSystemId.contains(MYBATIS_CONFIG_SYSTEM) || lowerCaseSystemId.contains(IBATIS_CONFIG_SYSTEM)) {
                    return getInputSource(MYBATIS_CONFIG_DTD, publicId, systemId);
                } else if (lowerCaseSystemId.contains(MYBATIS_MAPPER_SYSTEM) || lowerCaseSystemId.contains(IBATIS_MAPPER_SYSTEM)) {
                    return getInputSource(MYBATIS_MAPPER_DTD, publicId, systemId);
                }
            }
            return null;
        } catch (Exception e) {
            throw new SAXException(e.toString());
        }
    }

}

// XPathParser的初始化
private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver) {
    this.validation = validation;
    this.entityResolver = entityResolver;
    this.variables = variables;
    XPathFactory factory = XPathFactory.newInstance();
    this.xpath = factory.newXPath();
}

// 创建Document对象
private Document createDocument(InputSource inputSource) {
    // important: this must only be called AFTER common constructor
    try {
      	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      
        // ...配置factory，略

        DocumentBuilder builder = factory.newDocumentBuilder();
        builder.setEntityResolver(entityResolver);
        builder.setErrorHandler(new ErrorHandler() {
            // 空方法
        });
        // 加载XML文档
        return builder.parse(inputSource);
    } catch (Exception e) {
        throw new BuilderException("Error creating document instance.  Cause: " + e, e);
    }
}

public String evalString(Object root, String expression) {
    String result = (String) evaluate(expression, root, XPathConstants.STRING);
    result = PropertyParser.parse(result, variables);
    return result;
}

public class GenericTokenParser {

  private final String openToken;		// 占位符的开始标记
  private final String closeToken;		// 占位符的结束标记
  private final TokenHandler handler;	// TokenHandler实现会按照一定逻辑解析占位符
}

public String handleToken(String content) {
    if (variables != null) {
        String key = content;
        if (enableDefaultValue) {
            // 查找分隔符
            final int separatorIndex = content.indexOf(defaultValueSeparator);
            String defaultValue = null;
            if (separatorIndex >= 0) {
                // 获取占位符的名称
                key = content.substring(0, separatorIndex);
                // 获取默认值
                defaultValue = content.substring(separatorIndex + defaultValueSeparator.length());
            }
            if (defaultValue != null) {
                // variables集合中查找指定的占位符
                return variables.getProperty(key, defaultValue);
            }
        }
        if (variables.containsKey(key)) {
            return variables.getProperty(key);
        }
    }
    // variables集合为空
    return "${" + content + "}";
}

public class Reflector {

  private static final MethodHandle isRecordMethodHandle = getIsRecordMethodHandle();
  private final Class<?> type;											// 对应的Class类型
  private final String[] readablePropertyNames;							// 可读属性的名称集合, 即存在getter方法的属性
  private final String[] writablePropertyNames;							// 可写属性的名称集合, 即存在setter方法的属性
  private final Map<String, Invoker> setMethods = new HashMap<>();		// 记录了相应属性的setter方法
  private final Map<String, Invoker> getMethods = new HashMap<>();		// 记录了相应属性的getter方法
  private final Map<String, Class<?>> setTypes = new HashMap<>();		// 记录了属性相应的setter方法的参数值类型
  private final Map<String, Class<?>> getTypes = new HashMap<>();		// 记录了属性相应的getter方法的参数值类型
  private Constructor<?> defaultConstructor;							// 记录了默认的构造方法

  private Map<String, String> caseInsensitivePropertyMap = new HashMap<>();	// 记录了所有属性名称的集合
}

public Reflector(Class<?> clazz) {
    type = clazz;                                     // 初始化type字段
    addDefaultConstructor(clazz);                     // 查找clazz的默认构造方法(无参)
    Method[] classMethods = getClassMethods(clazz);  // 获得类的所有方法
    if (isRecord(type)) {
      addRecordGetMethods(classMethods);
    } else {
      addGetMethods(classMethods);                    // 处理clazz中的getter方法, 填充getMethods集合和getTypes集合
      addSetMethods(classMethods);                    // 处理clazz中的setter方法, 填充setMethods集合和setTypes集合
      addFields(clazz);                               // 处理没有getter/setter方法的字段
    }
    // 根据getMethods/setMethods集合, 初始化可读/写的属性的名称集合
    readablePropertyNames = getMethods.keySet().toArray(new String[0]);
    writablePropertyNames = setMethods.keySet().toArray(new String[0]);
    
    // 初始化caseInsensitivePropertyMap集合, 其中记录了所有大写格式的属性名称
    for (String propName : readablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
    for (String propName : writablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
  }

private Method[] getClassMethods(Class<?> clazz) {
    // 用于记录指定类中定义的全部方法的唯一签名以及对应的Method对象
    Map<String, Method> uniqueMethods = new HashMap<>();
    Class<?> currentClass = clazz;
    while (currentClass != null && currentClass != Object.class) {
        // 记录currentClass这个类中定义的全部方法
        addUniqueMethods(uniqueMethods, currentClass.getDeclaredMethods());

        // we also need to look for interface methods -
        // because the class may be abstract
        Class<?>[] interfaces = currentClass.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            addUniqueMethods(uniqueMethods, anInterface.getMethods());
        }

        currentClass = currentClass.getSuperclass();  // 获取父类, 继续while循环
    }

    Collection<Method> methods = uniqueMethods.values();

    return methods.toArray(new Method[0]);  // 转换成Method数组返回
}

private void addUniqueMethods(Map<String, Method> uniqueMethods, Method[] methods) {
    for (Method currentMethod : methods) {
        if (!currentMethod.isBridge()) {
			// 通过getSignature得到方法的签名是： 返回值类型#方法名称:参数列表
            // 例如Reflector.getSignature(Method)方法的唯一签名是
            // java.lang.String#getSignature:java.lang.reflect.Method
            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
            if (!uniqueMethods.containsKey(signature)) {
                uniqueMethods.put(signature, currentMethod);
            }
        }
    }
}

private void resolveGetterConflicts(Map<String, List<Method>> conflictingGetters) {
    for (Entry<String, List<Method>> entry : conflictingGetters.entrySet()) {
        Method winner = null;
        String propName = entry.getKey();
        boolean isAmbiguous = false;
        for (Method candidate : entry.getValue()) {
            if (winner == null) {
                // 如果没有候选方法, 当前方法直接成为候选方法
                winner = candidate;
                continue;
            }
            Class<?> winnerType = winner.getReturnType();
            Class<?> candidateType = candidate.getReturnType();
            if (candidateType.equals(winnerType)) {
                // 返回值相同, 而这种情况应该已经过滤掉了
                // 但如果是bool值, 可能存在getXXX 和 isXXX, 这个时候isXXX当选
                if (!boolean.class.equals(candidateType)) {
                    isAmbiguous = true;
                    break;
                }
                if (candidate.getName().startsWith("is")) {
                    winner = candidate;
                }
            } else if (candidateType.isAssignableFrom(winnerType)) {
                // 当前最适合方法的返回值是当前方法返回值的子类, 什么都不做
            } else if (winnerType.isAssignableFrom(candidateType)) {
                // 当前方法的返回值是当前最适合方法的返回值的之类, 当前的getter方法为最适合的getter方法
                winner = candidate;
            } else {
                isAmbiguous = true;
                break;
            }
        }
        addGetMethod(propName, winner, isAmbiguous);
    }
}

public interface ReflectorFactory {

  boolean isClassCacheEnabled();    // 检测ReflectorFactory对象是否会缓存Reflector对象

  void setClassCacheEnabled(boolean classCacheEnabled);     // 设置是否缓存Reflector对象

  Reflector findForClass(Class<?> type);      // 创建指定Class对应的Reflector对象
}

public Reflector findForClass(Class<?> type) {
    if (classCacheEnabled) {
        // synchronized (type) removed see issue #461
        return MapUtil.computeIfAbsent(reflectorMap, type, Reflector::new);
    }
    return new Reflector(type);
}

public static Type resolveFieldType(Field field, Type srcType) {
    Type fieldType = field.getGenericType();                // 获取字段的声明类型
    Class<?> declaringClass = field.getDeclaringClass();    // 获取字段定义所在的类的Class对象
    return resolveType(fieldType, srcType, declaringClass); // 后续处理
}

private static Type resolveType(Type type, Type srcType, Class<?> declaringClass) {
    if (type instanceof TypeVariable) {   // 解析TypeVariable类型
        return resolveTypeVar((TypeVariable<?>) type, srcType, declaringClass);
    }
    if (type instanceof ParameterizedType pt) { // 解析ParameterizedType类型
        return resolveParameterizedType(pt, srcType, declaringClass);
    } else if (type instanceof GenericArrayType gt) {  // 解析GenericArrayType类型
        return resolveGenericArrayType(gt, srcType, declaringClass);
    } else {
        return type;        // Class类型
    }
}

public interface ObjectFactory 
    
    default void setProperties(Properties properties) {	// 设定配置信息
        // NOP
    }

    <T> T create(Class<T> type);				// 通过无参构造器创建指定类的对象

	// 根据参数列表, 从指定类型中选择合适的构造器创建对象
    <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs);

	// 检测指定类型是否为集合类型(Collection类型)
    <T> boolean isCollection(Class<T> type);
}

public class PropertyTokenizer implements Iterator<PropertyTokenizer> {
    private String name;    // 当前表达式的名称
    private final String indexedName; // 当前表达式的索引名
    private String index;   // 索引下标
    private final String children;  // 子表达式

    public PropertyTokenizer(String fullname) {
        int delim = fullname.indexOf('.');
        if (delim > -1) {
            name = fullname.substring(0, delim);
            children = fullname.substring(delim + 1);
        } else {
            name = fullname;
            children = null;
        }
        indexedName = name;
        delim = name.indexOf('[');
        if (delim > -1) {
            index = name.substring(delim + 1, name.length() - 1);
            name = name.substring(0, delim);
        }
    }
    
    @Override
    public boolean hasNext() {
        return children != null;
    }

    @Override
    public PropertyTokenizer next() {
        return new PropertyTokenizer(children);
    }
}

public final class PropertyNamer {
    // 将方法名转换为属性名
    public static String methodToProperty(String name) {
        // 简单说就是将is、get、set截掉，并将首字母小写
    }

    // 方法名是否对应属性名
    public static boolean isProperty(String name) {
        // 简单说就是方法名是否以is、get、set开头
    }

    public static boolean isGetter(String name) {
        return name.startsWith("get") && name.length() > 3 || name.startsWith("is") && name.length() > 2;
    }

    public static boolean isSetter(String name) {
        return name.startsWith("set") && name.length() > 3;
    }
}

public static void copyBeanProperties(Class<?> type, Object sourceBean, Object destinationBean) {
    Class<?> parent = type;
    while (parent != null) {
        final Field[] fields = parent.getDeclaredFields();
        for (Field field : fields) {
            try {
                try {
                    field.set(destinationBean, field.get(sourceBean));
                } catch (IllegalAccessException e) {
                    if (!Reflector.canControlMemberAccessible()) {
                        throw e;
                    }
                    field.setAccessible(true);
                    field.set(destinationBean, field.get(sourceBean));
                }
            } catch (Exception e) {
                // Nothing useful to do, will only fail on final fields, which will be ignored.
            }
        }
        // 继续拷贝父类定义的字段
        parent = parent.getSuperclass();
    }
}

private StringBuilder buildProperty(String name, StringBuilder builder) {
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {		// 是否还有子表达式
        // 查找PropertyTokenizer.name对应的属性
        String propertyName = reflector.findPropertyName(prop.getName());
        if (propertyName != null) {
            builder.append(propertyName);	// 追加属性名
            builder.append(".");
            // 创建对应的MetaClass对象
            MetaClass metaProp = metaClassForProperty(propertyName);
            // 递归解析PropertyTokenizer的children字段, 并将解析结果保存到builder中
            metaProp.buildProperty(prop.getChildren(), builder);
        }
    } else {		// 递归出口
        String propertyName = reflector.findPropertyName(name);
        if (propertyName != null) {
            builder.append(propertyName);
        }
    }
    return builder;
}

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

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

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

    // 查找可写的属性名称集合
    String[] getGetterNames();

    // 查找可读属性的名称集合
    String[] getSetterNames();

    // 解析属性表达式指定属性的setter/getter参数类型
    Class<?> getSetterType(String name);
    Class<?> getGetterType(String name);

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

    // 为属性表示指定的属性创建相应的MetaObject对象
    MetaObject instantiatePropertyValue(String name, PropertyTokenizer prop, ObjectFactory objectFactory);

    // 封装的对象是否为Collection类型
    boolean isCollection();

    // 调用Collection类型的add方法
    void add(Object element);

    // 调用Collection类型的addAll方法
    <E> void addAll(List<E> element);

}

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始终为null, 所以这块其实是用户自定义的扩展点
        this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
    } else if (object instanceof Map) {
        // 若原始对象为Map类型，则创建MapWrapper对象
        this.objectWrapper = new MapWrapper(this, (Map) object);
    } else if (object instanceof Collection) {
        // 若原始对象为Collection类型，则创建CollectionWrapper对象
        this.objectWrapper = new CollectionWrapper(this, (Collection) object);
    } else {
        // 若原始对象为普通的JavaBean类型，则创建BeanWrapper对象
        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;
    }
    return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory);
}

public interface TypeHandler<T> {

    /**
     * setParameter方法负责将数据由JdbcType类型转换为Java类型
     */
    void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

    /**
     * getResult方法负责将数据由Java类型转换为JdbcType类型
     */
    T getResult(ResultSet rs, String columnName) throws SQLException;

    T getResult(ResultSet rs, int columnIndex) throws SQLException;

    T getResult(CallableStatement cs, int columnIndex) throws SQLException;

}

public abstract class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T> {

    @Override
    public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
        if (parameter == null) {
            if (jdbcType == null) {
                throw new TypeException("......");
            }
            try {
                ps.setNull(i, jdbcType.TYPE_CODE);	// 绑定参数为null的处理
            } catch (SQLException e) {
                throw new TypeException("...");
            }
        } else {
            try {
                // 绑定非空参数, 该方法为抽象方法, 由子类实现
                setNonNullParameter(ps, i, parameter, jdbcType);
            } catch (Exception e) {
                throw new TypeException("...");
            }
        }
    }

    @Override
    public T getResult(ResultSet rs, String columnName) throws SQLException {
        try {
            return getNullableResult(rs, columnName);
        } catch (Exception e) {
            throw new ResultMapException("...");
        }
    }

    public abstract T getNullableResult(ResultSet rs, String columnName) throws SQLException;

    public abstract T getNullableResult(ResultSet rs, int columnIndex) throws SQLException;

    public abstract T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException;

}

public final class TypeHandlerRegistry {

    // 记录JDBCType和TypeHandler之间的对应关系, 其中JdbcType是一个枚举类型
    // 该集合主要用于从结果集读取数据时, 将数据从Jdbc类型转换成Java类型
    private final Map<JdbcType, TypeHandler<?>> jdbcTypeHandlerMap = new EnumMap<>(JdbcType.class);
    
    // 记录了Java类型单向指定JdbcType转换时，需要使用的TypeHandler对象
    // 例如String可以转换为varchar、char等多种类型，所以存在一对多关系
    private final Map<Type, Map<JdbcType, TypeHandler<?>>> typeHandlerMap = new ConcurrentHashMap<>();
    
    // 记录了全部TypeHandler类型以及该类型相应的TypeHandler对象
    private final Map<Class<?>, TypeHandler<?>> allTypeHandlersMap = new HashMap<>();

    // 空TypeHandler集合的标识
    private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();
    
}

// 方法④的重载
private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
    if (javaType != null) { // 检测是否明确指定了TypeHandler能够处理的Java类型
        // 获取指定Java类型再typeHandlerMap中对应的TypeHandler集合
        Map<JdbcType, TypeHandler<?>> map = typeHandlerMap.get(javaType);
        if (map == null || map == NULL_TYPE_HANDLER_MAP) { // 创建新的集合，并添加到typeHandlerMap中
            map = new HashMap<>();
        }
        map.put(jdbcType, handler);
        typeHandlerMap.put(javaType, map);
    }
    // allTypeHandlersMap中添加TypeHandler类型和对应的TypeHandler对象
    allTypeHandlersMap.put(handler.getClass(), handler);
}

// 方法①的重载
public void register(Class<?> typeHandlerClass) {
    boolean mappedTypeFound = false;
    // 获取MappedTypes注解
    MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
    if (mappedTypes != null) {
        // 根据MappedTypes注解中指定的Java类型进行注册
        for (Class<?> javaTypeClass : mappedTypes.value()) {
            // 经由强制类型转换以及反射创建TypeHandler对象后，交由③进行处理
            register(javaTypeClass, typeHandlerClass);
            mappedTypeFound = true;
        }
    }
    if (!mappedTypeFound) {
        // 未指定MappedTypes注解，由②处理
        register(getInstance(null, typeHandlerClass));
    }
}

// 方法②的重载
public <T> void register(TypeHandler<T> typeHandler) {
    boolean mappedTypeFound = false;
    // 获取MappedTypes注解，逻辑与①类似
    MappedTypes注解， mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);
    if (mappedTypes != null) {
        for (Class<?> handledType : mappedTypes.value()) {
            register(handledType, typeHandler);
            mappedTypeFound = true;
        }
    }
    // 从3.1.0开始，如果typeHandler同时继承了TypeReference
    // 就可以根据TypeHandler的类型自动查找对应的Java类型
    if (!mappedTypeFound && typeHandler instanceof TypeReference) {
        try {
            TypeReference<T> typeReference = (TypeReference<T>) typeHandler;
            // 由③处理
            register(typeReference.getRawType(), typeHandler);
            mappedTypeFound = true;
        } catch (Throwable t) {
            // maybe users define the TypeReference with a different type and are not assignable, so just ignore it
        }
    }
    if (!mappedTypeFound) {
        // 转换类型后 交由③处理
        register((Class<T>) null, typeHandler);
    }
}

// 方法③的重载
private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {
    // 获取MappedTypes注解
    MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
    if (mappedJdbcTypes != null) {
        // 根据MappedTypes注解指定的类型进行注册
        for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
            // 由④进行注册
            register(javaType, handledJdbcType, typeHandler);
        }
        if (mappedJdbcTypes.includeNullJdbcType()) {
            // 由④进行注册
            register(javaType, null, typeHandler);
        }
    } else {
        // 由④进行注册
        register(javaType, null, typeHandler);
    }
}

// 方法⑤的重载
public void register(JdbcType jdbcType, TypeHandler<?> handler) {
    jdbcTypeHandlerMap.put(jdbcType, handler);
}

public void register(String packageName) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
    // 查找指定包下的TypeHandler接口实现类
    resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);
    Set<Class<? extends Class<?>>> handlerSet = resolverUtil.getClasses();
    for (Class<?> type : handlerSet) {
        // 过滤掉内部类、接口以及抽象类
        if (!type.isAnonymousClass() && !type.isInterface() &&
            !Modifier.isAbstract(type.getModifiers())) {
			// 交由①进行注册操作
            register(type);
        }
    }
}

public TypeHandlerRegistry(Configuration configuration) {
    this.unknownTypeHandler = new UnknownTypeHandler(configuration);

    register(Boolean.class, new BooleanTypeHandler());
    register(boolean.class, new BooleanTypeHandler());
    ......
}

private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
    if (ParamMap.class.equals(type)) {
        return null;
    }
    // 查找（或初始化）Java类型对应的TypeHandler集合
    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);
    TypeHandler<?> handler = null;
    if (jdbcHandlerMap != null) {
        // 根据jdbcType查找TypeHandler对象
        handler = jdbcHandlerMap.get(jdbcType查找);
        if (handler == null) {
            handler = jdbcHandlerMap.get(null);
        }
        if (handler == null) {
            // 如果jdbcHandlerMap只注册了一个TypeHandler，就用这个对象
            handler = pickSoleHandler(jdbcHandlerMap);
        }
    }
    // type drives generics here
    return (TypeHandler<T>) handler;
}

private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {
    // 查找Java类型对应的TypeHandler集合
    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(type);
    if (jdbcHandlerMap != null) {
        // 检测是否为空集合标识
        return NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap) ? null : jdbcHandlerMap;
    }
    // 初始化指定Java类型对应的TypeHandler集合
    if (type instanceof Class) {
        Class<?> clazz = (Class<?>) type;
        if (Enum.class.isAssignableFrom(clazz)) {
            if (clazz.isAnonymousClass()) {
                return getJdbcHandlerMap(clazz.getSuperclass());
            }
            jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(clazz, clazz);
            if (jdbcHandlerMap == null) {
                register(clazz, getInstance(clazz, defaultEnumTypeHandler));
                return typeHandlerMap.get(clazz);
            }
        } else {
            // 查找父类对应的TypeHandler集合，并作为初始集合
            jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);
        }
    }
    typeHandlerMap.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);
    return jdbcHandlerMap;
}

public class TypeAliasRegistry {
    
    private final Map<String, Class<?>> typeAliases = new HashMap<>();
    
    public void registerAlias(String alias, Class<?> value) {
        if (alias == null) {	// 别名是空
            throw new TypeException("...");
        }
        String key = alias.toLowerCase(Locale.ENGLISH);
        if (typeAliases.containsKey(key) && typeAliases.get(key) != null 
            && !typeAliases.get(key).equals(value)) {	// 别名已经存在
            throw new TypeException("...");
        }
        // 注册别名
        typeAliases.put(key, value);
    }

}

public final class LogFactory {
    
    // 记录当前使用的第三方日志组件所对应的适配器的构造方法
    private static Constructor<? extends Log> logConstructor;
    
    static {
        // 针对每种日志组件调用tryImplementation方法进行尝试加载
        tryImplementation(LogFactory::useSlf4jLogging);
        tryImplementation(LogFactory::useCommonsLogging);
        tryImplementation(LogFactory::useLog4J2Logging);
        tryImplementation(LogFactory::useLog4JLogging);
        tryImplementation(LogFactory::useJdkLogging);
        tryImplementation(LogFactory::useNoLogging);
    }
}

public static synchronized void useJdkLogging() {
    setImplementation(org.apache.ibatis.logging.jdk14.Jdk14LoggingImpl.class);
}

private static void setImplementation(Class<? extends Log> implClass) {
    try {
        // 获取指定适配器的构造方法
        Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
        Log log = candidate.newInstance(LogFactory.class.getName());
        // 初始化logConstructor字段
        logConstructor = candidate;
    } catch (Throwable t) {
        throw new LogException("Error setting Log implementation.  Cause: " + t, t);
    }
}

public class Jdk14LoggingImpl implements Log {
    
    private final Logger log;		// 底层封装的Logger对象
    
    public Jdk14LoggingImpl(String clazz) {
        log = Logger.getLogger(clazz);	// 初始化Logger对象
    }
    
    @Override
    public void error(String s) {
        log.log(Level.SEVERE, s);	// 委托给Logger对象
    }
    
    ......
    
}

public abstract class BaseJdbcLogger {
    // 记录了PreparedStatement接口中定义的常用的set*方法
    protected static final Set<String> SET_METHODS;
    // 记录了Statement接口和PreparedStatement接口中执行SQL语句相关的方法
    protected static final Set<String> EXECUTE_METHODS = new HashSet<>();
    
    // 记录了PreparedStatement的set*方法设置的键值对
    private final Map<Object, Object> columnMap = new HashMap<>();

    // 记录了PreparedStatement的set*方法设置的key值
    private final List<Object> columnNames = new ArrayList<>();
    // 记录了PreparedStatement的set*方法设置的value值
    private final List<Object> columnValues = new ArrayList<>();
    
    // 用于输出日志的Log对象
    protected final Log statementLog;
   	// 记录了SQL的层数，用于格式化输出SQL
    protected final int queryStack;
    
    static {
        SET_METHODS = Arrays.stream(PreparedStatement.class.getDeclaredMethods())
            .filter(method -> method.getName().startsWith("set"))
            .filter(method -> method.getParameterCount() > 1)
            .map(Method::getName)
            .collect(Collectors.toSet());

        EXECUTE_METHODS.add("execute");
        EXECUTE_METHODS.add("executeUpdate");
        EXECUTE_METHODS.add("executeQuery");
        EXECUTE_METHODS.add("addBatch");
    }
}

public final class ConnectionLogger extends BaseJdbcLogger implements InvocationHandler {

    public static Connection newInstance(Connection conn, Log statementLog, int queryStack) {
        // 使用JDK动态代理的方法创建代理对象
        InvocationHandler handler = new ConnectionLogger(conn, statementLog, queryStack);
        ClassLoader cl = Connection.class.getClassLoader();
        return (Connection) Proxy.newProxyInstance(cl, new Class[] { Connection.class }, handler);
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
        try {
            // 如果是从Object继承的方法，则直接调用，不做其他任何处理
            if (Object.class.equals(method.getDeclaringClass())) {
                return method.invoke(this, params);
            }
            // 如果调用的是prepareStatement、prepareCall或createStatement
            // 则再创建相应Statement对象后，为其创建代理对象并返回该代理对象
            if ("prepareStatement".equals(method.getName()) || "prepareCall".equals(method.getName())) {
                if (isDebugEnabled()) {
                    debug(" Preparing: " + removeExtraWhitespace((String) params[0]), true);
                }
                PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
                return PreparedStatementLogger.newInstance(stmt, statementLog, queryStack);
            }
            if ("createStatement".equals(method.getName())) {
                Statement stmt = (Statement) method.invoke(connection, params);
                return StatementLogger.newInstance(stmt, statementLog, queryStack);
            }
            // 其他方法则直接调用底层Connection对象的相应方法
            return method.invoke(connection, params);
        } catch (Throwable t) {
            throw ExceptionUtil.unwrapThrowable(t);
        }
    }
}

public final class ResultSetLogger extends BaseJdbcLogger implements InvocationHandler {

    // 记录了超大长度的类型
    private static final Set<Integer> BLOB_TYPES = new HashSet<>();
    // 是否是ResultSet结果集的第一行
    private boolean first = true;
    // 统计行数
    private int rows;
    // 真正的ResultSet对象
    private final ResultSet rs;
    // 记录了超大字段的列编号
    private final Set<Integer> blobColumns = new HashSet<>();
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
        try {
            // 如果是从Object继承的方法，则直接调用，不做其他任何处理
            if (Object.class.equals(method.getDeclaringClass())) {
                return method.invoke(this, params);
            }
            Object o = method.invoke(rs, params);
            // 针对ResultSet.next方法的处理
            if ("next".equals(method.getName())) {
                if ((Boolean) o) {	// 是否还存在下一行数据
                    rows++;
                    if (isTraceEnabled()) {
                        ResultSetMetaData rsmd = rs.getMetaData();
                        final int columnCount = rsmd.getColumnCount();	// 获取结果集的列数
                        if (first) {	// 如果是第一行数据，则输出表头
                            first = false;
                            // 除了输出表头还会记录超大字段的列
                            printColumnHeaders(rsmd, columnCount);
                        }
                        // 输出该行记录，会过滤掉blobColumns中记录的列，这些列数据较大，不会输出到日志
                        printColumnValues(columnCount);
                    }
                } else {
                    // 遍历完ResultSet后，会输出总行数
                    debug("     Total: " + rows, false);
                }
            }
            // 情况BaseJdbcLogger中的column*集合
            clearColumnInfo();
            return o;
        } catch (Throwable t) {
            throw ExceptionUtil.unwrapThrowable(t);
        }
    }
}

public class ClassLoaderWrapper {
    ClassLoader defaultClassLoader;		// 应用指定的默认类加载器
    ClassLoader systemClassLoader;		// 系统的ClassLoader
    
    ClassLoaderWrapper() {
    try {
        // 初始化系统的ClassLoader字段
        systemClassLoader = ClassLoader.getSystemClassLoader();
    } catch (SecurityException ignored) {
        // AccessControlException on Google App Engine
    }
  }
}

public URL getResourceAsURL(String resource) {
    return getResourceAsURL(resource, getClassLoaders(null));
}

// getClassLoaders返回ClassLoader数组，该数组指明了类加载器的使用顺序
ClassLoader[] getClassLoaders(ClassLoader classLoader) {
    return new ClassLoader[] { classLoader, defaultClassLoader, Thread.currentThread().getContextClassLoader(),
                              getClass().getClassLoader(), systemClassLoader };
}

URL getResourceAsURL(String resource, ClassLoader[] classLoader) {
    URL url;
    for (ClassLoader cl : classLoader) {	// 遍历ClassLoader数组
        if (null != cl) {
            // 调用ClassLoader.getResource方法查找指定的资源
            url = cl.getResource(resource);
            if (null == url) {
                // 尝试以"/"开头，再次查找
                url = cl.getResource("/" + resource);
            }
            if (null != url) {	// 查找到指定的资源
                return url;
            }
        }
    }

    // didn't find it anywhere.
    return null;
}

public interface Test {
    // 参数type是待检测的类，返回该类是否满足检测的条件
    boolean matches(Class<?> type);
}

public static class IsA implements Test {	// 用于检测类是否继承了parent指定的类

    private final Class<?> parent;
    
    public IsA(Class<?> parentType) {
        this.parent = parentType;
    }

    @Override
    public boolean matches(Class<?> type) {
        return type != null && parent.isAssignableFrom(type);
    }

    @Override
    public String toString() {
        return "is assignable to " + parent.getSimpleName();
    }
}

public static class AnnotatedWith implements Test {	// 用于检测指定类是否添加了annotation注解

    private final Class<? extends Annotation> annotation;

    public AnnotatedWith(Class<? extends Annotation> annotation) {
        this.annotation = annotation;
    }

    @Override
    public boolean matches(Class<?> type) {
        return type != null && type.isAnnotationPresent(annotation);
    }

    @Override
    public String toString() {
        return "annotated with @" + annotation.getSimpleName();
    }
}

public abstract class VFS {
    // 记录了MyBatis提供的两个VFS实现类
    public static final Class<?>[] IMPLEMENTATIONS = { JBoss6VFS.class, DefaultVFS.class };
    
    // 记录了用户自定义的VFS实现类
    // VFS.addImplClass方法会将指定的VFS实现对应的Class对象添加到这哥集合中
    public static final List<Class<? extends VFS>> USER_IMPLEMENTATIONS = new ArrayList<>();
    
}

public static VFS getInstance() {
    return VFSHolder.INSTANCE;
}

private static class VFSHolder {
    static final VFS INSTANCE = createVFS();

    @SuppressWarnings("unchecked")
    static VFS createVFS() {
        // 先用用户自定义的VFS实现，然后才用Mybatis提供的VFS实现
        List<Class<? extends VFS>> impls = new ArrayList<>(USER_IMPLEMENTATIONS);
        impls.addAll(Arrays.asList((Class<? extends VFS>[]) IMPLEMENTATIONS));

        VFS vfs = null;
        // 遍历impls集合，依次实例化VFS对象是否有效，一旦得到有效的VFS对象则结束循环
        for (int i = 0; vfs == null || !vfs.isValid(); i++) {
            Class<? extends VFS> impl = impls.get(i);
            try {
                vfs = impl.getDeclaredConstructor().newInstance();
            } catch (InstantiationException | IllegalAccessException | NoSuchMethodException
                     | InvocationTargetException e) {
                log.error("...");
                return null;
            }
        }
        return vfs;
    }

    private VFSHolder() {
    }
}

@Override
public List<String> list(URL url, String path) throws IOException {
    InputStream is = null;
    try {
        List<String> resources = new ArrayList<>();
		// 如果url指向的资源在一个jar包中，则获取Jar包对应的URL，否则返回null
        URL jarUrl = findJarForResource(url);
        if (jarUrl != null) {
            is = jarUrl.openStream();
            // 遍历Jar中的资源，并返回以path开头的资源列表
            resources = listResources(new JarInputStream(is), path);
        } else {
            // 遍历url指向的目录，将其资源名称记录到childern集合中，略
            // ...

            // 遍历children集合，递归查找符合条件的资源名称
            for (String child : children) {
                String resourcePath = path + "/" + child;
                resources.add(resourcePath);
                URL childUrl = new URL(prefix + child);
                resources.addAll(list(childUrl, resourcePath));
            }
        }

        return resources;
    } finally {
        // 关闭流
        // ...
    }
}

protected List<String> listResources(JarInputStream jar, String path) throws IOException {
    // 如果path不是以"/"开始和结束，则在其开始和结束位置添加"/"
    // ...

    // 遍历整个Jar包，将以path开头的资源记录到resources集合中并返回
    List<String> resources = new ArrayList<>();
    for (JarEntry entry; (entry = jar.getNextJarEntry()) != null;) {
        if (!entry.isDirectory()) {
            // Add leading slash if it's missing
            StringBuilder name = new StringBuilder(entry.getName());
            if (name.charAt(0) != '/') {
                name.insert(0, '/');
            }

            // Check file name
            if (name.indexOf(path) == 0) {		// 检测name是否以path开头
                // Trim leading slash
                resources.add(name.substring(1));
            }
        }
    }
    return resources;
}

public interface DataSourceFactory {

  // 设置DataSource的相关属性, 一般紧跟在初始化完成之后
  void setProperties(Properties props);

  // 获取DataSource对象
  DataSource getDataSource();

}

public UnpooledDataSourceFactory() {
    this.dataSource = new UnpooledDataSource();
}

@Override
public DataSource getDataSource() {
    return dataSource;
}

@Override
public void setProperties(Properties properties) {
    Properties driverProperties = new Properties();
    // 创建DataSource相应的MetaObject
    MetaObject metaDataSource = SystemMetaObject.forObject(dataSource);
    // 遍历Properties集合，该集合中配置乐数据源需要的信息
    for (Object key : properties.keySet()) {
        String propertyName = (String) key;
        if (propertyName.startsWith(DRIVER_PROPERTY_PREFIX)) {
            String value = properties.getProperty(propertyName);
            // 以"driver."开头的配置项是对DataSource的配置，记录到driverProperties
            driverProperties.setProperty(propertyName.substring(DRIVER_PROPERTY_PREFIX_LENGTH), value);
        } else if (metaDataSource.hasSetter(propertyName)) {  // 是否有该属性的setter方法
            String value = (String) properties.get(propertyName);
            // 根据属性进行类型转换
            Object convertedValue = convertValue(metaDataSource, propertyName, value);
            // 记录DataSource的相关属性值
            metaDataSource.setValue(propertyName, convertedValue);
        } else {
            throw new DataSourceException("Unknown DataSource property: " + propertyName);
        }
    }
    if (driverProperties.size() > 0) {
        // 设置DataSource.driverProperties属性值
        metaDataSource.setValue("driverProperties", driverProperties);
    }
}

public class UnpooledDataSource implements DataSource {

  // 加载Driver类的类加载器
  private ClassLoader driverClassLoader;
  // 数据库连接驱动的相关配置
  private Properties driverProperties;
  // 缓存所有已经注册的数据库连接驱动
  private static final Map<String, Driver> registeredDrivers = new ConcurrentHashMap<>();

  private String driver;  // 驱动连接的驱动名称
  private String url;   // 数据库URL
  private String username;  // 数据库用户名
  private String password;  // 数据库密码

  private Boolean autoCommit; // 是否自动提交
  private Integer defaultTransactionIsolationLevel;   // 事物隔离级别
  private Integer defaultNetworkTimeout;  // 超时时间
}

static {
    Enumeration<Driver> drivers = DriverManager.getDrivers();
    while (drivers.hasMoreElements()) {
        Driver driver = drivers.nextElement();
        registeredDrivers.put(driver.getClass().getName(), driver);
    }
}

private Connection doGetConnection(Properties properties) throws SQLException {
    // 初始化数据库驱动
    initializeDriver();
    // 创建真正的数据库连接
    Connection connection = DriverManager.getConnection(url, properties);
    // 配置数据库连接的autoCommit和隔离级别
    configureConnection(connection);
    return connection;
}

private synchronized void initializeDriver() throws SQLException {
    if (!registeredDrivers.containsKey(driver)) {   // 检测驱动是否已经注册
      Class<?> driverType;
      try {
        if (driverClassLoader != null) {
          driverType = Class.forName(driver, true, driverClassLoader);    // 注册驱动
        } else {
          driverType = Resources.classForName(driver);
        }
        Driver driverInstance = (Driver) driverType.getDeclaredConstructor().newInstance(); // 创建Driver对象
        // 注册驱动，DriverProxy是定义在UnpooledDataSource中的内部类，是Driver的静态代理类
        DriverManager.registerDriver(new DriverProxy(driverInstance));
        // 将驱动添加到registeredDrivers中
        registeredDrivers.put(driver, driverInstance);
      } catch (Exception e) {
        throw new SQLException("Error setting driver on UnpooledDataSource. Cause: " + e);
      }
    }
  }

private void configureConnection(Connection conn) throws SQLException {
    if (defaultNetworkTimeout != null) {
        conn.setNetworkTimeout(Executors.newSingleThreadExecutor(), defaultNetworkTimeout);
    }
    if (autoCommit != null && autoCommit != conn.getAutoCommit()) {
        // 设置事物是否自动提交
        conn.setAutoCommit(autoCommit);
    }
    if (defaultTransactionIsolationLevel != null) {
        // 设置事物隔离级别
        conn.setTransactionIsolation(defaultTransactionIsolationLevel);
    }
}

// 记录当前PooledConnection对象所在的PooledDataSource对象。该PooledConnection是从
// 该PooledDataSource中获取的；当调用close方法时会将PooledConnection放回该
// PooledDataSource中
private final PooledDataSource dataSource;

// 真正的数据库连接
private final Connection realConnection;

// 数据库连接的代理对象
private final Connection proxyConnection;

// 从连接池中取出该连接的时间戳
private long checkoutTimestamp;

// 该连接创建的时间戳
private long createdTimestamp;

// 最后一次被使用的世界城
private long lastUsedTimestamp;

// 由数据库URL、用户名和密码算出来的hash值，可用于标识该连接所在的连接池
private int connectionTypeCode;

// 检测当前PooledConnection是否有效。
// 主要防止close方法归还给连接池后仍然通过该连接操作数据库
private boolean valid;

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String methodName = method.getName();
    // 如果调用close方法，则将其重新放入连接池，而不是真正关闭数据库连接
    if (CLOSE.equals(methodName)) {
        dataSource.pushConnection(this);
        return null;
    }
    try {
        if (!Object.class.equals(method.getDeclaringClass())) {
            checkConnection();    // 通过valid字段检测连接是否有效
        }
        return method.invoke(realConnection, args);   // 调用真正数据库连接对象的对应方法
    } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
    }
}

// 空闲的PooledConnection集合
protected final List<PooledConnection> idleConnections = new ArrayList<>();
// 活跃的PooledConnection集合
protected final List<PooledConnection> activeConnections = new ArrayList<>();

// 请求数据库连接的次数
protected long requestCount;
// 获取连接的累积时间
protected long accumulatedRequestTime;
// checkoutTime表示应用从连接池中取出连接，到归还连接这段时长，
// 记录了所有连接累积的checkoutTime时长
protected long accumulatedCheckoutTime;
// 记录了超时的连接个数
protected long claimedOverdueConnectionCount;
// 累积超时时间
protected long accumulatedCheckoutTimeOfOverdueConnections;
// 累积等待时间
protected long accumulatedWaitTime;
// 等待次数
protected long hadToWaitCount;
// 无效的连接数
protected long badConnectionCount;

// 通过PoolState管理连接池的状态并记录统计信息
private final PoolState state = new PoolState(this);

// 记录UnpooledDataSource对象，用于生成真实的数据库连接对象，构造函数中会初始化该字段
private final UnpooledDataSource dataSource;

// 最大活跃连接数
protected int poolMaximumActiveConnections = 10;
// 最大空闲连接数
protected int poolMaximumIdleConnections = 5;
// 最大checkout时长
protected int poolMaximumCheckoutTime = 20000;
// 在无法获取连接时，线程需要等待的时间
protected int poolTimeToWait = 20000;
protected int poolMaximumLocalBadConnectionTolerance = 3;
// 在检测一个数据库连接是否可用时，会给数据库发送一个测试SQL语句
protected String poolPingQuery = "NO PING QUERY SET";
// 是否允许发送测试SQL语句
protected boolean poolPingEnabled;
// 当连接超过poolPingConnectionsNotUsedFor毫秒未使用时，会发送一次测试SQL语句，检测连接是否正常
protected int poolPingConnectionsNotUsedFor;
// 根据数据库的URL、用户名和密码生成的一个hash值，该哈希值用于标志着当前的连接池，在构造函数中初始化
private int expectedConnectionTypeCode;

private PooledConnection popConnection(String username, String password) throws SQLException {
    boolean countedWait = false;
    PooledConnection conn = null;
    long t = System.currentTimeMillis();
    int localBadConnectionCount = 0;

    while (conn == null) {
        lock.lock();
        try {
            if (!state.idleConnections.isEmpty()) {   // 检测空闲连接
                conn = state.idleConnections.remove(0);   // 获取连接
            } else if (state.activeConnections.size() < poolMaximumActiveConnections) { 
                // 活跃连接数没有达到最大值，则可以创建新连接
                // 创建新连接，并封装成PooledConnection对象
                conn = new PooledConnection(dataSource.getConnection(), this);
            } else { // 活跃连接数已经到最大值，则不能创建新连接
                // 获取最先创建的活跃连接
                PooledConnection oldestActiveConnection = state.activeConnections.get(0);
                long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
                if (longestCheckoutTime > poolMaximumCheckoutTime) {    // 检测该连接是否超时
                    // 对超时连接的信息进行统计
                    state.claimedOverdueConnectionCount++;
                    state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
                    state.accumulatedCheckoutTime += longestCheckoutTime;
                    // 将超时连接移除activeConnections集合
                    state.activeConnections.remove(oldestActiveConnection);
                    // 如果超时连接未提交，则自动回滚
                    if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
                        try {
                            oldestActiveConnection.getRealConnection().rollback();
                        } catch (SQLException e) {
                            log.debug("Bad connection. Could not roll back");
                        }
                    }
                    // 创建新的PooledConnection对象，但是真正的数据库连接并没有创建新的，还是之前的连接
                    conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
                    conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
                    conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
                    // 将超时的连接设置为无效
                    oldestActiveConnection.invalidate();
                } else {  // 无空闲连接，无法创建新连接，并且没有超时连接，只能阻塞等待
                    try {
                        if (!countedWait) {
                            state.hadToWaitCount++;   // 统计等待次数
                            countedWait = true;
                        }
                        long wt = System.currentTimeMillis();
                        if (!condition.await(poolTimeToWait, TimeUnit.MILLISECONDS)) {  // 阻塞等待
                            log.debug("Wait failed...");
                        }
                        state.accumulatedWaitTime += System.currentTimeMillis() - wt; // 统计等待时间
                    } catch (InterruptedException e) {
                        // set interrupt flag
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
            if (conn != null) {
                if (conn.isValid()) {   // 检测PooledConnection是否有效
                    if (!conn.getRealConnection().getAutoCommit()) {
                        conn.getRealConnection().rollback();
                    }
                    // 配置PooledConnection的相关属性
                    conn.setConnectionTypeCode(assembleConnectionTypeCode(
                        dataSource.getUrl(), username, password));
                    conn.setCheckoutTimestamp(System.currentTimeMillis());
                    conn.setLastUsedTimestamp(System.currentTimeMillis());
                    state.activeConnections.add(conn);    // 进行相关统计
                    state.requestCount++;
                    state.accumulatedRequestTime += System.currentTimeMillis() - t;
                } else {
                    state.badConnectionCount++;
                    localBadConnectionCount++;
                    conn = null;
                    if (localBadConnectionCount > 
                        poolMaximumIdleConnections + poolMaximumLocalBadConnectionTolerance) {
                        throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
                    }
                }
            }
        } finally {
            lock.unlock();
        }

    }

    if (conn == null) {
        throw new SQLException(
            "PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
    }

    return conn;
}

protected void pushConnection(PooledConnection conn) throws SQLException {

    lock.lock();
    try {
        // 从activeConnections移除该PooledConnection对象
        state.activeConnections.remove(conn);
        if (conn.isValid()) {   // 检测PooledConnection对象是否有效
            // 检测空闲连接数是否已经到达上限，以及PooledConnection是否为该连接池的连接
            if (state.idleConnections.size() < poolMaximumIdleConnections
                && conn.getConnectionTypeCode() == expectedConnectionTypeCode) {
                state.accumulatedCheckoutTime += conn.getCheckoutTime();  // 累计checkout时长
                if (!conn.getRealConnection().getAutoCommit()) {    // 回滚未提交的事物
                    conn.getRealConnection().rollback();
                }
                // 为返还创建新的PooledConnection对象
                PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
                state.idleConnections.add(newConn);   // 添加到idleConnections集合
                newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
                newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
                conn.invalidate();    // 将原先对象设置为无效
                condition.signal();   // 唤醒阻塞等待线程
            } else {    // 空闲连接数到达上限或者不属于该连接池
                state.accumulatedCheckoutTime += conn.getCheckoutTime(); // 累计checkout时长
                if (!conn.getRealConnection().getAutoCommit()) {
                    conn.getRealConnection().rollback();
                }
                conn.getRealConnection().close();   // 关闭真正的数据库连接
                conn.invalidate();    // 将原先对象设置为无效
            }
        } else {
            state.badConnectionCount++;   // 统计无效PooledConnection的个数
        }
    } finally {
        lock.unlock();
    }
}

public boolean isValid() {
    return valid && realConnection != null && dataSource.pingConnection(this);
}

protected boolean pingConnection(PooledConnection conn) {
    boolean result;   // 记录ping操作是否成功

    try {
        result = !conn.getRealConnection().isClosed();  // 真正的数据库连接是否已经关闭
    } catch (SQLException e) {
        result = false;
    }

    // 如果poolPingEnabled设置为false则不执行SQL语句
    // 长时间（超过poolPingConnectionsNotUsedFor指定的时长）未使用的连接，才需要使用ping操作
    // 来检测数据库连接是否正常
    if (result && poolPingEnabled && poolPingConnectionsNotUsedFor >= 0
        && conn.getTimeElapsedSinceLastUse() > poolPingConnectionsNotUsedFor) {
        try {
            // 执行SQL语句的JDBC操作
            Connection realConn = conn.getRealConnection();
            try (Statement statement = realConn.createStatement()) {
                statement.executeQuery(poolPingQuery).close();
            }
            if (!realConn.getAutoCommit()) {
                realConn.rollback();
            }
        } catch (Exception e) {
            conn.getRealConnection().close();
            result = false;
        }
    }
    return result;
}

public void forceCloseAll() {
    lock.lock();
    try {
        // 更新当前连接池的标识
        expectedConnectionTypeCode = assembleConnectionTypeCode(
            dataSource.getUrl(), dataSource.getUsername(), dataSource.getPassword());
        for (int i = state.activeConnections.size(); i > 0; i--) { // 处理全部的活跃连接
            try {
                // 从activeConnections中获取PooledConnection对象
                PooledConnection conn = state.activeConnections.remove(i - 1);
                conn.invalidate();    // 将PooledConnection对象设置未无效

                Connection realConn = conn.getRealConnection();   // 获取真正的数据库连接对象
                if (!realConn.getAutoCommit()) {  // 回滚未提交的事物
                    realConn.rollback();
                }
                realConn.close();   // 关闭真正的数据库连接
            } catch (Exception e) {
                // ignore
            }
        }
        // 同样的逻辑处理空闲的连接
        for (int i = state.idleConnections.size(); i > 0; i--) {
            // ...
        }
    } finally {
        lock.unlock();
    }
}

public interface Transaction {

  // 获取对应的数据库连接对象
  Connection getConnection() throws SQLException;

  // 提交事物
  void commit() throws SQLException;

  // 回滚事物
  void rollback() throws SQLException;

  // 关闭数据库连接
  void close() throws SQLException;

  // 获取事物超时时间
  Integer getTimeout() throws SQLException;

}

protected Connection connection;    // 事务对应的数据库连接
protected DataSource dataSource;    // 数据库连接所属的DataSource
protected TransactionIsolationLevel level;    // 事务隔离级别
protected boolean autoCommit;     // 是否自动提交

public interface TransactionFactory {

  // 配置TransactionFactory 一般紧跟在创建完成之后，完成对TransactionFactory的自定义配置
  default void setProperties(Properties props) {
    // NOP
  }

  // 在指定的连接上创建Transaction对象
  Transaction newTransaction(Connection conn);

  // 从指定数据源中获取数据库连接，并在此连接之上创建Transaction对象
  Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit);

}

// Configuration对象，Mybatis全局唯一配置对象，其中包含了所有的配置信息
private final Configuration config;
// 记录了Mapper接口与对应MapperProxyFactory之间的关系
private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new ConcurrentHashMap<>();

public <T> void addMapper(Class<T> type) {
    if (type.isInterface()) {   // type是否为接口
        if (hasMapper(type)) {    // 是否已经加载过该接口
            throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
        }
        boolean loadCompleted = false;
        try {
            // 将mapper接口对应的class对象和MapperProxyFactory对象添加到knownMappers集合
            knownMappers.put(type, new MapperProxyFactory<>(type));
            // XML解析和注解的处理
            MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
            parser.parse();
            loadCompleted = true;
        } finally {
            if (!loadCompleted) {
                knownMappers.remove(type);
            }
        }
    }
}

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    // 查找指定type对应的MapperProxyFactory对象
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
        throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
        // 创建实现了type接口的代理对象
        return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
        throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
}

public class MapperProxyFactory<T> {

  // 当前MapperProxyFactory对象可以创建实现了mapperInterface接口的代理对象
  private final Class<T> mapperInterface;
  // 缓存，key是mapperInterface接口中某方法对应的Method对象，value是对应的MapperMethodInvoker对象
  private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap<>();
    
  protected T newInstance(MapperProxy<T> mapperProxy) {
    // 创建实现了mapperInterface接口的代理对象
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    // 创建MapperProxy对象，每次调用都会创建新的MapperProxy对象
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }
}

public class MapperProxy<T> implements InvocationHandler, Serializable { 
  // 记录了关联的SqlSession对象
  private final SqlSession sqlSession;
  // mapper接口对应的class对象
  private final Class<T> mapperInterface;
  // 缓存，key是mapper接口中某方法对应的Method对象，value是对应的MapperMethod对象
  // MapperMethod对象会完成参数转换以及SQL语句的执行功能
  // MapperMethod并不记录任何状态相关的信息，因此可以在多个代理对象见共享
  private final Map<Method, MapperMethodInvoker> methodCache
      
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      // 如果目标方法继承自Object，则之间调用目标方法
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      }
      // 从缓存中获取MapperMethodInvoker对象，如果缓存中没有，则创建新的MapperMethodInvoker对象添加到缓存中
      // 然后调用invoke方法
      return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }
  
  // 上面提到的MapperMethodInvoker对象
  interface MapperMethodInvoker {
    Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable;
  }
   
  // MapperMethodInvoker对象的一个实现类
  private static class PlainMethodInvoker implements MapperMethodInvoker {
    private final MapperMethod mapperMethod;

    public PlainMethodInvoker(MapperMethod mapperMethod) {
      this.mapperMethod = mapperMethod;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) 
        throws Throwable {
      // 调用MapperMethod.execute方法执行SQL语句
      return mapperMethod.execute(sqlSession, args);
    }
  }
}

// 记录了SQL语句的名称与类型
private final SqlCommand command;
// Mapper接口中对应的方法的相关信息
private final MethodSignature method;

public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
    final String methodName = method.getName();
    final Class<?> declaringClass = method.getDeclaringClass();
    // 获得MappedStatement对象
    MappedStatement ms = resolveMappedStatement(mapperInterface, 
                                                methodName, declaringClass, configuration);
    if (ms == null) {
        if (method.getAnnotation(Flush.class) == null) {    // 处理@Flush注解
            throw new BindingException(
                "Invalid bound statement (not found): " + mapperInterface.getName() + "." + methodName);
        }
        name = null;
        type = SqlCommandType.FLUSH;
    } else {    // 初始花花name和type
        name = ms.getId();
        type = ms.getSqlCommandType();
        if (type == SqlCommandType.UNKNOWN) {
            throw new BindingException("Unknown execution method for: " + name);
        }
    }
}

private MappedStatement resolveMappedStatement(Class<?> mapperInterface, String methodName, 
                                               Class<?> declaringClass,
                                               Configuration configuration) {
    // SQL语句的名称是由Mapper接口的名称与对应的方法名称组成的
    String statementId = mapperInterface.getName() + "." + methodName;
    if (configuration.hasStatement(statementId)) {    // 检测是否有该名称的SQL语句
        // 从configuration.mappedStatements集合中查找对应的MappedStatement对象
        // MappedStatement对象中封装了SQL语句相关的信息，在Mybatis初始化的时候创建
        return configuration.getMappedStatement(statementId);
    }
    if (mapperInterface.equals(declaringClass)) {
        return null;
    }
    // 如果方法的在父接口中定义的，递归查找
    for (Class<?> superInterface : mapperInterface.getInterfaces()) {
        if (declaringClass.isAssignableFrom(superInterface)) {
            MappedStatement ms = resolveMappedStatement(superInterface, 
                                                        methodName, declaringClass, configuration);
            if (ms != null) {
                return ms;
            }
        }
    }
    return null;
}

public ParamNameResolver(Configuration config, Method method) {
    this.useActualParamName = config.isUseActualParamName();
    // 获取参数列表中每个参数的类型
    final Class<?>[] paramTypes = method.getParameterTypes();
    // 获取参数列表上的注解
    final Annotation[][] paramAnnotations = method.getParameterAnnotations();
    // 该集合用于记录参数索引与参数名称的对应关系
    final SortedMap<Integer, String> map = new TreeMap<>();
    int paramCount = paramAnnotations.length;
    for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {   // 遍历方法所有参数
        if (isSpecialParameter(paramTypes[paramIndex])) {   // 如果参数类型是RowBounds类型或ResultHandler类型
            continue;
        }
        String name = null;
        for (Annotation annotation : paramAnnotations[paramIndex]) {    // 遍历参数对应的注解集合
            if (annotation instanceof Param) {    // @Param注解出现过
                hasParamAnnotation = true;    // 将hasParamAnnotation设置成true
                name = ((Param) annotation).value();    // 获取@Param注解指定的名称
                break;
            }
        }
        if (name == null) {   // 该参数没有对应的@Param注解
            if (useActualParamName) {   // 根据配置决定是否使用参数实际名称作为其名称
                name = getActualParamName(method, paramIndex);
            }
            if (name == null) {   // 使用参数的索引作为其名称
                name = String.valueOf(map.size());
            }
        }
        map.put(paramIndex, name);    // 记录到MAP中保存
    }
    names = Collections.unmodifiableSortedMap(map);   // 初始化names集合
}

private static boolean isSpecialParameter(Class<?> clazz) {
    return RowBounds.class.isAssignableFrom(clazz) || ResultHandler.class.isAssignableFrom(clazz);
}

public Object getNamedParams(Object[] args) {
    final int paramCount = names.size();
    if (args == null || paramCount == 0) {    // 无参数，返回null
        return null;
    }
    if (!hasParamAnnotation && paramCount == 1) {   // 未使用@Param且只有一个参数
        Object value = args[names.firstKey()];
        return wrapToMapIfCollection(value, useActualParamName ? names.get(names.firstKey()) : null);
    } else {
        // param这个Map记录了参数名称与实参之间的对应关系。ParamMap继承了HashMap
        // 如果向ParamMap添加已经存在的key，会报错，其他与HashMap相同
        final Map<String, Object> param = new ParamMap<>();
        int i = 0;
        for (Map.Entry<Integer, String> entry : names.entrySet()) {
            // 将参数名与实参对应关系记录到param中
            param.put(entry.getValue(), args[entry.getKey()]);
            // 为参数创建"param + 索引"格式的默认参数名称, 如param1，param2等等 
            final String genericParamName = GENERIC_NAME_PREFIX + (i + 1);
            // 如果@Param注解指定的参数名称就是"param + 索引"格式的, 就不用再添加了
            if (!names.containsValue(genericParamName)) {   
                param.put(genericParamName, args[entry.getKey()]);  // 添加@Param指定的格式
            }
            i++;
        }
        return param;
    }
}

private final boolean returnsMany;    // 返回值是否为Collection类型或者是数组类型
private final boolean returnsMap;     // 返回值是否为Map类型
private final boolean returnsVoid;    // 返回值类型是否为void
private final boolean returnsCursor;    // 返回值类型是否为Cursor类型
private final Class<?> returnType;    // 返回值类型
private final String mapKey;      // 如果返回值类型是Map，则该字段记录了作为key的列明
private final Integer resultHandlerIndex;   // 用来标记该方法中参数列表中ResultHandler类型参数的位置
private final Integer rowBoundsIndex;   // 用来标记该方法中参数列表中RowBounds类型参数的位置
private final ParamNameResolver paramNameResolver;    // 方法对应的ParamNameResolver对象

public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) {
    // 解析放回值的方法类型，TypeParameterResolver可以看2.2.2
    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
    if (resolvedReturnType instanceof Class<?>) {
        this.returnType = (Class<?>) resolvedReturnType;
    } else if (resolvedReturnType instanceof ParameterizedType) {
        this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType();
    } else {
        this.returnType = method.getReturnType();
    }
    // 初始化returnsXXX字段
    this.returnsVoid = void.class.equals(this.returnType);
    this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) 
        || this.returnType.isArray();
    this.returnsCursor = Cursor.class.equals(this.returnType);
    this.returnsOptional = Optional.class.equals(this.returnType);
    // 若MethodSignature对应方法的返回值是Map且指定了@MapKey注解，则使用getMapKey方法进行处理
    this.mapKey = getMapKey(method);
    this.returnsMap = this.mapKey != null;
    // 初始化rowBoundsIndex和resultHandlerIndex字段
    this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
    this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
    // 创建ParamNameResolver对象
    this.paramNameResolver = new ParamNameResolver(configuration, method);
}

private Integer getUniqueParamIndex(Method method, Class<?> paramType) {
    Integer index = null;
    final Class<?>[] argTypes = method.getParameterTypes();
    for (int i = 0; i < argTypes.length; i++) {   // 遍历MethodSignature对应方法的参数列表
        if (paramType.isAssignableFrom(argTypes[i])) {
            if (index != null) {  // RowBounds和ResultHandler类型的参数只能有一个，不能重复出现
                throw new BindingException(
                    method.getName() + " cannot have multiple " + 
                    paramType.getSimpleName() + " parameters");
            }
            index = i;    // 记录paramType类型参数在参数列表中的位置索引
        }
    }
    return index;
}

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    switch (command.getType()) {    // 根据SQL语句的类型调用SQLSession对应的方法
        case INSERT: {
            // 使用ParamNameResolver处理args[]数组，将用户传入的实参列表与指定参数名称关联起来
            Object param = method.convertArgsToSqlCommandParam(args);
            // 调用SQLSession的insert方法，rowCountResult会根据method字段中记录的方法的返回值类型对结果进行转换
            result = rowCountResult(sqlSession.insert(command.getName(), param));
            break;
        }
        // UPDATE和DELETE与insert类似
        case UPDATE: {
            // ...
        }
        case DELETE: {
            // ...
        }
        case SELECT:
            // 处理返回值类型为void缺ResultSet通过ResultHandler处理的方法
            if (method.returnsVoid() && method.hasResultHandler()) {
                executeWithResultHandler(sqlSession, args);
                result = null;
            } else if (method.returnsMany()) {  // 处理返回值为集合或数组
                result = executeForMany(sqlSession, args);
            } else if (method.returnsMap()) { // 处理返回值为map
                result = executeForMap(sqlSession, args);
            } else if (method.returnsCursor()) {  // 处理返回值为Cursor
                result = executeForCursor(sqlSession, args);
            } else {    // 处理单一对象返回值
                Object param = method.convertArgsToSqlCommandParam(args);
                result = sqlSession.selectOne(command.getName(), param);
                if (method.returnsOptional() && (result == null || 
                                                 !method.getReturnType().equals(result.getClass()))) {
                    result = Optional.ofNullable(result);
                }
            }
            break;
        case FLUSH:
            result = sqlSession.flushStatements();
            break;
        default:
            throw new BindingException("Unknown execution method for: " + command.getName());
    }
    // ... 边界检查
    return result;
}

 private Object rowCountResult(int rowCount) {
     final Object result;
     if (method.returnsVoid()) {
         result = null;       // 返回值为void
     } else if (Integer.class.equals(method.getReturnType()) || 
                Integer.TYPE.equals(method.getReturnType())) {
         result = rowCount;       // 返回值为int或者Integer
     } else if (Long.class.equals(method.getReturnType()) || 
                Long.TYPE.equals(method.getReturnType())) {
         result = (long) rowCount;      // 返回值为long或者Long
     } else if (Boolean.class.equals(method.getReturnType()) || 
                Boolean.TYPE.equals(method.getReturnType())) {
         result = rowCount > 0;      // 返回值为Boolean
     } else {
         throw new BindingException("...");
     }
     return result;
 }

private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
    // 获取SQL语句对应的MappedStatement对象,MappedStatement中记录了SQL语句的相关信息
    MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
    // 当使用ResultHandler处理结果集时，必须指定ResultMap或者ResultType
    if (!StatementType.CALLABLE.equals(ms.getStatementType())
        && void.class.equals(ms.getResultMaps().get(0).getType())) {
        throw new BindingException("...");
    }
    // 转换实参列表
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {    // 参数中是否有RowBounds类型的参数
        // 获取RowBound是对象，根据MethodSignature.rowBoundsIndex字段指定位置，从args数组中查找
        RowBounds rowBounds = method.extractRowBounds(args);
        // 调用SQLSession的select方法，执行查询，并由指定的ResultHandler处理结果对象
        sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
    } else {
        sqlSession.select(command.getName(), param, method.extractResultHandler(args));
    }
}

 private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
     List<E> result;
     Object param = method.convertArgsToSqlCommandParam(args);   // 参数列表转换
     if (method.hasRowBounds()) {    // 检测是否指定了RowBounds参数
         RowBounds rowBounds = method.extractRowBounds(args);
         // 调用SQLSession.selectList方法进行查询
         result = sqlSession.selectList(command.getName(), param, rowBounds);
     } else {
         result = sqlSession.selectList(command.getName(), param);
     }
     // 将结果集转换为数组或者Collection集合
     // 实现与上面rowCountResult基本相似
     if (!method.getReturnType().isAssignableFrom(result.getClass())) {
         if (method.getReturnType().isArray()) {
             return convertToArray(result);
         }
         return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
     }
     return result;
 }

private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) {
    Map<K, V> result;
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
        RowBounds rowBounds = method.extractRowBounds(args);
        result = sqlSession.selectMap(command.getName(), param, method.getMapKey(), rowBounds);
    } else {
        result = sqlSession.selectMap(command.getName(), param, method.getMapKey());
    }
    return result;
}

public interface Cache {

  // 该缓存对象的ID
  String getId();

  // 向缓存中添加数据，一般情况下，key是cachekey， value是查询的结果
  void putObject(Object key, Object value);

  // 根据指定的key，在缓存中查找对应的结果对象
  Object getObject(Object key);

  // 删除key对应的缓存项
  Object removeObject(Object key);

 // 清空缓存
  void clear();

  // 缓存项的个数，该方法不会被核心代码使用，所以可提供空实现
  int getSize();

  // 获取读写所，该方法不会被核心代码使用，所以可提供空实现
  default ReadWriteLock getReadWriteLock() {
    return null;
  }

}

public class PerpetualCache implements Cache {

  // Cache对象的唯一标识
  private final String id;

  // 用于记录缓存的Map对象
  private final Map<Object, Object> cache = new HashMap<>();

  public PerpetualCache(String id) {
    this.id = id;
  }

  @Override
  public String getId() {
    return id;
  }

  @Override
  public int getSize() {
    return cache.size();
  }

  @Override
  public void putObject(Object key, Object value) {
    cache.put(key, value);
  }

  @Override
  public Object getObject(Object key) {
    return cache.get(key);
  }

  @Override
  public Object removeObject(Object key) {
    return cache.remove(key);
  }

  @Override
  public void clear() {
    cache.clear();
  }

}

// 阻塞超时时长
private long timeout;
// 被装饰的底层Cache对象
private final Cache delegate;
// 每个Key都有一个对应的CountDownLatch对象
private final ConcurrentHashMap<Object, CountDownLatch> locks;

@Override
public Object getObject(Object key) {
    acquireLock(key);   // 获取该key对应的锁
    Object value = delegate.getObject(key);   // 查询key
    if (value != null) {  // 缓存有key的对应缓存项，释放锁，否则继续持有锁
        releaseLock(key);
    }
    return value;
}

private void acquireLock(Object key) {
    CountDownLatch newLatch = new CountDownLatch(1);
    while (true) {
        CountDownLatch latch = locks.putIfAbsent(key, newLatch);    // 想要获取锁
        if (latch == null) {    // key不在hashmap存在，表明没有任何人持有锁，而且自己的锁也放到map中去了，溜了
            break;
        }
        // 这个时候latch就是上一个人的锁
        try {
            if (timeout > 0) {  // 没超时，等待
                boolean acquired = latch.await(timeout, TimeUnit.MILLISECONDS);
                if (!acquired) {    // 超时，抛出移除
                    throw new CacheException("...");
                }
            } else {
                latch.await();    // 等着
            }
        } catch (InterruptedException e) {
            throw new CacheException("...");
        }
    }
}

@Override
public void putObject(Object key, Object value) {
    try {
        delegate.putObject(key, value); // 向缓存中添加缓存项
    } finally {
        releaseLock(key); // 释放锁
    }
}

private void releaseLock(Object key) {
    CountDownLatch latch = locks.remove(key);   // 删除map中的key
    if (latch == null) {			// 那我之前放到map中的值呢？？
        throw new IllegalStateException("...");
    }
    latch.countDown();    // 释放锁
}

// 底层被装饰的底层Cache对象
private final Cache delegate;
// 用于记录Key进入缓存的先后顺序，使用的是LinkedList对象
private final Deque<Object> keyList;
// 缓存项的上限，超过该值，则需要清理最老的缓存项
private int size;

@Override
public void putObject(Object key, Object value) {
    cycleKeyList(key);    // 检测并清理缓存
    delegate.putObject(key, value);   // 添加缓存项
}

private void cycleKeyList(Object key) {
    keyList.addLast(key);   // 记录key
    if (keyList.size() > size) {    // 如果到达上限，清理最老的缓存项
        Object oldestKey = keyList.removeFirst();
        delegate.removeObject(oldestKey);
    }
}

// 底层被装饰的底层Cache对象
private final Cache delegate;
// LinkedHashMap类型的对象，是一个有序的HashMap，用于记录key最近的使用清空
private Map<Object, Object> keyMap;
// 记录最少被使用的缓存项key
private Object eldestKey;

public void setSize(final int size) {
    // 第三个参数为true表明记录的顺序是access-order，调用get方法会改变其记录的顺序
    keyMap = new LinkedHashMap<>(size, .75F, true) 
        @Override
        // 当调用LinkedHashMap的put方法时，会调用该方法
        protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
            boolean tooBig = size() > size;
            if (tooBig) {   // 如果到达缓存上限，则更新eldestKey字段，后面会删除该项
                eldestKey = eldest.getKey();
            }
            return tooBig;
        }
    };
}

@Override
public Object getObject(Object key) {
    keyMap.get(key); // 修改LinkedHashMap中记录的顺序
    return delegate.getObject(key);
}

@Override
public void putObject(Object key, Object value) {
    delegate.putObject(key, value);   // 添加缓存项
    cycleKeyList(key);    // 删除最久未使用的缓存项
}

private void cycleKeyList(Object key) {
    keyMap.put(key, key);
    if (eldestKey != null) {
        delegate.removeObject(eldestKey);
        eldestKey = null;
    }
}

//在SoftCache中，最近使用的一部分缓存项不会被GC回收，这就是通过将其value添加到
// hardLinksToAvoidGarbageCollection集合中实现的（即有强引用指向其value）
private final Deque<Object> hardLinksToAvoidGarbageCollection;
// 引用队列，用于记录已经被GC回收的缓存项所对应的SoftEntry对象
private final ReferenceQueue<Object> queueOfGarbageCollectedEntries;
// 底层被装饰的底层Cache对象
private final Cache delegate;
// 强连接的个数，默认值是256
private int numberOfHardLinks;

private static class SoftEntry extends SoftReference<Object> {
  private final Object key;

  SoftEntry(Object key, Object value, ReferenceQueue<Object> garbageCollectionQueue) {
    super(value, garbageCollectionQueue);   // 指向value的引用是软引用，且关联了引用队列
    this.key = key;   // 强引用
  }
}

@Override
public void putObject(Object key, Object value) {
    removeGarbageCollectedItems();    // 清除已经被GC回收的缓存项
    delegate.putObject(key, new SoftEntry(key, value, queueOfGarbageCollectedEntries)); // 项缓存中添加缓存项
}

private void removeGarbageCollectedItems() {
    SoftEntry sv;
    while ((sv = (SoftEntry) queueOfGarbageCollectedEntries.poll()) != null) {
        // 遍历queueOfGarbageCollectedEntries集合
        // 将已经被GC回收的value对象对应的缓存项清除
        delegate.removeObject(sv.key);
    }
}

@Override
public Object getObject(Object key) {
    Object result = null;
    @SuppressWarnings("unchecked")
    // 从缓存中查找对应的缓存项
    SoftReference<Object> softReference = (SoftReference<Object>) delegate.getObject(key);
    if (softReference != null) {  // 检测缓存中是否有对应缓存项
        result = softReference.get();   // 获取SoftReference引用的value
        if (result == null) {   // 已经被GC回收
            delegate.removeObject(key); // 从缓存中清除对应的缓存项
        } else { // 未被GC回收
            synchronized (hardLinksToAvoidGarbageCollection) {
                // 缓存项的value添加到hardLinksToAvoidGarbageCollection集合中保存
                hardLinksToAvoidGarbageCollection.addFirst(result);
                if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {
                    // 超过numberOfHardLinks，使用先进先出清除最老的缓存项
                    hardLinksToAvoidGarbageCollection.removeLast();
                }
            }
        }
    }
    return result;
}

// 参与计算hashcode，默认是37
private final int multiplier;
// 初始hashcode，初始值是17
private int hashcode;
// 校验和
private long checksum;
// updateList集合的个数
private int count;
// 由该集合中的所有对象共同决定两个CacheKey是否相同
private List<Object> updateList;

public void update(Object object) {
    int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);

    // 重新计算count，hashcode，checksum的值
    count++;
    checksum += baseHashCode;
    baseHashCode *= count;

    hashcode = multiplier * hashcode + baseHashCode;

    updateList.add(object);
}

@Override
public boolean equals(Object object) {
    if (this == object) {   // 是否是同一对象
        return true;
    }
    if (!(object instanceof CacheKey)) {  // 是否类型相同
        return false;
    }

    final CacheKey cacheKey = (CacheKey) object;

    if ((hashcode != cacheKey.hashcode) || (checksum != cacheKey.checksum) || (count != cacheKey.count)) { 
        // 比较三个数字
        return false;
    }

    // 比较updateList每一项
    for (int i = 0; i < updateList.size(); i++) {
        Object thisObject = updateList.get(i);
        Object thatObject = cacheKey.updateList.get(i);
        if (!ArrayUtil.equals(thisObject, thatObject)) {
            return false;
        }
    }
    return true;
}

@Override
public int hashCode() {
    return hashcode;
}

public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
        // 读取配置文件
        XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
        // 解析配置文件得到Configuration对象，创建DefaultSqlSessionFactory对象
        return build(parser.parse());
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
        ErrorContext.instance().reset();
        try {
            if (reader != null) {
                reader.close();
            }
        } catch (IOException e) {
            // Intentionally ignore. Prefer previous error.
        }
    }
}

// Configuration是Mybatis初始化过程的核心对象，Mybatis中几乎所有配置信息都会保存
// 到Configuration对象中。Configuration对象是在Mybatis初始化过程中创建且全局唯一
protected final Configuration configuration;
// 在mybatis-config.xml配置文件中可以使用typeAliases标签定义别名，这些定义的别名都会保存
// 在TypeAliasRegistry中，这个类可以见2.3.3
protected final TypeAliasRegistry typeAliasRegistry;
// 在mybatis-config.xml配置文件中可以使用typeRegistry标签定义TypeHandler
// 完成指定数据库类型和Java类型的转换，这些TypeHandler都会记录在TypeHandlerRegistry中
// 这个类可以见2.3.2
protected final TypeHandlerRegistry typeHandlerRegistry;

// 标记是否解析过mybatis-config.xml配置文件
private boolean parsed;
// 用于解析mybatis-config.xml配置文件的XPathParser对象，可以见2.1
private final XPathParser parser;
// 标识environment配置的名称，默认读取default属性
private String environment;
// ReflectorFactory负责创建和缓存Reflector对象，可以见2.2.1
private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();

public Configuration parse() {
    if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    // 在mybatis-config.xml中查找configuration节点，并开始解析
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

private void parseConfiguration(XNode root) {
    try {
        // 解析各个节点
        propertiesElement(root.evalNode("properties"));
        Properties settings = settingsAsProperties(root.evalNode("settings"));
        loadCustomVfsImpl(settings);
        loadCustomLogImpl(settings);
        typeAliasesElement(root.evalNode("typeAliases"));
        pluginsElement(root.evalNode("plugins"));
        objectFactoryElement(root.evalNode("objectFactory"));
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        settingsElement(settings);    // 将settings值设置到Configuration中
        // read it after objectFactory and objectWrapperFactory issue #631
        environmentsElement(root.evalNode("environments"));
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        typeHandlersElement(root.evalNode("typeHandlers"));
        mappersElement(root.evalNode("mappers"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

private void propertiesElement(XNode context) throws Exception {
    if (context == null) {
        return;
    }
    // 解析properties子节点(property)的name和value属性，并记录到properties中
    Properties defaults = context.getChildrenAsProperties();
    // 解析properties的resource和url属性，用于确定properties配置文件的位置
    String resource = context.getStringAttribute("resource");
    String url = context.getStringAttribute("url");
    // 不能同时存在，否则会抛出异常
    if (resource != null && url != null) {
        throw new BuilderException("...");
    }
    // 加载resource属性或者url属性指定的properties文件
    if (resource != null) {
        defaults.putAll(Resources.getResourceAsProperties(resource));
    } else if (url != null) {
        defaults.putAll(Resources.getUrlAsProperties(url));
    }
    // 与Configuration文件中的匹variables集合合并
    Properties vars = configuration.getVariables();
    if (vars != null) {
        defaults.putAll(vars);
    }
    // 更新XPathParser和Configuration的variables字段
    parser.setVariables(defaults);
    configuration.setVariables(defaults);
}

private Properties settingsAsProperties(XNode context) {
    if (context == null) {
        return new Properties();
    }
    // 解析settings子节点(setting)的name和value属性，并记录到properties中
    Properties props = context.getChildrenAsProperties();
    // 创建Configuration对应的MetaClass对象
    MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
    for (Object key : props.keySet()) {
        // Configuration是否定义了key属性相应的Setter方法
        if (!metaConfig.hasSetter(String.valueOf(key))) {
            throw new BuilderException( "...");
        }
    }
    return props;
}

private void typeAliasesElement(XNode context) {
    if (context == null) {
        return;
    }
    for (XNode child : context.getChildren()) {   // 处理全部子节点
        if ("package".equals(child.getName())) {    // 处理package节点
            // 获取指定的包名
            String typeAliasPackage = child.getStringAttribute("name");
            // 通过TypeAliasRegistry扫描指定包中的所有的类，并解析@Alias注解，完成别名注册
            configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
        } else {    // 处理typeAlias节点
            String alias = child.getStringAttribute("alias");   // 获取指定的别名
            String type = child.getStringAttribute("type");   // 获取别名对应的类型
            try {
                Class<?> clazz = Resources.classForName(type);
                if (alias == null) {
                    typeAliasRegistry.registerAlias(clazz);   // 扫描@Alias注解，完成注册
                } else {
                    typeAliasRegistry.registerAlias(alias, clazz);  // 注册别名
                }
            } catch (ClassNotFoundException e) {
                throw new BuilderException("...");
            }
        }
    }
}

private void pluginsElement(XNode context) throws Exception {
    if (context != null) {
        for (XNode child : context.getChildren()) {     // 遍历全部plugin节点
            // 获取plugin的interceptor属性值
            String interceptor = child.getStringAttribute("interceptor");
            // 获取plugin下properties配置的信息，并封装成Properties对象
            Properties properties = child.getChildrenAsProperties();
            // 通过TypeAliasRegistry解析别名后，实例化Interceptor对象
            Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).getDeclaredConstructor()
                .newInstance();
            // 设置Interceptor属性
            interceptorInstance.setProperties(properties);
            // 记录Interceptor对象
            configuration.addInterceptor(interceptorInstance);
        }
    }
}

private void objectFactoryElement(XNode context) throws Exception {
    if (context != null) {
        // 获取ObjectFactory节点的type属性
        String type = context.getStringAttribute("type");
        // 获取ObjectFactory下properties配置的信息，并封装成Properties对象
        Properties properties = context.getChildrenAsProperties();
        // 通过ObjectFactory解析别名后，实例化ObjectFactory对象
        ObjectFactory factory = (ObjectFactory) resolveClass(type).getDeclaredConstructor().newInstance();
        // 记录自定义ObjectFactory属性，完成初始化的相关操作
        factory.setProperties(properties);
        // 将自定义ObjectFactory对象记录到Configuration对象的ObjectFactory字段中，待后续使用
        configuration.setObjectFactory(factory);
    }
}

private void environmentsElement(XNode context) throws Exception {
    if (context == null) {
        return;
    }
    if (environment == null) {
        // 未指定environment字段，酒使用default属性指定的environment
        environment = context.getStringAttribute("default");
    }
    for (XNode child : context.getChildren()) {
        String id = child.getStringAttribute("id");
        if (isSpecifiedEnvironment(id)) {   // 与XMLConfigBuilder.environment字段匹配
            //  先通过TypeAliasRegistry解析别名后创建TransactionFactory
            TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
            // 创建DataSourceFactory和DataSource
            DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
            DataSource dataSource = dsFactory.getDataSource();
            // 创建Environment对象，封装了上面创建的TransactionFactory以及DataSource
            // 这里使用了Builder模式
            Environment.Builder environmentBuilder = new Environment.Builder(id).transactionFactory(txFactory)
                .dataSource(dataSource);
            configuration.setEnvironment(environmentBuilder.build());
            break;
        }
    }
}

private void databaseIdProviderElement(XNode context) throws Exception {
    if (context == null) {
        return;
    }
    String type = context.getStringAttribute("type");
    // 为了保证兼容性性，修改type取值
    if ("VENDOR".equals(type)) {
        type = "DB_VENDOR";
    }
    Properties properties = context.getChildrenAsProperties();  // 解析相关配置信息
    // 创建DatabaseIdProvider对象
    DatabaseIdProvider databaseIdProvider = (DatabaseIdProvider) resolveClass(type).getDeclaredConstructor()
        .newInstance();
    // 配置DatabaseIdProvider，完成初始化
    databaseIdProvider.setProperties(properties);
    Environment environment = configuration.getEnvironment();
    if (environment != null) {
        // 通过前面确定的DataSource获取databaseID,记录到Configuration的databaseId中
        String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
        configuration.setDatabaseId(databaseId);
    }
}

private String getDatabaseName(DataSource dataSource) throws SQLException {
    // 解析DataSource连接的数据库产品名称
    String productName = getDatabaseProductName(dataSource);
    if (this.properties != null) {
        // 根据databaseIdProvider子结点配置的数据库产品和databaseId之间的对应关系，确定最终使用的databaseId
        return properties.entrySet().stream().filter(entry -> productName.contains((String) entry.getKey()))
            .map(entry -> (String) entry.getValue()).findFirst().orElse(null);
    }
    return productName;
}

private String getDatabaseProductName(DataSource dataSource) throws SQLException {
    try (Connection con = dataSource.getConnection()) {
        return con.getMetaData().getDatabaseProductName();
    }
}

private void mappersElement(XNode context) throws Exception {
    if (context == null) {
        return;
    }
    for (XNode child : context.getChildren()) {
        if ("package".equals(child.getName())) {    // 处理package子结点
            String mapperPackage = child.getStringAttribute("name");
            // 扫描指定包，并想MapperRegistry注册Mapper接口
            configuration.addMappers(mapperPackage);
        } else {
            // 获取mapper结点的resource、url、class属性，这三个属性互斥
            String resource = child.getStringAttribute("resource");
            String url = child.getStringAttribute("url");
            String mapperClass = child.getStringAttribute("class");
            // 如果mapper结点指定了resource或是url属性，啧创建XMLMapperBuilder对象
            // 并通过该对象解析resource或是url指定的Mapper配置文件
            if (resource != null && url == null && mapperClass == null) {
                ErrorContext.instance().resource(resource);
                try (InputStream inputStream = Resources.getResourceAsStream(resource)) {
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource,
                                                                         configuration.getSqlFragments());
                    mapperParser.parse();
                }
            } else if (resource == null && url != null && mapperClass == null) {
                ErrorContext.instance().resource(url);
                try (InputStream inputStream = Resources.getUrlAsStream(url)) {
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url,
                                                                         configuration.getSqlFragments());
                    mapperParser.parse();
                }
            } else if (resource == null && url == null && mapperClass != null) {
                // 如果Mapper结点指定了class属性，则直接注册该Mapper接口
                Class<?> mapperInterface = Resources.classForName(mapperClass);
                configuration.addMapper(mapperInterface);
            } else {
                throw new BuilderException(
                    "A mapper element may only specify a url, resource or class, but not more than one.");
            }
        }
    }
}

public void parse() {
    // 判断是否已经加载过该映射文件
    if (!configuration.isResourceLoaded(resource)) {
        configurationElement(parser.evalNode("/mapper")); // 处理mapper结点
        // 将resource添加到configuration.loadedResource集合中保存, 记录了已经加载过的映射文件
        configuration.addLoadedResource(resource);
        bindMapperForNamespace();   // 注册mapper接口
    }
    // 处理configurationElement方法中解析失败的resultMap节点
    configuration.parsePendingResultMaps(false);
    // 处理configurationElement方法中解析失败的cache-ref节点
    configuration.parsePendingCacheRefs(false);
    // 处理configurationElement方法中解析失败的SQL语句节点
    configuration.parsePendingStatements(false);
}

private void configurationElement(XNode context) {
    try {
        // 获取mapper节点的namespace属性
        String namespace = context.getStringAttribute("namespace");
        if (namespace == null || namespace.isEmpty()) {
            throw new BuilderException("Mapper's namespace cannot be empty");
        }
        // 设置MapperBuilderAssistant.currentNamespace字段，记录命名空间
        builderAssistant.setCurrentNamespace(namespace);
        // 解析每个节点
        cacheRefElement(context.evalNode("cache-ref"));
        cacheElement(context.evalNode("cache"));
        // 这个节点已经废弃了, 不再推荐使用
        parameterMapElement(context.evalNodes("/mapper/parameterMap"));
        resultMapElements(context.evalNodes("/mapper/resultMap"));
        sqlElement(context.evalNodes("/mapper/sql"));
        buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
    }
}

private void cacheElement(XNode context) {
    if (context != null) {
        String type = context.getStringAttribute("type", "PERPETUAL");
        // 通过TypeAliasRegistry查找type属性对应的Cache接口实现
        Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
        String eviction = context.getStringAttribute("eviction", "LRU");
        // 解析eviction属性指定的Cache装饰器类型
        Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
        Long flushInterval = context.getLongAttribute("flushInterval");
        Integer size = context.getIntAttribute("size");
        boolean readWrite = !context.getBooleanAttribute("readOnly", false);
        boolean blocking = context.getBooleanAttribute("blocking", false);
        // 获取cache节点下的子节点，将用于初始化二级缓存
        Properties props = context.getChildrenAsProperties();
        // 通过MapperBuilderAssistant创建Cache对象，并添加到Configuration.cache集合中保存
        builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
    }
}

public V put(String key, V value) {
    if (containsKey(key)) {   // 如果包含了该Key，直接抛异常
        throw new IllegalArgumentException("...");
    }
    if (key.contains(".")) {
        // 按照"."将key切分成数组，并将数组的最后一项作为shortKey
        final String shortKey = getShortName(key);
        if (super.get(shortKey) == null) {
            super.put(shortKey, value);
        } else {
            // 如果该shortKey已经存在，则将value修改为Ambiguity对象
            super.put(shortKey, (V) new Ambiguity(shortKey));
        }
    }
    return super.put(key, value);
}

public V get(Object key) {
      V value = super.get(key);
      if (value == null) {    // 如果key没有对应的value，报错
        throw new IllegalArgumentException(name + " does not contain value for " + key);
      }
      if (value instanceof Ambiguity) {   // 如果value是Ambiguity类型报错
        throw new IllegalArgumentException(((Ambiguity) value).getSubject() + " is ambiguous in " + name
            + " (try using the full name including the namespace, or rename one of the entries)");
      }
      return value;
}

public Cache useNewCache(Class<? extends Cache> typeClass, Class<? extends Cache> evictionClass, Long flushInterval,
      Integer size, boolean readWrite, boolean blocking, Properties props) {
    // 创建Cache，CacheBuilder是建造者
    Cache cache = new CacheBuilder(currentNamespace).implementation(valueOrDefault(typeClass, PerpetualCache.class))
        .addDecorator(valueOrDefault(evictionClass, LruCache.class)).clearInterval(flushInterval).size(size)
        .readWrite(readWrite).blocking(blocking).properties(props).build();
    // 将Cache对象添加到Configuration.caches集合中，其中会将cache的id作为key，cache本身作为value
    configuration.addCache(cache);
    currentCache = cache;   // 记录当前命名空间使用的cache对象
    return cache;
}

private final String id;     // cache对象的唯一标识，一般对应映射文件的namespace
// cache接口的真正实现类，默认值是前面提到的PerpetualCache(2.9.2)
private Class<? extends Cache> implementation;
// 装饰器集合, 默认只包含LruCache.class(2.9.3.2)
private final List<Class<? extends Cache>> decorators;
// cache大小
private Integer size;
// 清理时间周期
private Long clearInterval;
// 是否可读写
private boolean readWrite;
// 其他配置信息
private Properties properties;
// 是否阻塞
private boolean blocking;

public Cache build() {
    // 设置上面提到的默认属性
    setDefaultImplementations();
    // 根据implementation指定的类型，通过反射获取参数类型为String的构造方法
    // 并通过该构造方法创建对应的Cache对象
    Cache cache = newBaseCacheInstance(implementation, id);
    // 根据cache节点下配置的property信息，初始化Cache对象
    setCacheProperties(cache);
    
    // 检测cache对象的类型，如果是PerpetualCache类型，添加decorators集合的装饰器，
    // 如果是自定义cache的实现，则不添加装饰器
    if (PerpetualCache.class.equals(cache.getClass())) {
      for (Class<? extends Cache> decorator : decorators) {
        cache = newCacheDecoratorInstance(decorator, cache);
        setCacheProperties(cache);    // 配置cache对象的属性
      }
      // 添加mybatis中提供的标准装饰器
      cache = setStandardDecorators(cache);
    } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
      // 如果不是LoggingCache的子类，添加LoggingCache的装饰器
      cache = new LoggingCache(cache);
    }
    return cache;
}

private Cache setStandardDecorators(Cache cache) {
    try {
      // 创建Cache对象对应的metaObject对象
      MetaObject metaCache = SystemMetaObject.forObject(cache);
      if (size != null && metaCache.hasSetter("size")) {
        metaCache.setValue("size", size);
      }
      if (clearInterval != null) {    // 检测是否指定了clearInterval字段
        cache = new ScheduledCache(cache);    // 添加ScheduledCache装饰器
        ((ScheduledCache) cache).setClearInterval(clearInterval);
      }
      if (readWrite) {    // 是否只读
        cache = new SerializedCache(cache);   // 添加SerializedCache装饰器
      }
      cache = new LoggingCache(cache);  // 添加LoggingCache和SynchronizedCache装饰器
      cache = new SynchronizedCache(cache);
      if (blocking) { //是否阻塞
        cache = new BlockingCache(cache);
      }
      return cache;
    } catch (Exception e) {
      throw new CacheException("Error building standard cache decorators.  Cause: " + e, e);
    }
}

private void cacheRefElement(XNode context) {
    if (context != null) {
        // 将当前Mapper配置文件的namespace与被引用的Cache所在的namespace之间的对应关系
        // 记录到Configuration.cacheRefMap集合中
        configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
        // 创建CacheRefResolver对象
        CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant,
                                                                 context.getStringAttribute("namespace"));
        try {
            // 解析Cache引用，该估计欧辰主要是设置MapperBuilderAssistant中的currentCache和unresolvedCacheRef字段
            cacheRefResolver.resolveCacheRef();
        } catch (IncompleteElementException e) {
            // 如果解析出现异常, 酒放到incompleteCacheRef，后面再处理
            configuration.addIncompleteCacheRef(cacheRefResolver);
        }
    }
}

public Cache useCacheRef(String namespace) {
    if (namespace == null) {
      throw new BuilderException("cache-ref element requires a namespace attribute.");
    }
    try {
      // 标识为未成功解析Cached引用
      unresolvedCacheRef = true;
      // 获取namespace对应的Cache对象
      Cache cache = configuration.getCache(namespace);
      if (cache == null) {
        throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.");
      }
      // 记录当前命名空间使用的Cache对象
      currentCache = cache;
      // 标识为成功解析了Cache引用
      unresolvedCacheRef = false;
      return cache;
    } catch (IllegalArgumentException e) {
      throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.", e);
    }
}

private Configuration configuration;    // Mybatis的全局配置对象
private String property;    // 与该列进行映射的属性
private String column;  // 从数据库中得到的列名或者是列名的别名
private Class<?> javaType;  // JavaBean的完全限定名，或一个类型别名
private JdbcType jdbcType;  // 进行映射的列的JDBC类型
private TypeHandler<?> typeHandler; // 类型处理器，会覆盖默认的类型处理器
// 对应节点的ResultMap属性，该属性通过id引用了另外一个resultMap节点定义，它负责将结果集的一部分
// 映射成其他关联的结果对象，这样我们就可以通过join进行关联查询，然后直接映射成多个对象
// 并同时设置这些对象的组合关系
private String nestedResultMapId;
// 对应节点的select属性，该属性通过id引用了另一个select节点定义，它会将指定的列的值传入
// select属性指定的select语句中作为参数进行查询
private String nestedQueryId;
private Set<String> notNullColumns; // 对应节点的nonNullColumn属性拆分后的结果
private String columnPrefix;  // 表前缀
private List<ResultFlag> flags; // 处理后的标志，标志共两个：id和constructor
private List<ResultMapping> composites; // column属性拆分后的结果，composites.size > 0 会使column为null
private String resultSet;
private String foreignColumn;
private boolean lazy;   // 是否延迟加载

private Configuration configuration;  // Mybatis全局配置对象

private String id;  // resultMap节点的id属性
private Class<?> type; // resultMap节点的type属性
// 记录除了discriminator节点之外的其他映射关系
private List<ResultMapping> resultMappings;
// 记录了映射关系中带有ID标志的映射关系，列如id节点和constructor节点的idArgs子节点
private List<ResultMapping> idResultMappings;
// 记录了映射关系中带有Constructor标志的映射关系，列入constructor节点所有子元素
private List<ResultMapping> constructorResultMappings;
// 记录了映射关系中不带有Constructor标志的映射关系
private List<ResultMapping> propertyResultMappings;
private Set<String> mappedColumns;  // 记录了所有映射关系中涉及的column属性的集合
private Set<String> mappedProperties;
// 鉴别器，对应discriminator节点
// discriminator相当于一个switch语句，能判断条件，然后返回相应的resultMap
private Discriminator discriminator;
private boolean hasNestedResultMaps;  // 是否含有嵌套的结果映射，如果某个映射关系中存在resultMap属性，为true
private boolean hasNestedQueries;   // 是否含有嵌套查询，如果某个属性映射中存在select属性，为true
private Boolean autoMapping;  //是否开启自动映射

private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings,
                                   Class<?> enclosingType) {
    ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
    // resultType的属性, 表示结果集被映射的java对象
    // getStringAttribute表示从XNode获取第一个参数的值, 如果没有就取第二个参数作为默认值
    String type = resultMapNode.getStringAttribute("type", 
                        resultMapNode.getStringAttribute("ofType",
                        resultMapNode.getStringAttribute("resultType",                                                               resultMapNode.getStringAttribute("javaType"))));
    // 解析type类型
    Class<?> typeClass = resolveClass(type);
    if (typeClass == null) {
        // 获取上一个标签的type
        typeClass = inheritEnclosingType(resultMapNode, enclosingType);
    }
    Discriminator discriminator = null;
    // 该集合用于记录解析的结果
    List<ResultMapping> resultMappings = new ArrayList<>(additionalResultMappings);
    // 处理resultMap的子节点
    List<XNode> resultChildren = resultMapNode.getChildren();
    for (XNode resultChild : resultChildren) {
        if ("constructor".equals(resultChild.getName())) {  // 处理constructor节点
            processConstructorElement(resultChild, typeClass, resultMappings);
        } else if ("discriminator".equals(resultChild.getName())) { // 处理discriminator节点
            discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
        } else {
            // 处理id、result、association、collection节点
            List<ResultFlag> flags = new ArrayList<>();
            if ("id".equals(resultChild.getName())) {
                flags.add(ResultFlag.ID);
            }
            // 创建ResultMapping对象，并添加到resultMapping集合中保存
            resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
        }
    }
    String id = resultMapNode.getStringAttribute("id", resultMapNode.getValueBasedIdentifier());
    String extend = resultMapNode.getStringAttribute("extends");
    Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
    ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, 
                                                                typeClass, extend, discriminator,
                                                                resultMappings, autoMapping);
    try {
        // 创建ResultMap对象，并添加到 Configuration.resultMaps集合中，该集合是StrictMap对象
        return resultMapResolver.resolve();
    } catch (IncompleteElementException e) {
        configuration.addIncompleteResultMap(resultMapResolver);
        throw e;
    }
}

private void sqlElement(List<XNode> list, String requiredDatabaseId) {
    for (XNode context : list) {
        // 获取databaseId属性
        String databaseId = context.getStringAttribute("databaseId");
        // 获取id属性
        String id = context.getStringAttribute("id");
        // id属性加上namespace
        id = builderAssistant.applyCurrentNamespace(id, false);
        // 如果databaseId属性和当前databaseId一致，就添加到sqlFragments中
        // sqlFragment指向了Configuration.sqlFragments集合
        if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) {
            sqlFragments.put(id, context);
        }
    }
}

public interface SqlSource {

  // getBoundSql方法会根据映射文件中的内容或注解描述的SQL语句，以及传入的参数对象，返回可执行的SQL语句
  BoundSql getBoundSql(Object parameterObject);

}

private String resource;    // 节点中的id属性 包括命名空间前缀
private SqlSource sqlSource;  // sqlSource对象，对应一条sql语句
private SqlCommandType sqlCommandType;  // sql语句的类型

public void parseStatementNode() {
    // 获取SQL节点的id属性以及databaseId属性
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");
    // 判断是否匹配当前数据库， 若不匹配则不加载当前SQL节点
    // 若存在相同id且数据库databaseId属性值不为空，则不再加载当前SQL节点
    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
      return;
    }

    // 根据SQL节点的名称决定SQL语句的类型
    String nodeName = context.getNode().getNodeName();
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    boolean useCache = context.getBooleanAttribute("useCache", isSelect);
    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

    // 处理其中的include属性
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    includeParser.applyIncludes(context.getNode());
    
    // 后面核心的内容后面再说
}

public void applyIncludes(Node source) {
    // 获取mybatis-config.xml中properties节点下定义的变量集合
    Properties variablesContext = new Properties();
    Properties configurationVariables = configuration.getVariables();
    Optional.ofNullable(configurationVariables).ifPresent(variablesContext::putAll);
    // 处理include节点
    applyIncludes(source, variablesContext, false);
}

private void applyIncludes(Node source, final Properties variablesContext, boolean included) {
    if ("include".equals(source.getNodeName())) {     // (2) 处理include子节点
      // 查找refid属性指向的sql节点，返回的是其深克隆的Node对象
      Node toInclude = findSqlFragment(getStringAttribute(source, "refid"), variablesContext);
      // 解析include节点下的property节点，将得到的键值对添加到variablesContext中，并形成新的Properties对象返回
      // 用于替换占位符
      Properties toIncludeContext = getVariablesContext(source, variablesContext);
      // 递归处理include节点，再sql节点中可能有include节点引入了其他SQL片段
      applyIncludes(toInclude, toIncludeContext, true);
      if (toInclude.getOwnerDocument() != source.getOwnerDocument()) {
        toInclude = source.getOwnerDocument().importNode(toInclude, true);
      }
      // 将include节点替换为被引用的SQL片段
      source.getParentNode().replaceChild(toInclude, source);
      while (toInclude.hasChildNodes()) { // 将sql节点的子节点添加到sql节点前面
        toInclude.getParentNode().insertBefore(toInclude.getFirstChild(), toInclude);
      }
      toInclude.getParentNode().removeChild(toInclude);   // 删除sql节点
    } else if (source.getNodeType() == Node.ELEMENT_NODE) {   // (1)
      if (included && !variablesContext.isEmpty()) {
        // replace variables in attribute values
        NamedNodeMap attributes = source.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
          Node attr = attributes.item(i);
          attr.setNodeValue(PropertyParser.parse(attr.getNodeValue(), variablesContext));
        }
      }
      // 遍历子节点
      NodeList children = source.getChildNodes();
      for (int i = 0; i < children.getLength(); i++) {
        applyIncludes(children.item(i), variablesContext, included);
      }
    } else if (included && (source.getNodeType() == Node.TEXT_NODE || source.getNodeType() == Node.CDATA_SECTION_NODE)
        && !variablesContext.isEmpty()) {   // (3)
      // 使用之前解析得到的Properties对象替换对应的占位符
      source.setNodeValue(PropertyParser.parse(source.getNodeValue(), variablesContext));
    }
}

<sql id="someinclude">
	from ${tablename}
</sql>

<select id="countAll" resultType="int">
	select 
    B.id as blog_id, B.title as blog_title, B.author_id as blog_author_id
    <include refid="someinclude">
    	<property name="tablename" value="Blog">
    </include>
</select>

private void processSelectKeyNodes(String id, Class<?> parameterTypeClass, LanguageDriver langDriver) {
    // 获取全部的selectKey节点
    List<XNode> selectKeyNodes = context.evalNodes("selectKey");
    // 解析selectKey节点
    if (configuration.getDatabaseId() != null) {
      parseSelectKeyNodes(id, selectKeyNodes, parameterTypeClass, langDriver, configuration.getDatabaseId());
    }
    parseSelectKeyNodes(id, selectKeyNodes, parameterTypeClass, langDriver, null);
    // 移除selectKey节点
    removeSelectKeyNodes(selectKeyNodes);
}

private void parseSelectKeyNode(String id, XNode nodeToHandle, Class<?> parameterTypeClass, LanguageDriver langDriver,
      String databaseId) {
    // 获取selectKey节点的resultType、statementType、keyProperty等属性
    String resultType = nodeToHandle.getStringAttribute("resultType");
    Class<?> resultTypeClass = resolveClass(resultType);
    StatementType statementType = StatementType
        .valueOf(nodeToHandle.getStringAttribute("statementType", StatementType.PREPARED.toString()));
    String keyProperty = nodeToHandle.getStringAttribute("keyProperty");
    String keyColumn = nodeToHandle.getStringAttribute("keyColumn");
    boolean executeBefore = "BEFORE".equals(nodeToHandle.getStringAttribute("order", "AFTER"));

    // defaults
    boolean useCache = false;
    boolean resultOrdered = false;
    KeyGenerator keyGenerator = NoKeyGenerator.INSTANCE;
    Integer fetchSize = null;
    Integer timeout = null;
    boolean flushCache = false;
    String parameterMap = null;
    String resultMap = null;
    ResultSetType resultSetTypeEnum = null;

    // 通过LangDriver.createSqlSource创建SqlSource
    SqlSource sqlSource = langDriver.createSqlSource(configuration, nodeToHandle, parameterTypeClass);
    // selectKey节点中只能配置SELECT语句
    SqlCommandType sqlCommandType = SqlCommandType.SELECT;

    // 通过MapperBuilderAssistant.创建MappedStatement对象，并添加到configuration.mappedStatements集合中保存
    // 该集合为StrictMap类型
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType, fetchSize, timeout, parameterMap,
        parameterTypeClass, resultMap, resultTypeClass, resultSetTypeEnum, flushCache, useCache, resultOrdered,
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, null, false);

    id = builderAssistant.applyCurrentNamespace(id, false);

    MappedStatement keyStatement = configuration.getMappedStatement(id, false);
    // 创建SelectKeyGenerator对象，并添加到configuration.keyGenerators集合中保存
    configuration.addKeyGenerator(id, new SelectKeyGenerator(keyStatement, executeBefore));
}

public SqlSource parseScriptNode() {
    // 手写判断当前节点是否有动态SQL, 动态SQL会包括占位符或是动态SQL相关节点
    MixedSqlNode rootSqlNode = parseDynamicTags(context);
    SqlSource sqlSource;
    if (isDynamic) {
      sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
    } else {
      sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
    }
    return sqlSource;
}

protected MixedSqlNode parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<>();   // 用于记录生成的SQLNode集合
    NodeList children = node.getNode().getChildNodes(); // 获取SelectKey节点的所有子节点
    for (int i = 0; i < children.getLength(); i++) {
      // 创建XNode，该过程会将能解析掉的"${}"都解析掉
      XNode child = node.newXNode(children.item(i));
      if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE ||
        child.getNode().getNodeType() == Node.TEXT_NODE) {  // 对文本节点的处理
        String data = child.getStringBody("");
        TextSqlNode textSqlNode = new TextSqlNode(data);
        // 解析SQL语句，如果有未解析的占位符，说明该节点是动态SQL
        if (textSqlNode.isDynamic()) {
          contents.add(textSqlNode);
          isDynamic = true;   // 标记为动态SQL
        } else {
          contents.add(new StaticTextSqlNode(data));
        }
      } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) {
        // 如果子节点是一个标签, 那么一定是一个动态SQL节点
        // 根据不同的动态标签生成不同的NodeHandler
        String nodeName = child.getNode().getNodeName();
        NodeHandler handler = nodeHandlerMap.get(nodeName);
        if (handler == null) {
          throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
        }
        // 处理动态SQL，并将解析得到的SQLNode对象放入contents中保存
        handler.handleNode(child, contents);
        isDynamic = true;
      }
    }
    return new MixedSqlNode(contents);
}

KeyGenerator keyGenerator;
String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);

// 检测SQL节点中是否配置了selectKey节点、SQL节点的useGeneratedKeys属性值
// mybatis-config.xml中全局的useGeneratedKeys配置，以及是否为insert语句，
// 决定KeyGenerator接口实现
if (configuration.hasKeyGenerator(keyStatementId)) {
    keyGenerator = configuration.getKeyGenerator(keyStatementId);
} else {
    keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
                                               configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
        ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
}

// 调用LanguageDriver创建SqlSource
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
StatementType statementType = StatementType
    .valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
Integer fetchSize = context.getIntAttribute("fetchSize");
Integer timeout = context.getIntAttribute("timeout");
String parameterMap = context.getStringAttribute("parameterMap");
String resultType = context.getStringAttribute("resultType");
Class<?> resultTypeClass = resolveClass(resultType);
String resultMap = context.getStringAttribute("resultMap");
if (resultTypeClass == null && resultMap == null) {
    resultTypeClass = MapperAnnotationBuilder.getMethodReturnType(builderAssistant.getCurrentNamespace(), id);
}
String resultSetType = context.getStringAttribute("resultSetType");
ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
if (resultSetTypeEnum == null) {
    resultSetTypeEnum = configuration.getDefaultResultSetType();
}
String keyProperty = context.getStringAttribute("keyProperty");
String keyColumn = context.getStringAttribute("keyColumn");
String resultSets = context.getStringAttribute("resultSets");
boolean dirtySelect = context.getBooleanAttribute("affectData", Boolean.FALSE);

// 通过MapperBuilderAssistant创建MappedStatement，并添加到Configuration.mappedStatements中
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType, fetchSize, timeout, parameterMap,
                                    parameterTypeClass, resultMap, resultTypeClass, resultSetTypeEnum, flushCache, 
                                    useCache, resultOrdered,keyGenerator, keyProperty, keyColumn, databaseId, 
                                    langDriver, resultSets, dirtySelect);