Mybatis源码解析之标签的解析

阅读须知

• Mybatis源码版本：3.4.4
• 文章中使用/* */注释的方法会做深入分析

正文

Mybatis是我们日常开发过程中经常使用的ORM框架，读者可以首先参考Mybatis中文官方文档来看一下Mybatis的使用示例，首先要通过SqlSessionFactoryBuilder来构建SqlSessionFactory，我们就以SqlSessionFactory的构建为入口来分析Mybatis源码：
SqlSessionFactoryBuilder：

public SqlSessionFactory build(InputStream inputStream) {
    /* 构建SqlSessionFactory */
    return build(inputStream, null, null);
}

SqlSessionFactoryBuilder：

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        /* 解析配置，构建SqlSessionFactory */
        return build(parser.parse());
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
        ErrorContext.instance().reset();
        try {
            inputStream.close();
        } catch (IOException e) {
        }
    }
}

XMLConfigBuilder：

public Configuration parse() {
    if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    /* 解析配置 */
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

关于配置的功能及使用方法，请参考官方文档，地址已经给出。
XMLConfigBuilder：

private void parseConfiguration(XNode root) {
    try {
        /* 解析properties标签 */
        propertiesElement(root.evalNode("properties"));
        /* 解析settings标签 */
        Properties settings = settingsAsProperties(root.evalNode("settings"));
        /* 设置自定义VFS */
        loadCustomVfs(settings);
        /* 解析typeAliases标签 */
        typeAliasesElement(root.evalNode("typeAliases"));
        /* 解析plugins标签 */
        pluginElement(root.evalNode("plugins"));
        /* 解析objectFactory标签 */
        objectFactoryElement(root.evalNode("objectFactory"));
        /* 解析objectWrapperFactory标签 */
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        /* 解析reflectorFactory标签 */
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        /* 将settings配置放入configuration对象中 */
        settingsElement(settings);
        /* 解析environments标签 */
        environmentsElement(root.evalNode("environments"));
        /* 解析databaseIdProvider标签 */
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        /* 解析typeHandlers标签 */
        typeHandlerElement(root.evalNode("typeHandlers"));
        /* 解析mappers标签 */
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

XMLConfigBuilder：

private void propertiesElement(XNode context) throws Exception {
    if (context != null) {
        // 将子标签的name和value属性作为键值对放入Properties对象中
        Properties defaults = context.getChildrenAsProperties();
        // 获取resource属性
        String resource = context.getStringAttribute("resource");
        // 获取url属性
        String url = context.getStringAttribute("url");
        // 两者不能同时存在
        if (resource != null && url != null) {
            throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
        }
        if (resource != null) {
            // 如果resource不为空则加载resource配置的配置文件
            defaults.putAll(Resources.getResourceAsProperties(resource));
        } else if (url != null) {
            // 如果url不为空则加载url配置的资源
            defaults.putAll(Resources.getUrlAsProperties(url));
        }
        Properties vars = configuration.getVariables();
        if (vars != null) {
            // 如果定义了configuration对象的变量同样加入配置中
            defaults.putAll(vars);
        }
        // 将配置放入parser和configuration对象中
        parser.setVariables(defaults);
        configuration.setVariables(defaults);
    }
}

XMLConfigBuilder：

private Properties settingsAsProperties(XNode context) {
    if (context == null) {
        return new Properties();
    }
    // 将子标签的name和value属性作为键值对放入Properties对象中
    Properties props = context.getChildrenAsProperties();
    MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
    // 校验Configuration类中是否有对应的setter方法
    for (Object key : props.keySet()) {
        if (!metaConfig.hasSetter(String.valueOf(key))) {
            throw new BuilderException("The setting " + key + " is not known.  Make sure you spelled it correctly (case sensitive).");
        }
    }
    return props;
}

XMLConfigBuilder：

private void loadCustomVfs(Properties props) throws ClassNotFoundException {
    // 将用户自定义VFS放入configuration对象中
    String value = props.getProperty("vfsImpl");
    if (value != null) {
        String[] clazzes = value.split(",");
        for (String clazz : clazzes) {
            if (!clazz.isEmpty()) {
                @SuppressWarnings("unchecked")
                Class<? extends VFS> vfsImpl = (Class<? extends VFS>)Resources.classForName(clazz);
                configuration.setVfsImpl(vfsImpl);
            }
        }
    }
}

这里提到了Mybatis VFS，简单介绍一下，它提供一个非常简单的API，用于访问应用程序服务器内的资源。
XMLConfigBuilder：

private void typeAliasesElement(XNode parent) {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            if ("package".equals(child.getName())) {
                String typeAliasPackage = child.getStringAttribute("name");
                /* 指定包名的类别名注册 */
                configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
            } else {
                String alias = child.getStringAttribute("alias");
                String type = child.getStringAttribute("type");
                try {
                    Class<?> clazz = Resources.classForName(type);
                    if (alias == null) {
                        /* 没有指定别名的类别名注册 */
                        typeAliasRegistry.registerAlias(clazz);
                    } else {
                        /* 指定别名的类别名注册 */
                        typeAliasRegistry.registerAlias(alias, clazz);
                    }
                } catch (ClassNotFoundException e) {
                    throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
                }
            }
        }
    }
}

TypeAliasRegistry：

public void registerAliases(String packageName){
    /* 根据包名注册类别名 */
    registerAliases(packageName, Object.class);
}

TypeAliasRegistry：

public void registerAliases(String packageName, Class<?> superType){
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
    // 加载包下面的类
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
    for(Class<?> type : typeSet){
        // 非匿名类，非接口类，非成员类
        if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
            /* 注册类别名 */
            registerAlias(type);
        }
    }
}

TypeAliasRegistry：

public void registerAlias(Class<?> type) {
    String alias = type.getSimpleName();
    // 如果注解了@Alias，则取注解的值作为别名
    Alias aliasAnnotation = type.getAnnotation(Alias.class);
    if (aliasAnnotation != null) {
        alias = aliasAnnotation.value();
    } 
    /* 注册类别名 */
    registerAlias(alias, type);
}

TypeAliasRegistry：

public void registerAlias(String alias, Class<?> value) {
    if (alias == null) {
        throw new TypeException("The parameter alias cannot be null");
    }
    // 别名转成小写
    String key = alias.toLowerCase(Locale.ENGLISH);
    // 如果已经包含当前别名，并且不为null，并且新值和原来的值不一样，抛出异常
    if (TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null && !TYPE_ALIASES.get(key).equals(value)) {
        throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'.");
    }
    // 将键值映射关系放入别名映射中
    TYPE_ALIASES.put(key, value);
}

TypeAliasRegistry：

public void registerAlias(String alias, String value) {
    try {
        // 在指定别名的情况下同样也是调用上面的方法进行注册
        registerAlias(alias, Resources.classForName(value));
    } catch (ClassNotFoundException e) {
        throw new TypeException("Error registering type alias "+alias+" for "+value+". Cause: " + e, e);
    }
}

Mybatis默认为我们注册了很多别名，在构造TypeAliasRegistry对象时：

public TypeAliasRegistry() {
    registerAlias("string", String.class);
    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    registerAlias("short", Short.class);
    registerAlias("int", Integer.class);
    registerAlias("integer", Integer.class);
    registerAlias("double", Double.class);
    registerAlias("float", Float.class);
    registerAlias("boolean", Boolean.class);
    registerAlias("byte[]", Byte[].class);
    registerAlias("long[]", Long[].class);
    registerAlias("short[]", Short[].class);
    registerAlias("int[]", Integer[].class);
    registerAlias("integer[]", Integer[].class);
    registerAlias("double[]", Double[].class);
    registerAlias("float[]", Float[].class);
    registerAlias("boolean[]", Boolean[].class);
    registerAlias("_byte", byte.class);
    registerAlias("_long", long.class);
    registerAlias("_short", short.class);
    registerAlias("_int", int.class);
    registerAlias("_integer", int.class);
    registerAlias("_double", double.class);
    registerAlias("_float", float.class);
    registerAlias("_boolean", boolean.class);
    registerAlias("_byte[]", byte[].class);
    registerAlias("_long[]", long[].class);
    registerAlias("_short[]", short[].class);
    registerAlias("_int[]", int[].class);
    registerAlias("_integer[]", int[].class);
    registerAlias("_double[]", double[].class);
    registerAlias("_float[]", float[].class);
    registerAlias("_boolean[]", boolean[].class);
    registerAlias("date", Date.class);
    registerAlias("decimal", BigDecimal.class);
    registerAlias("bigdecimal", BigDecimal.class);
    registerAlias("biginteger", BigInteger.class);
    registerAlias("object", Object.class);
    registerAlias("date[]", Date[].class);
    registerAlias("decimal[]", BigDecimal[].class);
    registerAlias("bigdecimal[]", BigDecimal[].class);
    registerAlias("biginteger[]", BigInteger[].class);
    registerAlias("object[]", Object[].class);
    registerAlias("map", Map.class);
    registerAlias("hashmap", HashMap.class);
    registerAlias("list", List.class);
    registerAlias("arraylist", ArrayList.class);
    registerAlias("collection", Collection.class);
    registerAlias("iterator", Iterator.class);
    registerAlias("ResultSet", ResultSet.class);
}

在构造Configuration对象时：

public Configuration() {
    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
    typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
    typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
    typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
    typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);
    typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
    typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
    typeAliasRegistry.registerAlias("LRU", LruCache.class);
    typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
    typeAliasRegistry.registerAlias("WEAK", WeakCache.class);
    typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);
    typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
    typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);
    typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
    typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
    typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
    typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
    typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
    typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
    typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);
    typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
    typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);
    languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
    languageRegistry.register(RawLanguageDriver.class);
}

这些别名我们都是可以直接使用的。
XMLConfigBuilder：

private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            // 获取interceptor属性配置的类名或者类别名
            String interceptor = child.getStringAttribute("interceptor");
            // 将子标签的name和value属性作为键值对放入Properties对象中
            Properties properties = child.getChildrenAsProperties();
            // 反射实例化
            Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
            // 为拦截器设置用户指定的property配置
            interceptorInstance.setProperties(properties);
            // 将拦截器添加到configuration对象中
            configuration.addInterceptor(interceptorInstance);
        }
    }
}

XMLConfigBuilder：

private void objectFactoryElement(XNode context) throws Exception {
    if (context != null) {
        // 获取type属性配置的类名或者类别名
        String type = context.getStringAttribute("type");
        // 将子标签的name和value属性作为键值对放入Properties对象中
        Properties properties = context.getChildrenAsProperties();
        // 反射实例化
        ObjectFactory factory = (ObjectFactory) resolveClass(type).newInstance();
        // 为ObjectFactory设置用户指定的property配置
        factory.setProperties(properties);
        // 将ObjectFactory设置到configuration对象中
        configuration.setObjectFactory(factory);
    }
}

XMLConfigBuilder：

private void objectWrapperFactoryElement(XNode context) throws Exception {
    if (context != null) {
        // 获取type属性配置的类名或者类别名
        String type = context.getStringAttribute("type");
        // 反射实例化
        ObjectWrapperFactory factory = (ObjectWrapperFactory) resolveClass(type).newInstance();
        // 将ObjectWrapperFactory设置到configuration对象中
        configuration.setObjectWrapperFactory(factory);
    }
}

XMLConfigBuilder：

private void reflectorFactoryElement(XNode context) throws Exception {
    if (context != null) {
        // 获取type属性配置的类名或者类别名
        String type = context.getStringAttribute("type");
        // 反射实例化
        ReflectorFactory factory = (ReflectorFactory) resolveClass(type).newInstance();
        // 将ReflectorFactory设置到configuration对象中
        configuration.setReflectorFactory(factory);
    }
}

XMLConfigBuilder：

private void settingsElement(Properties props) throws Exception {
    configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
    configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
    configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
    configuration.setProxyFactory((ProxyFactory) createInstance(props.getProperty("proxyFactory")));
    configuration.setLazyLoadingEnabled(booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
    configuration.setAggressiveLazyLoading(booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
    configuration.setMultipleResultSetsEnabled(booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
    configuration.setUseColumnLabel(booleanValueOf(props.getProperty("useColumnLabel"), true));
    configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
    configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
    configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));
    configuration.setDefaultFetchSize(integerValueOf(props.getProperty("defaultFetchSize"), null));
    configuration.setMapUnderscoreToCamelCase(booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
    configuration.setSafeRowBoundsEnabled(booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
    configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
    configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
    configuration.setLazyLoadTriggerMethods(stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
    configuration.setSafeResultHandlerEnabled(booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
    configuration.setDefaultScriptingLanguage(resolveClass(props.getProperty("defaultScriptingLanguage")));
    configuration.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
    configuration.setUseActualParamName(booleanValueOf(props.getProperty("useActualParamName"), true));
    configuration.setReturnInstanceForEmptyRow(booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
    configuration.setLogPrefix(props.getProperty("logPrefix"));
    @SuppressWarnings("unchecked")
    Class<? extends Log> logImpl = (Class<? extends Log>)resolveClass(props.getProperty("logImpl"));
    configuration.setLogImpl(logImpl);
    configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
}

这里就是将settings对应的配置设置到configuration对象中。
XMLConfigBuilder：

private void environmentsElement(XNode context) throws Exception {
    if (context != null) {
        if (environment == null) {
            // 获取environment默认配置id
            environment = context.getStringAttribute("default");
        }
        for (XNode child : context.getChildren()) {
            // 获取子标签environment的id属性
            String id = child.getStringAttribute("id");
            // 判断与默认配置id是否相同
            if (isSpecifiedEnvironment(id)) {
                /* 解析transactionManager子标签 */
                TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
                /* 解析dataSource子标签 */
                DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
                DataSource dataSource = dsFactory.getDataSource();
                Environment.Builder environmentBuilder = new Environment.Builder(id)
                .transactionFactory(txFactory)
                .dataSource(dataSource);
                // 构建Environment对象并设置到configuration对象中
                configuration.setEnvironment(environmentBuilder.build());
            }
        }
    }
}

XMLConfigBuilder：

private TransactionFactory transactionManagerElement(XNode context) throws Exception {
    if (context != null) {
        // 获取type属性配置的类名或者类别名
        String type = context.getStringAttribute("type");
        // 将子标签的name和value属性作为键值对放入Properties对象中
        Properties props = context.getChildrenAsProperties();
        // 反射实例化
        TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();
        // 为TransactionFactory设置用户指定的property配置
        factory.setProperties(props);
        return factory;
    }
    throw new BuilderException("Environment declaration requires a TransactionFactory.");
}

XMLConfigBuilder：

private DataSourceFactory dataSourceElement(XNode context) throws Exception {
    if (context != null) {
        // 获取type属性配置的类名或者类别名
        String type = context.getStringAttribute("type");
        // 将子标签的name和value属性作为键值对放入Properties对象中
        Properties props = context.getChildrenAsProperties();
        // 反射实例化
        DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
        // 为DataSourceFactory设置用户指定的property配置
        factory.setProperties(props);
        return factory;
    }
    throw new BuilderException("Environment declaration requires a DataSourceFactory.");
}

XMLConfigBuilder：

private void databaseIdProviderElement(XNode context) throws Exception {
    DatabaseIdProvider databaseIdProvider = null;
    if (context != null) {
        // 获取type属性配置的类名或者类别名
        String type = context.getStringAttribute("type");
        if ("VENDOR".equals(type)) {
            // 这里的DB_VENDOR类别名是在构造Configuration对象时注册的，对应的类是VendorDatabaseIdProvider
            type = "DB_VENDOR";
        }
        // 将子标签的name和value属性作为键值对放入Properties对象中
        Properties properties = context.getChildrenAsProperties();
        // 反射实例化
        databaseIdProvider = (DatabaseIdProvider) resolveClass(type).newInstance();
        // 为DatabaseIdProvider设置用户指定的property配置
        databaseIdProvider.setProperties(properties);
    }
    Environment environment = configuration.getEnvironment();
    if (environment != null && databaseIdProvider != null) {
        // 获取databaseId
        String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
        configuration.setDatabaseId(databaseId); // 设置到configuration对象中
    }
}

XMLConfigBuilder：

private void typeHandlerElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            if ("package".equals(child.getName())) {
                String typeHandlerPackage = child.getStringAttribute("name"); // 包名
                /* 根据包名加载类型处理器 */
                typeHandlerRegistry.register(typeHandlerPackage);
            } else {
                String javaTypeName = child.getStringAttribute("javaType");
                String jdbcTypeName = child.getStringAttribute("jdbcType");
                String handlerTypeName = child.getStringAttribute("handler");
                // 获取javaType属性配置的类名或者类别名
                Class<?> javaTypeClass = resolveClass(javaTypeName);
                // 根据jdbcType配置的名称在枚举找到对应的枚举值
                JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
                // 获取handler属性配置的类名或者类别名
                Class<?> typeHandlerClass = resolveClass(handlerTypeName);
                if (javaTypeClass != null) {
                    if (jdbcType == null) {
                        /* 注册类型处理器 */
                        typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
                    } else {
                        /* 注册类型处理器 */
                        typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
                    }
                } else {
                    /* 注册类型处理器 */
                    typeHandlerRegistry.register(typeHandlerClass);
                }
            }
        }
    }
}

TypeHandlerRegistry：

public void register(String packageName) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
    // 加载包下面的类
    resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);
    Set<Class<? extends Class<?>>> handlerSet = resolverUtil.getClasses();
    for (Class<?> type : handlerSet) {
        // 非匿名类，非接口类，非abstract修饰的类
        if (!type.isAnonymousClass() && !type.isInterface() && !Modifier.isAbstract(type.getModifiers())) {
            register(type); /* 注册类型处理器 */
        }
    }
}

TypeHandlerRegistry：

public void register(Class<?> typeHandlerClass) {
    boolean mappedTypeFound = false;
    MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
    // 如果注解了@MappedTypes，则使用注解属性值作为javaType
    if (mappedTypes != null) {
        for (Class<?> javaTypeClass : mappedTypes.value()) {
            /* 注册类型处理器 */
            register(javaTypeClass, typeHandlerClass);
            mappedTypeFound = true;
        }
    }
    if (!mappedTypeFound) {
        /* 获取TypeHandler实例，注册类型处理器 */
        register(getInstance(null, typeHandlerClass));
    }
}

TypeHandlerRegistry：

public void register(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
    /* 获取TypeHandler实例，注册类型处理器 */
    register(javaTypeClass, getInstance(javaTypeClass, typeHandlerClass));
}

TypeHandlerRegistry：

public <T> TypeHandler<T> getInstance(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
    if (javaTypeClass != null) {
        try {
            // 如果有javaType，则将javaType作为参数实例化类型处理器
            Constructor<?> c = typeHandlerClass.getConstructor(Class.class);
            return (TypeHandler<T>) c.newInstance(javaTypeClass);
        } catch (NoSuchMethodException ignored) {
        } catch (Exception e) {
            throw new TypeException("Failed invoking constructor for handler " + typeHandlerClass, e);
        }
    }
    try {
        // 无参构造方法实例化类型处理器
        Constructor<?> c = typeHandlerClass.getConstructor();
        return (TypeHandler<T>) c.newInstance();
    } catch (Exception e) {
        throw new TypeException("Unable to find a usable constructor for " + typeHandlerClass, e);
    }
}

TypeHandlerRegistry：

private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {
    // 获取类型处理器上的@MappedJdbcTypes注解信息
    MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
    if (mappedJdbcTypes != null) {
        for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
            /* 遍历注解的value属性配置的JdbcType数组作为jdbcType注册类型处理器 */
            register(javaType, handledJdbcType, typeHandler);
        }
        if (mappedJdbcTypes.includeNullJdbcType()) {
            /* 如果注解配置了允许包括null值的jdbcType则注册jdbcType为null的类型处理器 */
            register(javaType, null, typeHandler);
        }
    } else {
        /* 注册jdbcType为null的类型处理器 */
        register(javaType, null, typeHandler);
    }
}

TypeHandlerRegistry：

private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
    if (javaType != null) {
        Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);
        if (map == null) {
            map = new HashMap<JdbcType, TypeHandler<?>>();
            TYPE_HANDLER_MAP.put(javaType, map);
        }
        map.put(jdbcType, handler);
    }
    ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
}

注册的过程就是将对应jdbcType、javaType、typeHandler三者的对应关系存入映射中。另外几个重载的注册类型处理器的方法都大同小异，就不做赘述了，另外在构造TypeHandlerRegistry时，Mybatis注册一些默认的类型处理器：

public TypeHandlerRegistry() {
    register(Boolean.class, new BooleanTypeHandler());
    register(boolean.class, new BooleanTypeHandler());
    register(JdbcType.BOOLEAN, new BooleanTypeHandler());
    register(JdbcType.BIT, new BooleanTypeHandler());
    register(Byte.class, new ByteTypeHandler());
    register(byte.class, new ByteTypeHandler());
    register(JdbcType.TINYINT, new ByteTypeHandler());
    register(Short.class, new ShortTypeHandler());
    register(short.class, new ShortTypeHandler());
    register(JdbcType.SMALLINT, new ShortTypeHandler());
    register(Integer.class, new IntegerTypeHandler());
    register(int.class, new IntegerTypeHandler());
    register(JdbcType.INTEGER, new IntegerTypeHandler());
    register(Long.class, new LongTypeHandler());
    register(long.class, new LongTypeHandler());
    register(Float.class, new FloatTypeHandler());
    register(float.class, new FloatTypeHandler());
    register(JdbcType.FLOAT, new FloatTypeHandler());
    register(Double.class, new DoubleTypeHandler());
    register(double.class, new DoubleTypeHandler());
    register(JdbcType.DOUBLE, new DoubleTypeHandler());
    register(Reader.class, new ClobReaderTypeHandler());
    register(String.class, new StringTypeHandler());
    register(String.class, JdbcType.CHAR, new StringTypeHandler());
    register(String.class, JdbcType.CLOB, new ClobTypeHandler());
    register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.LONGVARCHAR, new ClobTypeHandler());
    register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
    register(JdbcType.CHAR, new StringTypeHandler());
    register(JdbcType.VARCHAR, new StringTypeHandler());
    register(JdbcType.CLOB, new ClobTypeHandler());
    register(JdbcType.LONGVARCHAR, new ClobTypeHandler());
    register(JdbcType.NVARCHAR, new NStringTypeHandler());
    register(JdbcType.NCHAR, new NStringTypeHandler());
    register(JdbcType.NCLOB, new NClobTypeHandler());
    register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
    register(JdbcType.ARRAY, new ArrayTypeHandler());
    register(BigInteger.class, new BigIntegerTypeHandler());
    register(JdbcType.BIGINT, new LongTypeHandler());
    register(BigDecimal.class, new BigDecimalTypeHandler());
    register(JdbcType.REAL, new BigDecimalTypeHandler());
    register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
    register(JdbcType.NUMERIC, new BigDecimalTypeHandler());
    register(InputStream.class, new BlobInputStreamTypeHandler());
    register(Byte[].class, new ByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
    register(byte[].class, new ByteArrayTypeHandler());
    register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
    register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.BLOB, new BlobTypeHandler());
    register(Object.class, UNKNOWN_TYPE_HANDLER);
    register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
    register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
    register(Date.class, new DateTypeHandler());
    register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
    register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
    register(JdbcType.TIMESTAMP, new DateTypeHandler());
    register(JdbcType.DATE, new DateOnlyTypeHandler());
    register(JdbcType.TIME, new TimeOnlyTypeHandler());
    register(java.sql.Date.class, new SqlDateTypeHandler());
    register(java.sql.Time.class, new SqlTimeTypeHandler());
    register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());
    try {
        register("java.time.Instant", "org.apache.ibatis.type.InstantTypeHandler");
        register("java.time.LocalDateTime", "org.apache.ibatis.type.LocalDateTimeTypeHandler");
        register("java.time.LocalDate", "org.apache.ibatis.type.LocalDateTypeHandler");
        register("java.time.LocalTime", "org.apache.ibatis.type.LocalTimeTypeHandler");
        register("java.time.OffsetDateTime", "org.apache.ibatis.type.OffsetDateTimeTypeHandler");
        register("java.time.OffsetTime", "org.apache.ibatis.type.OffsetTimeTypeHandler");
        register("java.time.ZonedDateTime", "org.apache.ibatis.type.ZonedDateTimeTypeHandler");
        register("java.time.Month", "org.apache.ibatis.type.MonthTypeHandler");
        register("java.time.Year", "org.apache.ibatis.type.YearTypeHandler");
        register("java.time.YearMonth", "org.apache.ibatis.type.YearMonthTypeHandler");
        register("java.time.chrono.JapaneseDate", "org.apache.ibatis.type.JapaneseDateTypeHandler");
    } catch (ClassNotFoundException e) {
    }
    register(Character.class, new CharacterTypeHandler());
    register(char.class, new CharacterTypeHandler());
}

配置文件解析的最后一步就是对mapper配置的解析：
XMLConfigBuilder：

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            if ("package".equals(child.getName())) {
                String mapperPackage = child.getStringAttribute("name");
                /* 按照包名配置解析 */
                configuration.addMappers(mapperPackage);
            } else {
                String resource = child.getStringAttribute("resource");
                String url = child.getStringAttribute("url");
                String mapperClass = child.getStringAttribute("class");
                if (resource != null && url == null && mapperClass == null) {
                    ErrorContext.instance().resource(resource);
                    InputStream inputStream = Resources.getResourceAsStream(resource);
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                    /* 按照resource配置解析 */
                    mapperParser.parse();
                } else if (resource == null && url != null && mapperClass == null) {
                    ErrorContext.instance().resource(url);
                    InputStream inputStream = Resources.getUrlAsStream(url);
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                    /* 按照url配置解析 */
                    mapperParser.parse();
                } else if (resource == null && url == null && mapperClass != null) {
                    Class<?> mapperInterface = Resources.classForName(mapperClass);
                    /* 按照class配置解析 */
                    configuration.addMapper(mapperInterface);
                } else {
                    // 三者只能出现一个，某则抛出异常
                    throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
                }
            }
        }
    }
}

Configuration：

public void addMappers(String packageName) {
    /* 根据包名注册mapper */
    mapperRegistry.addMappers(packageName);
}

MapperRegistry：

public void addMappers(String packageName, Class<?> superType) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
    // 加载包下面的类
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
    for (Class<?> mapperClass : mapperSet) {
        /* 添加mapper */
        addMapper(mapperClass);
    }
}

MapperRegistry：

public <T> void addMapper(Class<T> type) {
    if (type.isInterface()) { // mapper类必须是接口
        if (hasMapper(type)) { // 如果mapper已经存在，报错
            throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
        }
        boolean loadCompleted = false;
        try {
            knownMappers.put(type, new MapperProxyFactory<T>(type)); // 将当前mapper添加到已知mapper集合中
            MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
            parser.parse(); /* 解析mapper配置 */
            loadCompleted = true;
        } finally {
            if (!loadCompleted) {
                knownMappers.remove(type); // 如果解析出现异常，从已知的mapper集合中移除掉当前mapper
            }
        }
    }
}

MapperAnnotationBuilder：

public void parse() {
    String resource = type.toString();
    // 判断是否已经加载过，防止重复加载
    if (!configuration.isResourceLoaded(resource)) {
        loadXmlResource(); /* 加载xml配置 */
        configuration.addLoadedResource(resource); // 标记为已经加载的资源
        assistant.setCurrentNamespace(type.getName());
        parseCache(); /* 解析@CacheNamespace注解配置 */
        parseCacheRef(); /* 解析@CacheNamespaceRef注解配置 */
        Method[] methods = type.getMethods();
        for (Method method : methods) {
            try {
                if (!method.isBridge()) {
                    parseStatement(method); /* 解析方法上的注解配置 */
                }
            } catch (IncompleteElementException e) {
                // 添加到未完成解析的方法解析器集合中，后续继续解析
                configuration.addIncompleteMethod(new MethodResolver(this, method));
            }
        }
    }
    parsePendingMethods(); // 解析挂起的方法
}

MapperAnnotationBuilder：

private void loadXmlResource() {
    // 判断是否已经加载过，防止重复加载
    if (!configuration.isResourceLoaded("namespace:" + type.getName())) {
        // 将类名的.替换成/，也就是查找当前路径下同名的xml文件作为配置文件
        String xmlResource = type.getName().replace('.', '/') + ".xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(type.getClassLoader(), xmlResource);
        } catch (IOException e) {
        }
        if (inputStream != null) {
            XMLMapperBuilder xmlParser = new XMLMapperBuilder(inputStream, assistant.getConfiguration(), xmlResource, configuration.getSqlFragments(), type.getName());
            /* 解析xml配置 */
            xmlParser.parse();
        }
    }
}

public void parse() {
    // 判断是否已经加载过，防止重复加载
    if (!configuration.isResourceLoaded(resource)) {
        /* 解析mapper配置 */
        configurationElement(parser.evalNode("/mapper"));
        configuration.addLoadedResource(resource); // 标记为已加载资源
        bindMapperForNamespace(); /* 为命名空间绑定mapper */
    }
    parsePendingResultMaps(); // 解析挂起的resultMap
    parsePendingCacheRefs(); // 解析挂起的cacheRef
    parsePendingStatements(); // 解析挂起的statement
}

这里提到了对挂起元素的解析，什么时候会有挂起元素后面会详细说明，对挂起元素的解析和正常解析的流程是一样的，就是从configuration对象中拿出挂起的元素再次解析一遍。
XMLMapperBuilder：

private void configurationElement(XNode context) {
    try {
        String namespace = context.getStringAttribute("namespace"); // 获取命名空间配置
        if (namespace == null || namespace.equals("")) {
            throw new BuilderException("Mapper's namespace cannot be empty");
        }
        // 设置当前命名空间
        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. Cause: " + e, e);
    }
}
 
  
XMLMapperBuilder：
 
  
private void cacheRefElement(XNode context) {
    if (context != null) {
        // 将当前命名空间和cache-ref中配置的命名空间添加映射关系
        configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
        CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
        try {
            // 这里的解析主要是验证cache-ref关联的缓存对象是否已经存在，如果不存在，就会抛出IncompleteElementException异常
            cacheRefResolver.resolveCacheRef();
        } catch (IncompleteElementException e) {
            // 添加到未完成解析的cache-ref集合中，后续继续解析
            configuration.addIncompleteCacheRef(cacheRefResolver);
        }
    }
}
 
  
XMLMapperBuilder：
 
  
private void cacheElement(XNode context) throws Exception {
    if (context != null) {
        // 获取缓存类型配置，默认为PERPETUAL持久化缓存，支持实现Cache接口自定义缓存
        String type = context.getStringAttribute("type", "PERPETUAL");
        // 获取类名或类别名对应的Class对象
        Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
        // 获取回收策略配置，默认为LRU最近最少使用原则
        String eviction = context.getStringAttribute("eviction", "LRU");
        // 获取类名或类别名对应的Class对象，Mybatis提供的几种的回收策略在构建Configuration对象时注册了别名，上文介绍过
        Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
        // 获取flushInterval缓存刷新间隔配置，默认没有刷新间隔
        Long flushInterval = context.getLongAttribute("flushInterval");
        // 获取size缓存引用数目配置，默认值是1024
        Integer size = context.getIntAttribute("size");
        // 获取缓存只读属性配置
        boolean readWrite = !context.getBooleanAttribute("readOnly", false);
        // 获取缓存blocking配置
        boolean blocking = context.getBooleanAttribute("blocking", false);
        // 将子标签的name和value属性作为键值对放入Properties对象中
        Properties props = context.getChildrenAsProperties();
        /* 添加缓存 */
        builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
    }
}
 
  
MapperBuilderAssistant：
 
  
public Cache useNewCache(Class<? extends Cache> typeClass,
    Class<? extends Cache> evictionClass,
    Long flushInterval,
    Integer size,
    boolean readWrite,
    boolean blocking,
    Properties props) {
    /* 构建缓存 */
    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();
    // 添加到缓存映射中
    configuration.addCache(cache);
    currentCache = cache;
    return cache;
}
 
  
CacheBuilder：
 
  
public Cache build() {
    // 设置默认实现，如果没有默认实现会用PerpetualCache作为默认实现并添加默认装饰者LruCache
    setDefaultImplementations();
    // 反射实例化cache，id也就是命名空间会作为构造方法的参数
    Cache cache = newBaseCacheInstance(implementation, id);
    /* 为缓存设置用户自定义属性 */
    setCacheProperties(cache);
    if (PerpetualCache.class.equals(cache.getClass())) {
        for (Class<? extends Cache> decorator : decorators) {
            // 装饰者装饰缓存对象，默认就是LruCache装饰PerpetualCache
            cache = newCacheDecoratorInstance(decorator, cache);
            /* 装饰者装饰之后再次为缓存对象设置用户自定义属性 */
            setCacheProperties(cache);
        }
        /* 设置基本的装饰者 */
        cache = setStandardDecorators(cache);
    } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
        // 如果基本cache对象不是PerpetualCache并且没有继承LoggingCache，那么用LoggingCache装饰基本cache对象，主要是为了记录缓存命中比例
        cache = new LoggingCache(cache);
    }
    return cache;
}
 
  
CacheBuilder：
 
  
private void setCacheProperties(Cache cache) {
    if (properties != null) {
        MetaObject metaCache = SystemMetaObject.forObject(cache);
        for (Map.Entry<Object, Object> entry : properties.entrySet()) {
            String name = (String) entry.getKey();
            String value = (String) entry.getValue();
            // 根据配置找到相关setter方法调用赋值
            if (metaCache.hasSetter(name)) {
                Class<?> type = metaCache.getSetterType(name);
                if (String.class == type) {
                    metaCache.setValue(name, value);
                } else if (int.class == type
                    || Integer.class == type) {
                    metaCache.setValue(name, Integer.valueOf(value));
                } else if (long.class == type
                    || Long.class == type) {
                    metaCache.setValue(name, Long.valueOf(value));
                } else if (short.class == type
                    || Short.class == type) {
                    metaCache.setValue(name, Short.valueOf(value));
                } else if (byte.class == type
                    || Byte.class == type) {
                    metaCache.setValue(name, Byte.valueOf(value));
                } else if (float.class == type
                    || Float.class == type) {
                    metaCache.setValue(name, Float.valueOf(value));
                } else if (boolean.class == type
                    || Boolean.class == type) {
                    metaCache.setValue(name, Boolean.valueOf(value));
                } else if (double.class == type
                    || Double.class == type) {
                    metaCache.setValue(name, Double.valueOf(value));
                } else {
                    throw new CacheException("Unsupported property type for cache: '" + name + "' of type " + type);
                }
            }
        }
    }
    // 如果cache对象实现了InitializingObject接口，在这里调用它的initialize方法
    if (InitializingObject.class.isAssignableFrom(cache.getClass())){
        try {
            ((InitializingObject) cache).initialize();
        } catch (Exception e) {
            throw new CacheException("Failed cache initialization for '" +
                cache.getId() + "' on '" + cache.getClass().getName() + "'", e);
        }
    }
}
 
  
CacheBuilder：
 
  
private Cache setStandardDecorators(Cache cache) {
    try {
        MetaObject metaCache = SystemMetaObject.forObject(cache);
        if (size != null && metaCache.hasSetter("size")) {
            metaCache.setValue("size", size);
        }
        if (clearInterval != null) {
            // 如果配置了flushInterval，则用ScheduledCache装饰基本cache对象
            cache = new ScheduledCache(cache);
            ((ScheduledCache) cache).setClearInterval(clearInterval);
        }
        if (readWrite) {
            // 如果配置了readOnly为true，则用SerializedCache装饰基本cache对象
            cache = new SerializedCache(cache);
        }
        // 用LoggingCache装饰基本cache对象
        cache = new LoggingCache(cache);
        // 用SynchronizedCache装饰基本cache对象
        cache = new SynchronizedCache(cache);
        // 如果配置了blocking为true，则用BlockingCache装饰基本cache对象
        if (blocking) {
            cache = new BlockingCache(cache);
        }
        return cache;
    } catch (Exception e) {
        throw new CacheException("Error building standard cache decorators.  Cause: " + e, e);
    }
}
 
  
XMLMapperBuilder：
 
  
private void resultMapElements(List<XNode> list) throws Exception {
    for (XNode resultMapNode : list) {
        try {
            /* 解析标签 */
            resultMapElement(resultMapNode);
        } catch (IncompleteElementException e) {
        }
    }
}
 
  
XMLMapperBuilder：
 
  
private ResultMap resultMapElement(XNode resultMapNode) throws Exception {
    /* 解析标签 */
    return resultMapElement(resultMapNode, Collections.<ResultMapping> emptyList());
}
 
  
XMLMapperBuilder：
 
  
private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings) throws Exception {
    ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
    // 提取id属性
    String id = resultMapNode.getStringAttribute("id",
        resultMapNode.getValueBasedIdentifier());
    // 按优先级提取type属性
    String type = resultMapNode.getStringAttribute("type",
        resultMapNode.getStringAttribute("ofType",
            resultMapNode.getStringAttribute("resultType",
                resultMapNode.getStringAttribute("javaType"))));
    // 提取extends配置
    String extend = resultMapNode.getStringAttribute("extends");
    // 提取autoMapping配置
    Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
    Class<?> typeClass = resolveClass(type);
    Discriminator discriminator = null;
    List<ResultMapping> resultMappings = new ArrayList<ResultMapping>();
    resultMappings.addAll(additionalResultMappings);
    List<XNode> resultChildren = resultMapNode.getChildren();
    for (XNode resultChild : resultChildren) {
        if ("constructor".equals(resultChild.getName())) {
            /* 处理子标签 */
            processConstructorElement(resultChild, typeClass, resultMappings);
        } else if ("discriminator".equals(resultChild.getName())) {
            /* 处理子标签 */
            discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
        } else {
            List<ResultFlag> flags = new ArrayList<ResultFlag>();
            if ("id".equals(resultChild.getName())) {
                // 如果是子标签，添加标记
                flags.add(ResultFlag.ID);
            }
            /* 构建ResultMapping */
            resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
        }
    }
    ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
    try {
        /* 解析返回ResultMap */
        return resultMapResolver.resolve();
    } catch (IncompleteElementException  e) {
        // 添加到未完成解析的ResultMap集合中，后续继续解析
        configuration.addIncompleteResultMap(resultMapResolver);
        throw e;
    }
}
 
  
XMLMapperBuilder：
 
  
private void processConstructorElement(XNode resultChild, Class<?> resultType, List<ResultMapping> resultMappings) throws Exception {
    List<XNode> argChildren = resultChild.getChildren();
    for (XNode argChild : argChildren) {
        List<ResultFlag> flags = new ArrayList<ResultFlag>();
        flags.add(ResultFlag.CONSTRUCTOR);
        if ("idArg".equals(argChild.getName())) {
            // 如果子标签是添加标记
            flags.add(ResultFlag.ID);
        }
        /* 构建并添加ResultMapping */
        resultMappings.add(buildResultMappingFromContext(argChild, resultType, flags));
    }
}
 
  
XMLMapperBuilder：
 
  
private ResultMapping buildResultMappingFromContext(XNode context, Class<?> resultType, List<ResultFlag> flags) throws Exception {
    String property; // 提取属性，提取name，其他标签提取property
    if (flags.contains(ResultFlag.CONSTRUCTOR)) {
        property = context.getStringAttribute("name");
    } else {
        property = context.getStringAttribute("property");
    }
    // 下面是各种标签属性的提取
    String column = context.getStringAttribute("column");
    String javaType = context.getStringAttribute("javaType");
    String jdbcType = context.getStringAttribute("jdbcType");
    String nestedSelect = context.getStringAttribute("select");
    /* 递归处理嵌套的resultMapping */
    String nestedResultMap = context.getStringAttribute("resultMap",
        processNestedResultMappings(context, Collections.<ResultMapping> emptyList()));
    String notNullColumn = context.getStringAttribute("notNullColumn");
    String columnPrefix = context.getStringAttribute("columnPrefix");
    String typeHandler = context.getStringAttribute("typeHandler");
    String resultSet = context.getStringAttribute("resultSet");
    String foreignColumn = context.getStringAttribute("foreignColumn");
    boolean lazy = "lazy".equals(context.getStringAttribute("fetchType", configuration.isLazyLoadingEnabled() ? "lazy" : "eager"));
    // 获取javaType配置的类名或类别名对应的Class对象
    Class<?> javaTypeClass = resolveClass(javaType);
    @SuppressWarnings("unchecked")
    // 获取typeHandler配置的类名或类别名对应的Class对象
    Class<? extends TypeHandler<?>> typeHandlerClass = (Class<? extends TypeHandler<?>>) resolveClass(typeHandler);
    // 根据jdbcType配置的名称在枚举找到对应的枚举值
    JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
    /* 构建ResultMapping */
    return builderAssistant.buildResultMapping(resultType, property, column, javaTypeClass, jdbcTypeEnum, nestedSelect, nestedResultMap, notNullColumn, columnPrefix, typeHandlerClass, flags, resultSet, foreignColumn, lazy);
}
 
  
XMLMapperBuilder：
 
  
private String processNestedResultMappings(XNode context, List<ResultMapping> resultMappings) throws Exception {
    if ("association".equals(context.getName())
        || "collection".equals(context.getName())
        || "case".equals(context.getName())) {
        if (context.getStringAttribute("select") == null) {
            // 如果是、、三个标签中的一个并且没有配置select属性，则递归解析成ResultMap对象
            ResultMap resultMap = resultMapElement(context, resultMappings);
            return resultMap.getId();
        }
    }
    return null;
}
 
  
MapperBuilderAssistant：
 
  
public ResultMapping buildResultMapping(
    Class<?> resultType,
    String property,
    String column,
    Class<?> javaType,
    JdbcType jdbcType,
    String nestedSelect,
    String nestedResultMap,
    String notNullColumn,
    String columnPrefix,
    Class<? extends TypeHandler<?>> typeHandler,
    List<ResultFlag> flags,
    String resultSet,
    String foreignColumn,
    boolean lazy) {
    // 如果配置了javaType则返回javaType对应的Class对象，如果没有配置，则根据父标签配置的类型的相关property属性的相关setter方法的参数类型当做javaType返回
    Class<?> javaTypeClass = resolveResultJavaType(resultType, property, javaType);
    // 从TypeHandler映射中获取对应的TypeHandler，如果获取不到，则通过javaTypeClass和typeHandlerClass实例化TypeHandler
    TypeHandler<?> typeHandlerInstance = resolveTypeHandler(javaTypeClass, typeHandler);
    /* 解析组合的column属性 */
    List<ResultMapping> composites = parseCompositeColumnName(column);
    // 将解析后的每个属性封装到ResultMapping对象中返回
    return new ResultMapping.Builder(configuration, property, column, javaTypeClass)
        .jdbcType(jdbcType)
        .nestedQueryId(applyCurrentNamespace(nestedSelect, true))
        .nestedResultMapId(applyCurrentNamespace(nestedResultMap, true))
        .resultSet(resultSet)
        .typeHandler(typeHandlerInstance)
        .flags(flags == null ? new ArrayList<ResultFlag>() : flags)
        .composites(composites)
        .notNullColumns(parseMultipleColumnNames(notNullColumn))
        .columnPrefix(columnPrefix)
        .foreignColumn(foreignColumn)
        .lazy(lazy)
        .build();
}
 
  
MapperBuilderAssistant：
 
  
private List<ResultMapping> parseCompositeColumnName(String columnName) {
    List<ResultMapping> composites = new ArrayList<ResultMapping>();
    // column属性可以这样配置：column="{prop1=col1,prop2=col2}"
    if (columnName != null && (columnName.indexOf('=') > -1 || columnName.indexOf(',') > -1)) {
        StringTokenizer parser = new StringTokenizer(columnName, "{}=, ", false);
        while (parser.hasMoreTokens()) {
            String property = parser.nextToken(); // prop1
            String column = parser.nextToken(); // col1
            // 将解析后的属性封装到ResultMapping对象中
            ResultMapping complexResultMapping = new ResultMapping.Builder(
                configuration, property, column, configuration.getTypeHandlerRegistry().getUnknownTypeHandler()).build();
            composites.add(complexResultMapping);
        }
    }
    return composites;
}
 
  
下面我们来看子标签的解析：
 XMLMapperBuilder：
 
  
private Discriminator processDiscriminatorElement(XNode context, Class<?> resultType, List<ResultMapping> resultMappings) throws Exception {
    // 各个属性的提取
    String column = context.getStringAttribute("column");
    String javaType = context.getStringAttribute("javaType");
    String jdbcType = context.getStringAttribute("jdbcType");
    String typeHandler = context.getStringAttribute("typeHandler");
    // 获取javaType配置的类名或类别名对应的Class对象
    Class<?> javaTypeClass = resolveClass(javaType);
    // 获取typeHandler配置的类名或类别名对应的Class对象
    @SuppressWarnings("unchecked")
    Class<? extends TypeHandler<?>> typeHandlerClass = (Class<? extends TypeHandler<?>>) resolveClass(typeHandler);
    // 根据jdbcType配置的名称在枚举找到对应的枚举值
    JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
    Map<String, String> discriminatorMap = new HashMap<String, String>();
    // 子标签
    for (XNode caseChild : context.getChildren()) {
        // 提取value属性
        String value = caseChild.getStringAttribute("value");
        // 提取resultMap属性，递归处理嵌套的resultMapping，上面已经分析过
        String resultMap = caseChild.getStringAttribute("resultMap", processNestedResultMappings(caseChild, resultMappings));
        discriminatorMap.put(value, resultMap);
    }
    /* 构建鉴别器 */
    return builderAssistant.buildDiscriminator(resultType, column, javaTypeClass, jdbcTypeEnum, typeHandlerClass, discriminatorMap);
}
 
  
MapperBuilderAssistant：
 
  
public Discriminator buildDiscriminator(
    Class<?> resultType,
    String column,
    Class<?> javaType,
    JdbcType jdbcType,
    Class<? extends TypeHandler<?>> typeHandler,
    Map<String, String> discriminatorMap) {
    // 构建ResultMapping
    ResultMapping resultMapping = buildResultMapping(
        resultType,
        null,
        column,
        javaType,
        jdbcType,
        null,
        null,
        null,
        null,
        typeHandler,
        new ArrayList<ResultFlag>(),
        null,
        null,
        false);
    Map<String, String> namespaceDiscriminatorMap = new HashMap<String, String>();
    for (Map.Entry<String, String> e : discriminatorMap.entrySet()) {
        String resultMap = e.getValue();
        // 应用当前命名空间，命名空间+resultMap的id
        resultMap = applyCurrentNamespace(resultMap, true);
        namespaceDiscriminatorMap.put(e.getKey(), resultMap);
    }
    // 将解析好的属性封装到Discriminator对象中构建鉴别器
    return new Discriminator.Builder(configuration, resultMapping, namespaceDiscriminatorMap).build();
}
 
  
接下来就是构建并返回ResultMap对象了：
 
  
public ResultMap resolve() {
    /* 将resultMap添加到configuration对象中并返回 */
    return assistant.addResultMap(this.id, this.type, this.extend, this.discriminator, this.resultMappings, this.autoMapping);
}
 
  
MapperBuilderAssistant：
 
  
public ResultMap addResultMap(
    String id,
    Class<?> type,
    String extend,
    Discriminator discriminator,
    List<ResultMapping> resultMappings,
    Boolean autoMapping) {
    // 分别对id和extend应用当前命名空间，命名空间+resultMap的id
    id = applyCurrentNamespace(id, false);
    extend = applyCurrentNamespace(extend, true);
    if (extend != null) {
        // 如果configuration对象中不包含extend对应的resultMap，抛出IncompleteElementException，添加到未完成解析的ResultMap集合中，后续继续解析
        if (!configuration.hasResultMap(extend)) {
            throw new IncompleteElementException("Could not find a parent resultmap with id '" + extend + "'");
        }
        // 获取configuration对象中extend对应的resultMap
        ResultMap resultMap = configuration.getResultMap(extend);
        // 复制一份extend对应的resultMap中的resultMapping
        List<ResultMapping> extendedResultMappings = new ArrayList<ResultMapping>(resultMap.getResultMappings());
        // 移除掉与当前resultMap中相同的resultMapping
        extendedResultMappings.removeAll(resultMappings);
        boolean declaresConstructor = false;
        for (ResultMapping resultMapping : resultMappings) {
            // 如果有CONSTRUCTOR标记也就是包含标签，做一个标记
            if (resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR)) {
                declaresConstructor = true;
                break;
            }
        }
        // 如果当前resultMap中配置了标签，则溢出extend对应的resultMap中标记为CONSTRUCTOR的resultMapping
        if (declaresConstructor) {
            Iterator<ResultMapping> extendedResultMappingsIter = extendedResultMappings.iterator();
            while (extendedResultMappingsIter.hasNext()) {
                if (extendedResultMappingsIter.next().getFlags().contains(ResultFlag.CONSTRUCTOR)) {
                    extendedResultMappingsIter.remove();
                }
            }
        }
        // 将extend对应的resultMapping添加到当前resultMapping集合中
        resultMappings.addAll(extendedResultMappings);
    }
    // 将解析好的各个属性封装到ResultMap对象中返回
    ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping)
    .discriminator(discriminator)
    .build();
    // 添加到configuration对象的ResultMap映射集合中
    configuration.addResultMap(resultMap);
    return resultMap;
}
 
  
标签的解析到这里就完成了，下面是标签的解析：
 XMLMapperBuilder：
 
  
private void sqlElement(List<XNode> list) throws Exception {
    if (configuration.getDatabaseId() != null) {
        /* 解析sql标签，携带databaseId配置 */
        sqlElement(list, configuration.getDatabaseId());
    }
    /* 解析sql标签，不带databaseId配置 */
    sqlElement(list, null);
}
 
  
XMLMapperBuilder：
 
  
private void sqlElement(List<XNode> list, String requiredDatabaseId) throws Exception {
    for (XNode context : list) {
        // 提取databaseId配置
        String databaseId = context.getStringAttribute("databaseId");
        // 提取id配置
        String id = context.getStringAttribute("id");
        // 应用当前命名空间，命名空间+配置的id
        id = builderAssistant.applyCurrentNamespace(id, false);
        /* 判断databaseId配置是否匹配 */
        if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) {
            // 添加映射关系
            sqlFragments.put(id, context);
        }
    }
}
 
  
XMLMapperBuilder：
 
  
private boolean databaseIdMatchesCurrent(String id, String databaseId, String requiredDatabaseId) {
    // 如果配置了全局的databaseId，当判断当前标签配置的databaseId与全局的databaseId是否相同
    if (requiredDatabaseId != null) {
        if (!requiredDatabaseId.equals(databaseId)) {
            return false;
        }
    } else {
        // 如果没有配置全局的databaseId，则当前标签也不能配置databaseId
        if (databaseId != null) {
            return false;
        }
        // 如果id已经在映射关系中存在，则判断是否配置了databaseId
        if (this.sqlFragments.containsKey(id)) {
            XNode context = this.sqlFragments.get(id);
            if (context.getStringAttribute("databaseId") != null) {
                return false;
            }
        }
    }
    return true;
}
 
  
这里的标签解析只是添加了映射，真正的应用才后面。下面是、、、四个标签的解析：
 XMLMapperBuilder：
 
  
private void buildStatementFromContext(List<XNode> list) {
    if (configuration.getDatabaseId() != null) {
        /* 解析，携带databaseId配置 */
        buildStatementFromContext(list, configuration.getDatabaseId());
    }
    /* 解析，不带databaseId配置 */
    buildStatementFromContext(list, null);
}
 
  
XMLMapperBuilder：
 
  
private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    for (XNode context : list) {
        final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
        try {
            /* 解析 */
            statementParser.parseStatementNode();
        } catch (IncompleteElementException e) {
            // 添加到未完成解析statement元素集合中，后续继续解析
            configuration.addIncompleteStatement(statementParser);
        }
    }
}
 
  
XMLStatementBuilder：
 
  
public void parseStatementNode() {
    // 提取id配置
    String id = context.getStringAttribute("id");
    // 提取databaseId配置
    String databaseId = context.getStringAttribute("databaseId");
    // 判断是否匹配，上面分析过
    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
        return;
    }
    // 各个属性的提取
    Integer fetchSize = context.getIntAttribute("fetchSize");
    Integer timeout = context.getIntAttribute("timeout");
    String parameterMap = context.getStringAttribute("parameterMap");
    String parameterType = context.getStringAttribute("parameterType");
    // 获取parameterType配置的类名或类别名对应的Class对象
    Class<?> parameterTypeClass = resolveClass(parameterType);
    String resultMap = context.getStringAttribute("resultMap");
    String resultType = context.getStringAttribute("resultType");
    String lang = context.getStringAttribute("lang");
    // 获取lang配置对应的语言驱动，在构造Configuration对象时，Mybatis注册了XMLLanguageDriver、RawLanguageDriver两个语言驱动，并将XMLLanguageDriver设置为默认的语言驱动
    LanguageDriver langDriver = getLanguageDriver(lang);
    // 获取resultType配置的类名或类别名对应的Class对象
    Class<?> resultTypeClass = resolveClass(resultType);
    String resultSetType = context.getStringAttribute("resultSetType");
    // 根据statementType配置的名称在枚举找到对应的枚举值，默认为PREPARED
    StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
    // 根据resultSetType配置的名称在枚举找到对应的枚举值
    ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
    String nodeName = context.getNode().getNodeName();
    // 根据标签的名称在SqlCommandType枚举中找到对应的枚举值，如对应SELECT枚举值
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    // 提取flushCache配置，标签默认为false，其他为true
    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    // 提取useCache配置，标签默认为true，其他为false
    boolean useCache = context.getBooleanAttribute("useCache", isSelect);
    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    /* 应用包含的片段 */
    includeParser.applyIncludes(context.getNode());
    /* 解析标签 */
    processSelectKeyNodes(id, parameterTypeClass, langDriver);
    /* 创建SqlSource */
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
    String resultSets = context.getStringAttribute("resultSets");
    String keyProperty = context.getStringAttribute("keyProperty");
    String keyColumn = context.getStringAttribute("keyColumn");
    KeyGenerator keyGenerator;
    String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
    // 应用当前命名空间，命名空间+keyStatementId 
    keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
    // 不同情况的KeyGenerator选择
    if (configuration.hasKeyGenerator(keyStatementId)) {
        keyGenerator = configuration.getKeyGenerator(keyStatementId);
    } else {
        keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
            configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
        ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
    }
    /* 构建MappedStatement并添加到configuration对象中 */
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered, 
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}
 
  
XMLIncludeTransformer：
 
  
public void applyIncludes(Node source) {
    Properties variablesContext = new Properties();
    Properties configurationVariables = configuration.getVariables();
    if (configurationVariables != null) {
        // 复制一份configuration对象中的全局变量
        variablesContext.putAll(configurationVariables);
    }
    /* 应用包含的sql片段 */
    applyIncludes(source, variablesContext, false);
}
 
  
XMLIncludeTransformer：
 
  
private void applyIncludes(Node source, final Properties variablesContext, boolean included) {
    // 如果是标签
    if (source.getNodeName().equals("include")) {
        /* 提取refid对应的sql片段的Node */
        Node toInclude = findSqlFragment(getStringAttribute(source, "refid"), variablesContext);
        /* 从节点定义中读取占位符和它们的值 */
        Properties toIncludeContext = getVariablesContext(source, variablesContext);
        // 将包含的sql片段节点作为参数递归此方法
        applyIncludes(toInclude, toIncludeContext, true);
        if (toInclude.getOwnerDocument() != source.getOwnerDocument()) {
            // 如果当前节点和被包含节点不在同一个文档中，则将被包含节点导入当前节点所在的文档中
            toInclude = source.getOwnerDocument().importNode(toInclude, true);
        }
        // 将当前节点替换成被包含节点
        source.getParentNode().replaceChild(toInclude, source);
        while (toInclude.hasChildNodes()) {
            // 将子节点放在被包含节点的前面
            toInclude.getParentNode().insertBefore(toInclude.getFirstChild(), toInclude);
        }
        // 从父节点中移除被包含节点
        toInclude.getParentNode().removeChild(toInclude);
    } else if (source.getNodeType() == Node.ELEMENT_NODE) {
        NodeList children = source.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            // 如果是元素类型的Node如，就遍历子节点递归此方法
            applyIncludes(children.item(i), variablesContext, included);
        }
    } else if (included && source.getNodeType() == Node.TEXT_NODE
        && !variablesContext.isEmpty()) {
        // 如果是文本类型的Node，则解析并设置节点值，主要是替换节点值中声明的变量如${var1}
        source.setNodeValue(PropertyParser.parse(source.getNodeValue(), variablesContext));
    }
}
 
  
XMLIncludeTransformer：
 
  
private Node findSqlFragment(String refid, Properties variables) {
    // 解析refid中声明的变量，如${var1}
    refid = PropertyParser.parse(refid, variables);
    // 应用当前命名空间，命名空间+refid
    refid = builderAssistant.applyCurrentNamespace(refid, true);
    try {
        // 根据refid从之前解析标签时添加的映射中获取对应的节点
        XNode nodeToInclude = configuration.getSqlFragments().get(refid);
        // 复制一份返回
        return nodeToInclude.getNode().cloneNode(true);
    } catch (IllegalArgumentException e) {
        throw new IncompleteElementException("Could not find SQL statement to include with refid '" + refid + "'", e);
    }
}
 
  
XMLIncludeTransformer：
 
  
private Properties getVariablesContext(Node node, Properties inheritedVariablesContext) {
    Map<String, String> declaredProperties = null;
    NodeList children = node.getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
        Node n = children.item(i); // 子节点也就是标签
        if (n.getNodeType() == Node.ELEMENT_NODE) {
            // 提取name属性
            String name = getStringAttribute(n, "name");
            // 提取value属性，并解析属性值中声明的变量
            String value = PropertyParser.parse(getStringAttribute(n, "value"), inheritedVariablesContext);
            if (declaredProperties == null) {
                declaredProperties = new HashMap<String, String>();
            }
            // 添加到声明的属性映射中
            if (declaredProperties.put(name, value) != null) {
                // 重复声明抛异常
                throw new BuilderException("Variable " + name + " defined twice in the same include definition");
            }
        }
    }
    if (declaredProperties == null) {
        // 声明属性为空直接返回继承的全局变量
        return inheritedVariablesContext;
    } else {
        // 声明属性不为空则将两者放入新的Properties对象中返回
        Properties newProperties = new Properties();
        newProperties.putAll(inheritedVariablesContext);
        newProperties.putAll(declaredProperties);
        return newProperties;
    }
}
 
  
下面是标签的解析
 XMLStatementBuilder：
 
  
private void processSelectKeyNodes(String id, Class<?> parameterTypeClass, LanguageDriver langDriver) {
    List<XNode> selectKeyNodes = context.evalNodes("selectKey");
    if (configuration.getDatabaseId() != null) {
        /* 解析selectKey节点，携带databaseId配置 */
        parseSelectKeyNodes(id, selectKeyNodes, parameterTypeClass, langDriver, configuration.getDatabaseId());
    }
    /* 解析selectKey节点，不带databaseId配置 */
    parseSelectKeyNodes(id, selectKeyNodes, parameterTypeClass, langDriver, null);
    // 解析完成之后从父节点中移除掉
    removeSelectKeyNodes(selectKeyNodes);
}
 
  
XMLStatementBuilder：
 
  
private void parseSelectKeyNodes(String parentId, List<XNode> list, Class<?> parameterTypeClass, LanguageDriver langDriver, String skRequiredDatabaseId) {
    for (XNode nodeToHandle : list) {
        // 设置id为父节点的id属性加上!selectKey后缀
        String id = parentId + SelectKeyGenerator.SELECT_KEY_SUFFIX;
        String databaseId = nodeToHandle.getStringAttribute("databaseId");
        // 判断databaseId配置是否匹配，上文分析过
        if (databaseIdMatchesCurrent(id, databaseId, skRequiredDatabaseId)) {
            /* 解析selectKey节点 */
            parseSelectKeyNode(id, nodeToHandle, parameterTypeClass, langDriver, databaseId);
        }
    }
}
 
  
XMLStatementBuilder：
 
  
private void parseSelectKeyNode(String id, XNode nodeToHandle, Class<?> parameterTypeClass, LanguageDriver langDriver, String databaseId) {
    // 各个属性的提取
    String resultType = nodeToHandle.getStringAttribute("resultType");
    // 解析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"));
    // 一些默认值的声明
    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;
    /* 创建SqlSource */
    SqlSource sqlSource = langDriver.createSqlSource(configuration, nodeToHandle, parameterTypeClass);
    SqlCommandType sqlCommandType = SqlCommandType.SELECT;
    /* 添加MappedStatement */
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered,
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, null);
    // 应用当前命名空间，命名空间+id
    id = builderAssistant.applyCurrentNamespace(id, false);
    MappedStatement keyStatement = configuration.getMappedStatement(id, false);
    // 添加SelectKeyGenerator，在sql执行前后为参数赋相应的值
    configuration.addKeyGenerator(id, new SelectKeyGenerator(keyStatement, executeBefore));
}
 
  
XMLLanguageDriver：
 
  
 public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
     XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
     /* 解析节点，创建SqlSource */
     return builder.parseScriptNode();
 }
 
  
XMLScriptBuilder：
 
  
public SqlSource parseScriptNode() {
    /* 解析动态标签 */
    List<SqlNode> contents = parseDynamicTags(context);
    MixedSqlNode rootSqlNode = new MixedSqlNode(contents);
    SqlSource sqlSource = null;
    // 根据解析时判断的是否是动态标签的结果来创建不同的SqlSource
    if (isDynamic) {
        sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
    } else {
        sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
    }
    return sqlSource;
}
 
  
XMLScriptBuilder：
 
  
List<SqlNode> parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<SqlNode>();
    NodeList children = node.getNode().getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
        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);
            /* 判断文本类型的node是否是动态的 */
            if (textSqlNode.isDynamic()) {
                contents.add(textSqlNode);
                isDynamic = true;
            } else {
                contents.add(new StaticTextSqlNode(data));
            }
      } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) {
          String nodeName = child.getNode().getNodeName();
          /* 获取动态节点的处理器 */
          NodeHandler handler = nodeHandlers(nodeName);
          if (handler == null) {
              throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
          }
          /* 处理动态节点 */
          handler.handleNode(child, contents);
          isDynamic = true;
      }
  }
  return contents;
}
 
  
TextSqlNode：
 
  
public boolean isDynamic() {
    DynamicCheckerTokenParser checker = new DynamicCheckerTokenParser();
    /* 创建解析器 */
    GenericTokenParser parser = createParser(checker);
    /* 解析 */
    parser.parse(text);
    return checker.isDynamic();
}
 
  
TextSqlNode：
 
  
private GenericTokenParser createParser(TokenHandler handler) {
    return new GenericTokenParser("${", "}", handler);
}
 
  
GenericTokenParser：
 
  
public String parse(String text) {
    if (text == null || text.isEmpty()) {
        return ""; // 文本为空返回空字符串
    }
    char[] src = text.toCharArray();
    int offset = 0;
    // openToken：${，closeToken：}
    int start = text.indexOf(openToken, offset);
    if (start == -1) {
        return text; // openToken在文本中不存在，返回文本
    }
    final StringBuilder builder = new StringBuilder();
    StringBuilder expression = null;
    while (start > -1) {
        // 如果openToken前面是反斜杠\转义字符，移除掉并继续
        if (start > 0 && src[start - 1] == '\\') {
            builder.append(src, offset, start - offset - 1).append(openToken);
            offset = start + openToken.length();
        } else {
            // 找到了openToken，下面要找closeToken
            if (expression == null) {
                expression = new StringBuilder();
            } else {
                expression.setLength(0);
            }
            builder.append(src, offset, start - offset);
            offset = start + openToken.length();
            int end = text.indexOf(closeToken, offset);
            while (end > -1) {
                if (end > offset && src[end - 1] == '\\') {
                    // 同样的，如果closeToken前面是反斜杠\转义字符，移除掉并继续
                    expression.append(src, offset, end - offset - 1).append(closeToken);
                    offset = end + closeToken.length();
                    end = text.indexOf(closeToken, offset);
                } else {
                    expression.append(src, offset, end - offset);
                    offset = end + closeToken.length();
                    break;
                }
            }
            if (end == -1) {
                // closeToken没有找到的情况
                builder.append(src, start, src.length - start);
                offset = src.length;
            } else {
                /* 处理表达式 */
                builder.append(handler.handleToken(expression.toString()));
                offset = end + closeToken.length();
            }
        }
        start = text.indexOf(openToken, offset);
    }
    if (offset < src.length) {
        builder.append(src, offset, src.length - offset);
    }
    return builder.toString();
}
 
  
TextSqlNode.DynamicCheckerTokenParser：
 
  
public String handleToken(String content) {
    this.isDynamic = true; // 将动态标记设置为true
    return null;
}
 
  
XMLScriptBuilder：
 
  
NodeHandler nodeHandlers(String nodeName) {
    Map<String, NodeHandler> map = new HashMap<String, NodeHandler>();
    map.put("trim", new TrimHandler());
    map.put("where", new WhereHandler());
    map.put("set", new SetHandler());
    map.put("foreach", new ForEachHandler());
    map.put("if", new IfHandler());
    map.put("choose", new ChooseHandler());
    map.put("when", new IfHandler());
    map.put("otherwise", new OtherwiseHandler());
    map.put("bind", new BindHandler());
    return map.get(nodeName);
}
 
  
这里我们看到了Mybatis提供的一些动态标签的处理器，如、、等，我们以标签为例来看它如何处理动态标签，而处理过后节点的应用则是在mapper方法执行的过程中，我们会在后续的文章中进行详细讲解，其他动态标签的处理也是类似的：
 XMLScriptBuilder.IfHandler：
 
  
public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
    // 递归解析当前节点的动态子节点
    List<SqlNode> contents = parseDynamicTags(nodeToHandle);
    MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
    // 提取标签test属性配置
    String test = nodeToHandle.getStringAttribute("test");
    // 构建相关Node节点
    IfSqlNode ifSqlNode = new IfSqlNode(mixedSqlNode, test);
    targetContents.add(ifSqlNode);
}
 
  
解析标签最后是构建并添加MappedStatement：
 MapperBuilderAssistant：
 
  
public MappedStatement addMappedStatement(
    String id,
    SqlSource sqlSource,
    StatementType statementType,
    SqlCommandType sqlCommandType,
    Integer fetchSize,
    Integer timeout,
    String parameterMap,
    Class<?> parameterType,
    String resultMap,
    Class<?> resultType,
    ResultSetType resultSetType,
    boolean flushCache,
    boolean useCache,
    boolean resultOrdered,
    KeyGenerator keyGenerator,
    String keyProperty,
    String keyColumn,
    String databaseId,
    LanguageDriver lang,
    String resultSets) {
    if (unresolvedCacheRef) {
        throw new IncompleteElementException("Cache-ref not yet resolved");
    }
    // 应用当前命名空间，命名空间+id
    id = applyCurrentNamespace(id, false);
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    // 将各个解析好的属性复制给MappedStatement.Builder对象中的MappedStatement实例的各个属性
    MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
        .resource(resource)
        .fetchSize(fetchSize)
        .timeout(timeout)
        .statementType(statementType)
        .keyGenerator(keyGenerator)
        .keyProperty(keyProperty)
        .keyColumn(keyColumn)
        .databaseId(databaseId)
        .lang(lang)
        .resultOrdered(resultOrdered)
        .resultSets(resultSets)
        .resultMaps(getStatementResultMaps(resultMap, resultType, id))
        .resultSetType(resultSetType)
        .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
        .useCache(valueOrDefault(useCache, isSelect))
        .cache(currentCache);
    /* 获取参数映射 */
    ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
    if (statementParameterMap != null) {
        statementBuilder.parameterMap(statementParameterMap);
    }
    // 返回MappedStatement对象
    MappedStatement statement = statementBuilder.build();
    // 添加到configuration对象中
    configuration.addMappedStatement(statement);
    return statement;
}
 
  
MapperBuilderAssistant：
 
  
private ParameterMap getStatementParameterMap(
    String parameterMapName,
    Class<?> parameterTypeClass,
    String statementId) {
    parameterMapName = applyCurrentNamespace(parameterMapName, true);
    ParameterMap parameterMap = null;
    // parameterMap已经不推荐使用
    if (parameterMapName != null) {
        try {
            parameterMap = configuration.getParameterMap(parameterMapName);
        } catch (IllegalArgumentException e) {
            throw new IncompleteElementException("Could not find parameter map " + parameterMapName, e);
        }
    } else if (parameterTypeClass != null) {
        List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
        // paramType方式的配置，构建ParameterMap对象
        parameterMap = new ParameterMap.Builder(
            configuration,
            statementId + "-Inline",
            parameterTypeClass,
            parameterMappings).build();
    }
    return parameterMap;
}
 
  
标签解析完成了，下面会继续、、、四个标签的解析，后面的流程在解析标签时已经分析过，同样都会创建SqlSource、解析动态标签、构建MappedStatement等，这里不再赘述。最后就是将解析好的Configuration对象封装到DefaultSqlSessionFactory中返回。
 SqlSessionFactoryBuilder：
 
  
public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}
 
  
到这里，整个Mybatis标签解析的源码就分析完了。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(MyBatis)
        

            

                

                    
insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
                    
                    
MyBatis 详解
                        阿贾克斯的黎明
javamybatis
                        
目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
                    
                    
mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析
                        weixin_39844942
mybatis二级缓存失效
                        
这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
                    
                    
详解mybatis的一二级缓存以及缓存失效原因
                        仰望天花板
缓存数据库mybatisjavamysql
                        
数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
                    
                    
36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
                    
                    
MyBatis批量插入大量数据
                        小黑屋说YYDS
MyBatisjava
                        
1.思路分析批量插入这个问题，我们用JDBC操作，其实就是两种思路吧：用一个for循环，把数据一条一条的插入（这种需要开启批处理）。生成一条插入sql，类似这种insertintouser(username,address)values(‘aa’,‘bb’),(‘cc’,‘dd’)…。到底哪种快呢？我们从两方面来考虑这个问题：插入SQL本身执行的效率。网络I/O。先说第一种方案，就是用for循环循
                    
                    
MyBatis 查询数据库_mybatis查询某个库的所有表名(2)
                        2401_84181942
程序员mybatisoracletomcat
                        
标签说明：***``标签**：需要指定namespace属性，表示命名空间，值为mapper接口的全限定名，包括全包名.类名。***``查询标签**：是用来执行数据库的查询操作的：`id`：是和Interface（接口）中定义的方法名称一样的，表示对接口的具体实现方法。`resultType`：是返回的数据类型，也就是开头我们定义的实体类。####2.4.4添加Service服务层实现代码如下：@
                    
                    
5-【JavaWeb】JUnit 单元测试及JUL 日志系统
                        weixin_44329069
JavaWebjunit单元测试
                        
1.使用JUnit进行单元测试JUnit是Java中非常流行的单元测试框架，MyBatis与JUnit可以很好地结合，来测试持久层代码的正确性。1.1添加JUnit依赖在使用JUnit之前，需要在pom.xml中引入JUnit依赖。junitjunit4.13.2test1.2单元测试基本结构假设我们要测试UserMapper中的getUserById方法，测试代码如下：importorg.apa
                    
                    
【免费】springboot项目申报管理系统|毕业设计|Javaweb项目
                        计算机学姐来啦
springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee
                        
收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
                    
                    
MyBatis系统学习（一）——项目结构及其含义
                        OEC小胖胖
MyBatismybatis学习web后端
                        
1.MyBatis简介MyBatis是一款优秀的持久层框架，它通过SQL映射的方式实现Java对数据库操作的映射，既保留了SQL语句的灵活性，也简化了代码的编写。在一个MyBatis项目中，核心部分主要有：配置文件（mybatis-config.xml）映射文件（Mapper.xml）实体类（Entity/POJO）接口类（Mapper接口）MyBatis会话工厂（SqlSessionFactor
                    
                    
MyBatis 如何将 Mapper 接口与其 XML 映射文件关联：深入原理与实现
                        OEC小胖胖
web后端mybatisxmljavaweb后端
                        
MyBatis如何将Mapper接口与其XML映射文件关联：深入原理与实现1.概述MyBatis是一个简单、灵活的持久层框架，它通过SQL语句将Java对象与数据库进行映射。MyBatis支持基于XML和注解的配置方式。在实际开发中，XML映射文件与Mapper接口的关联是MyBatis的核心功能之一。通过这种关联，开发者可以在Mapper接口中定义方法，并在XML文件中编写SQL语句，从而实现数
                    
                    
Mybatis实现员工管理系统
                        wu1113_
mybatisjavamaven
                        
文章目录1.案例需求2.编程思路3.案例源码4.小结1.案例需求在上次做的父子模块的maven以及Ajax实现人工管理系统的基础上使用Mybatis实现员工管理系统的增删改查，具体运行效果如下：2.编程思路Mybatis框架的一般执行流程：创建MyBatis配置文件mybatis-config.xml在里面加载数据源、事务等，管理映射文件创建需要的映射文件mapper.xml，用于映射表中列和实体
                    
                    
springboot+mybatisplus实现基本的增删改查以及分页查询。这里使用的是Restful风格包括简单描述Restful是什么
                        okchan666
springbootjava
                        
先实现springboot+mybatisplus的增删改查接口使用postman测试：第一步创建项目导入依赖：直接给大家了：4.0.0org.springframework.bootspring-boot-starter-parent2.6.6com.okchanspringboot_07_ssmp0.0.1-SNAPSHOT1.8org.springframework.bootspring-b
                    
                    
MyBatis 方法重载的陷阱及解决方案
                        molashaonian
mybatis方法重载异常方法名相同
                        
在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
                    
                    
Spring Cloud+Spring Boot+Mybatis+Java版电子招标采购系统源码 及 功能清单
                        Xiaohong0716
mybatisjavaspringcloud
                        
一、立项管理1、招标立项申请功能点：招标类项目立项申请入口，用户可以保存为草稿，提交。2、非招标立项申请功能点：非招标立项申请入口、用户可以保存为草稿、提交。3、采购立项列表功能点：对草稿进行编辑，驳回的立项编辑，在途流程查看。二、项目管理1、采购计划管理功能点：采购计划新增、编辑、删除2、采购过程管理功能点：查询、维护基准价、组建评审小组、项目答疑澄清、文件费保证金审核、供应商报价维护、查看评审
                    
                    
BindingException: Invalid bound statement (not found)
                        小卡车555
MyBatismybatisjavamysql
                        
Mybatis出现绑定异常问题的解决org.apache.ibatis.binding.BindingException:Invalidboundstatement(notfound)一般的原因是Mapperinterface和xml文件的定义对应不上，需要检查包名，namespace，函数名称等能否对应上，需要比较细致的对比，我经常就是写错了一两个字母搞的很长时间找不到错误按以下步骤一一执行：1
                    
                    
工程项目管理系统源码与Spring Cloud：实现高效系统管理与二次开发
                        微服务技术分享
springcloudjava工程项目管理系统源码
                        
随着企业规模的不断扩大和业务的快速发展，传统的工程项目管理方式已经无法满足现代企业的需求。为了提高工程管理效率、减轻劳动强度、提高信息处理速度和准确性，企业需要借助先进的数字化技术进行转型。本文将介绍一款采用SpringCloud+SpringBoot+Mybatis技术框架的工程项目管理系统，该系统涵盖了项目管理、合同管理、预警管理、竣工管理、质量管理等多个方面，通过数据字典、编码管理、用户管理
                    
                    
[附源码]SSM计算机毕业设计游戏账号交易平台JAVA
                        计算机程序源码
java游戏mysql
                        
项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
                    
                    
Mybatis Mysql
                        莫夏_b560

                        
1、查询失败或者结果异常andfwbdh=#{fwbdh}更换成andfwbdh=#{fwbdh}
                    
                    
33. MyBatis中的@Param注解如何使用？如何在Mapper接口中传递多个参数？
                        这孩子叫逆
Mybatis笔记javamybatistomcat
                        
在MyBatis中，@Param注解用于将方法参数绑定到SQL语句中的命名参数。它主要用于在Mapper接口中传递多个参数，以便在SQL语句中更方便地引用这些参数。为什么使用@Param注解？在MyBatis中，当Mapper接口的方法只有一个参数时，MyBatis会默认将这个参数的名称绑定为#{parameter}，可以直接在SQL语句中引用它。如果方法有多个参数，MyBatis默认使用para
                    
                    
Python+Django毕业设计校园易购二手交易平台（程序+LW+部署）
                        Python、JAVA毕设程序源码
课程设计javamysql
                        
项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
                    
                    
Springboot3 整合 Mybatis3
                        （前程似锦）
mybatisjavaspringboot
                        
Springboot3整合MybatisSpringboot3整合MybatisSpringboot3整合Mybatis一、导入依赖二、编写配置文件三、定义模型entity实体类四、在启动类上添加注解，表示mapper接口所在位置五、定义mapper接口六、定义mapper.xml映射文件七、service层八、测试一、导入依赖mybatis的必要依赖注意：使用springboot3的话要使用my
                    
                    
mybatis支持json，Spring boot配置
                        Knight_9

                        
mysql5.7版本以后支持原生json格式，基于Springboot进行配置说明。mybatis支持mysql的json格式mysql-connector，mysql的驱动版本要大于等于5.1.40，否则json字段查询会发生乱码。继承BaseTypeHandler自定义一个json类型处理器，放到一个handler包下，例：packagecom.c.config.handler;importc
                    
                    
【Java】Mybatis Druid连接池配置详细
                        beautiful_huang
Java
                        
pom.xmlcom.alibabadruid1.0.18.propertiesspring.datasource.driver-class-name=com.mysql.jdbc.Driverspring.datasource.url=jdbc:mysql://localhost:3306/mybatis2?characterEncoding=utf-8&useSSL=truespring.da
                    
                    
关于com.baomidou:mybatis-plus-boot-starter:jar:unknown was not found解决办法
                        波斯CD
mybatisjarjava
                        
原型com.baomidoumybatis-plus-boot-starter修改以后解决了com.baomidoumybatis-plus-boot-starter3.5.3.1
                    
                    
MyBatis-Plus 3.5.5的代码生成器 实践【完整代码】
                        qq_43513957
mybatis
                        
MyBatis-Plus3.5.5的代码生成器实践【完整代码】1.表：要有一个version字段，乐观锁更新。配置拦截器的代码packagecom.example.demo.zmybatisplusGenerator.config;importcom.baomidou.mybatisplus.annotation.DbType;importcom.baomidou.mybatisplus.exte
                    
                    
深入解析 MyBatis：从理论到项目实例
                        OEC小胖胖
web后端mybatisjavaspringweb后端
                        
深入解析MyBatis：从理论到项目实例目录MyBatis概述MyBatis项目结构及作用核心概念详解分页功能的实现与深入剖析动态SQL缓存机制详解与Spring集成常见问题与深入分析完整项目示例总结1.MyBatis概述MyBatis是一个轻量级的持久层框架，使用SQL查询语句来访问数据库。它与Java对象建立映射关系，通过配置文件或注解来管理SQL语句，灵活性高且与数据库操作直接相关，适合需要
                    
                    
MyBatis Plus 实战详解
                        Aries263
redis分布式数据库
                        
一、引言MyBatisPlus（简称MP）是MyBatis的增强工具，旨在简化开发、提高效率。它保留了MyBatis的强大功能，并在其基础上进行了扩展和优化，提供了强大的CRUD操作、配置选项、条件构造器等功能。本文将详细介绍MyBatisPlus的安装、配置、基本操作以及分页和条件查询的使用。二、安装与配置1.添加依赖首先，在Maven项目的pom.xml中添加MyBatisPlus的依赖。以下
                    
                    
在springboot中，利用xml配置mybatis的方法
                        猪猡猪猡猪
javamybatismybatisspringbootxmljavamysql
                        
前置步骤参考博客：SpringBoot配置Mybatis的两种方式（通过XML配置和通过YML配置文件配置）_Darreni的博客-CSDN博客但按照博客中的关键代码和步骤创建的项目无法启动启动报错：Description:FailedtoconfigureaDataSource:'url’attributeisnotspecif:Reason:Failedtodetermineasuitable
                    
                    
MyBatis 学习笔记(4) 动态SQL
                        张云飞Vir

                        
1.背景本节讲mybatis应对动态SQL的场景。2.知识动态SQL是指“条件"不固定的SQL，对比于一般的SQL，动态SQL会有一个或者多个条件/参数。比如：场景：查询的时候，如果用户输入了姓名，就按姓名模糊查询；同时又输入了邮箱，就再增加一个条件按姓名+邮箱两个条件查询。传统的拼接SQL很费力，拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。借助功能强大的基于OGNL的
                    
                                
java数字签名三种方式
                                    知了ing
javajdk
                                    
以下3钟数字签名都是基于jdk7的 
1，RSA 
 

String password="test";
			// 1.初始化密钥
			KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
			keyPairGenerator.initialize(51
                                
                                
Hibernate学习笔记
                                    caoyong
Hibernate
                                    
1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 
2>、搭建Hibernate的开发环境 
     a>、添加jar包: 
      aa>、hibernatte开发包中/lib/required/所
                                
                                
设计模式之装饰器模式Decorator（结构型）
                                    漂泊一剑客
Decorator
                                    
1. 概述 
 
 
       若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。 
 
      
                                
                                
读取磁盘文件txt，并输入String
                                    一炮送你回车库
String
                                    
public static void main(String[] args) throws IOException { 
  
 String fileContent = readFileContent("d:/aaa.txt"); 
  
 System.out.println(fileContent); 
   

                                
                                
js三级联动下拉框
                                    3213213333332132
三级联动
                                    

//三级联动  
   省/直辖市<select id="province"></select>  
   市/省直辖<select id="city"></select>  
   县/区 <select id="area"></select>  
  
                                
                                
erlang之parse_transform编译选项的应用
                                    616050468
parse_transform游戏服务器属性同步abstract_code
                                    
         最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
                                
                                
JAVA JSON的解析
                                    darkranger
java
                                    

 
//		{
//			“Total”：“条数”，
//			 Code: 1,
//
//			“PaymentItems”:[
//			{
//			“PaymentItemID”:”支款单ID”,
//			“PaymentCode”:”支款单编号”,
//			“PaymentTime”:”支款日期”,
//			”ContractNo”:”合同号”，
//	
                                
                                
POJ-1273-Drainage Ditches
                                    aijuans
ACM_POJ
                                    
POJ-1273-Drainage Ditches 
http://poj.org/problem?id=1273 
基本的最大流，按LRJ的白书写的 
 
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
#define INF 0x7fffffff
int ma
                                
                                
工作流Activiti5表的命名及含义
                                    atongyeye
工作流Activiti
                                    
activiti5 - http://activiti.org/designer/update在线插件安装 
 
activiti5一共23张表 
 
 
Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 
 
ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。 
 
A
                                
                                
android的广播机制和广播的简单使用
                                    百合不是茶
android广播机制广播的注册
                                    
      Android广播机制简介  在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
                                
                                
Spring事务传播行为详解
                                    bijian1013
javaspring事务传播行为
                                    
        在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。 
        Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
                                
                                
eidtplus operate
                                    征客丶
eidtplus
                                    
开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动 
列模式替换或复制内容(多行): 
右键-->格式-->填充所选内容-->选择相应操作 
OR 
Ctrl+Shift+V(复制多行数据,必须行数一致) 
 
-------------------------------------------------------
                                
                                
【Kafka一】Kafka入门
                                    bit1129
kafka
                                    
这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧 
  下载Kafka 
 http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 
 2.10表示Scala的版本，而0.8.1.1表示Kafka
                                
                                
Spring 事务实现机制
                                    BlueSkator
spring代理事务
                                    
Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口 
                                
                                
bootstrap源码学习与示例：bootstrap-dropdown（转帖）
                                    BreakingBad
bootstrapdropdown
                                    
bootstrap-dropdown组件是个烂东西，我读后的整体感觉。 
一个下拉开菜单的设计： 
                  <ul class="nav pull-right">
                        <li id="fat-menu" class="dropdown">

                                
                                
读《研磨设计模式》-代码笔记-中介者模式-Mediator
                                    bylijinnan
java设计模式
                                    
声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/*
 * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。
 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
 * 
 * 在我看来，Mediator模式是把多个对象（
                                
                                
常用代码记录
                                    chenjunt3
UIExcelJ#
                                    
  
1、单据设置某行或某字段不能修改

//i是行号,"cash"是字段名称
getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false);
//取得单据表体所有项用以上语句做循环就能设置整行了
getBillC
                                
                                
搜索引擎与工作流引擎
                                    comsci
算法工作搜索引擎网络应用
                                    
  
 
    最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想) 
  -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
                                
                                
oracle Health Monitor
                                    daizj
oracleHealth Monitor
                                    
About Health Monitor 
 
Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. 
 
About Health Monitor Checks 
 
Health M
                                
                                
JSON字符串转换为对象
                                    dieslrae
javajson
                                    
    作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了. 
  
                                
                                
C语言学习八结构体，综合应用，学生管理系统
                                    dcj3sjt126com
C语言
                                    
实现功能的代码： 
# include <stdio.h>
# include <malloc.h>

struct Student
{
	int age;
	float score;
	char name[100];
};


int main(void)
{
	int len;
	struct Student * pArr;
	int i,
                                
                                
vagrant学习笔记
                                    dcj3sjt126com
vagrant
                                    
想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant 
  
1. vagrant virtualbox 下载安装 
https://www.vagrantup.com/downloads.html 
https://www.virtualbox.org/wiki/Downloads 
  
查看安装在命令行输入vagrant 
  
  
2.
                                
                                
14.性能优化-优化-软件配置优化
                                    frank1234
软件配置性能优化
                                    
1.Tomcat线程池 
 
修改tomcat的server.xml文件： 
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
                                
                                
一个不错的shell 脚本教程 入门级
                                    HarborChung
linuxshell
                                    
一个不错的shell 脚本教程 入门级 
建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
                                
                                
Spring4新特性——核心容器的其他改进
                                    jinnianshilongnian
spring动态代理spring4依赖注入
                                    
Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
                                
                                
Linux设置tomcat开机启动
                                    liuxingguome
tomcatlinux开机自启动
                                    
执行命令sudo gedit /etc/init.d/tomcat6 
 
然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 
 
#!/bin/bash 
 
# 
 
# /etc/rc.d/init.d/tomcat 
 
# init script for tomcat precesses
                                
                                
第13章 Ajax进阶（下）
                                    onestopweb
Ajax
                                    
index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
                                
                                
Troubleshooting Crystal Reports off BW
                                    blueoxygen
BO
                                    
http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE 
  
Quite useful, especially this part:  
SAP BW connectivity 
For t
                                
                                
Java开发熟手该当心的11个错误
                                    tomcat_oracle
javajvm多线程单元测试
                                    
#1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
                                
                                
正则表达式大全
                                    yang852220741
html编程正则表达式
                                    
今天向大家分享正则表达式大全，它可以大提高你的工作效率 
正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。 
一、校验数字的表达式 
 
数字：^[0-9]*$ 
n位的数字：^\d{n}$ 
至少n位的数字：^\d{n,}$ 
m-n位的数字：^\d{m,n}$
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        
版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.