MyBatis - 初始化（九）加载Mapper接口与XML映射文件

MyBatis - 初始化（九）加载Mapper接口与XML映射文件

该系列文档是本人在学习 Mybatis 的源码过程中总结下来的，可能对各位读者会不太友好，阅读前需要对 MyBatis 和 Spring 有一定的了解。比较适合刚接触，会使用但是一直没去探究底层的同学。

MyBatis 版本：3.5.6

MyBatis-Spring 版本：2.0.3

MyBatis-Spring-Boot-Starter 版本：2.1.4

该系列其他文档请查看：《 MyBatis 系列 - 导读》

一、MyBatis的初始化

在MyBatis初始化过程中，大致会有以下几个步骤：

1. 创建Configuration全局配置对象，会往TypeAliasRegistry别名注册中心添加Mybatis需要用到的相关类，并设置默认的语言驱动类为XMLLanguageDriver
2. 加载mybatis-config.xml配置文件、Mapper接口中的注解信息和XML映射文件，解析后的配置信息会形成相应的对象并保存到Configuration全局配置对象中
3. 构建DefaultSqlSessionFactory对象，通过它可以创建DefaultSqlSession对象，MyBatis中SqlSession的默认实现类

因为整个初始化过程涉及到的代码比较多，所以拆分成了四个模块依次对MyBatis的初始化进行分析：

• 《MyBatis - 初始化（八）加载 mybatis-config.xml 》
• 《MyBatis - 初始化（九）加载Mapper接口与XML映射文件》
• 《MyBatis - 初始化（十）SQL初始化（上）》
• 《MyBatis - 初始化（十一）SQL初始化（下）》

由于在MyBatis的初始化过程中去解析Mapper接口与XML映射文件涉及到的篇幅比较多，XML映射文件的解析过程也比较复杂，所以才分成了后面三个模块，逐步分析，这样便于理解

初始化（二）之加载Mapper接口与映射文件

在上一个模块已经分析了是如何解析mybatis-config.xml配置文件的，在最后如何解析标签的还没有进行分析，这个过程稍微复杂一点，因为需要解析Mapper接口以及它的XML映射文件，让我们一起来看看这个解析过程

解析XML映射文件生成的对象主要如下图所示：

主要包路径：org.apache.ibatis.builder、org.apache.ibatis.mapping

主要涉及到的类：

• org.apache.ibatis.builder.xml.XMLConfigBuilder：根据配置文件进行解析，开始Mapper接口与XML映射文件的初始化，生成Configuration全局配置对象
• org.apache.ibatis.binding.MapperRegistry：Mapper接口注册中心，将Mapper接口与其动态代理对象工厂进行保存，这里我们解析到的Mapper接口需要往其进行注册
• org.apache.ibatis.builder.annotation.MapperAnnotationBuilder：解析Mapper接口，主要是解析接口上面注解，其中加载XML映射文件内部会调用XMLMapperBuilder类进行解析
• org.apache.ibatis.builder.xml.XMLMapperBuilder：解析XML映射文件
• org.apache.ibatis.builder.xml.XMLStatementBuilder：解析XML映射文件中的Statement配置（ 标签）
  org.apache.ibatis.builder.MapperBuilderAssistant：Mapper构造器小助手，用于创建ResultMapping、ResultMap和MappedStatement对象
  org.apache.ibatis.mapping.ResultMapping：保存标签的子标签相关信息，也就是 Java Type 与 Jdbc Type 的映射信息
  org.apache.ibatis.mapping.ResultMap：保存了标签的配置信息以及子标签的所有信息
  org.apache.ibatis.mapping.MappedStatement：保存了解析
  标签内的SQL语句所生成的所有信息

解析入口

我们回顾上一个模块，在org.apache.ibatis.builder.xml.XMLConfigBuilder中会解析mybatis-config.xml配置文件中的标签，调用其parse()->parseConfiguration(XNode root)->mapperElement(XNode parent)方法，那么我们来看看这个方法，代码如下：

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
        // <0> 遍历子节点
        for (XNode child : parent.getChildren()) {
            // <1> 如果是 package 标签，则扫描该包
            if ("package".equals(child.getName())) {
                // 获得包名
                String mapperPackage = child.getStringAttribute("name");
                // 添加到 configuration 中
                configuration.addMappers(mapperPackage);
            } else { // 如果是 mapper 标签
                // 获得 resource、url、class 属性
                String resource = child.getStringAttribute("resource");
                String url = child.getStringAttribute("url");
                String mapperClass = child.getStringAttribute("class");
                // <2> 使用相对于类路径的资源引用
                if (resource != null && url == null && mapperClass == null) {
                    ErrorContext.instance().resource(resource);
                    // 获得 resource 的 InputStream 对象
                    InputStream inputStream = Resources.getResourceAsStream(resource);
                    // 创建 XMLMapperBuilder 对象
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                    // 执行解析
                    mapperParser.parse();
                // <3> 使用完全限定资源定位符（URL）
                } else if (resource == null && url != null && mapperClass == null) {
                    ErrorContext.instance().resource(url);
                    // 获得 url 的 InputStream 对象
                    InputStream inputStream = Resources.getUrlAsStream(url);
                    // 创建 XMLMapperBuilder 对象
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url,configuration.getSqlFragments());
                    // 执行解析
                    mapperParser.parse();
                // <4> 使用映射器接口实现类的完全限定类名
                } else if (resource == null && url == null && mapperClass != null) {
                    // 获得 Mapper 接口
                    Class<?> mapperInterface = Resources.classForName(mapperClass);
                    // 添加到 configuration 中
                    configuration.addMapper(mapperInterface);
                } else {
                    throw new BuilderException( "A mapper element may only specify a url, resource or class, but not more than one.");
                }
            }
        }
    }
}

遍历标签的子节点

1. 如果是子节点，则获取package属性，对该包路径下的Mapper接口进行解析
2. 否的的话，通过子节点的resource属性或者url属性解析该映射文件，或者通过class属性解析该Mapper接口

通常我们是直接配置一个包路径，这里就查看上面第1种对Mapper接口进行解析的方式，第2种的解析方式其实在第1 种方式都会涉及到，它只是抽取出来了，那么我们就直接看第1种方式

首先将package包路径添加到Configuration全局配置对象中，也就是往其内部的MapperRegistry注册表进行注册，调用它的MapperRegistry的addMappers(String packageName)方法进行注册

我们来看看在MapperRegistry注册表中是如何解析的，在之前文档的Binding模块中有讲到过这个类，该方法如下：

public class MapperRegistry {
    
    public void addMappers(String packageName) {
		addMappers(packageName, Object.class);
	}
    
    /**
	 * 用于扫描指定包中的Mapper接口，并与XML文件进行绑定
	 * @since 3.2.2
	 */
	public void addMappers(String packageName, Class<?> superType) {
		// <1> 扫描指定包下的指定类
		ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
		resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
		Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
		// <2> 遍历，添加到 knownMappers 中
		for (Class<?> mapperClass : mapperSet) {
			addMapper(mapperClass);
		}
	}
    
	public <T> void addMapper(Class<T> type) {
		// <1> 判断，必须是接口。
		if (type.isInterface()) {
			// <2> 已经添加过，则抛出 BindingException 异常
			if (hasMapper(type)) {
				throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
			}
			boolean loadCompleted = false;
			try {
				// <3> 将Mapper接口对应的代理工厂添加到 knownMappers 中
				knownMappers.put(type, new MapperProxyFactory<>(type));
				// It's important that the type is added before the parser is run
				// otherwise the binding may automatically be attempted by the mapper parser.
				// If the type is already known, it won't try.
				// <4> 解析 Mapper 的注解配置
				MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
				// 解析 Mapper 接口上面的注解和 Mapper 接口对应的 XML 文件
				parser.parse();
				// <5> 标记加载完成
				loadCompleted = true;
			} finally {
				// <6> 若加载未完成，从 knownMappers 中移除
				if (!loadCompleted) {
					knownMappers.remove(type);
				}
			}
		}
	}
}

<1>首先必须是个接口

<2>已经在MapperRegistry注册中心存在，则会抛出异常

<3>创建一个Mapper接口对应的MapperProxyFactory动态代理工厂

<4>【重要！！！】通过MapperAnnotationBuilder解析该Mapper接口与对应XML映射文件

MapperAnnotationBuilder

org.apache.ibatis.builder.annotation.MapperAnnotationBuilder：解析Mapper接口，主要是解析接口上面注解，加载XML文件会调用XMLMapperBuilder类进行解析

我们先来看看他的构造函数和parse()解析方法：

public class MapperAnnotationBuilder {

    /**
     * 全局配置对象
     */
	private final Configuration configuration;
    /**
     * Mapper 构造器小助手
     */
	private final MapperBuilderAssistant assistant;
    /**
     * Mapper 接口的 Class 对象
     */
	private final Class<?> type;

	public MapperAnnotationBuilder(Configuration configuration, Class<?> type) {
		String resource = type.getName().replace('.', '/') + ".java (best guess)";
		this.assistant = new MapperBuilderAssistant(configuration, resource);
		this.configuration = configuration;
		this.type = type;
	}

	public void parse() {
		String resource = type.toString();
		if (!configuration.isResourceLoaded(resource)) {
		    // 加载该接口对应的 XML 文件
			loadXmlResource();
			configuration.addLoadedResource(resource);
			assistant.setCurrentNamespace(type.getName());
			// 解析 Mapper 接口的 @CacheNamespace 注解，创建缓存
			parseCache();
			// 解析 Mapper 接口的 @CacheNamespaceRef 注解，引用其他命名空间
			parseCacheRef();
			Method[] methods = type.getMethods();
			for (Method method : methods) {
				try {
					// issue #237
					if (!method.isBridge()) { // 如果不是桥接方法
					  // 解析方法上面的注解
						parseStatement(method);
					}
				} catch (IncompleteElementException e) {
					configuration.addIncompleteMethod(new MethodResolver(this, method));
				}
			}
		}
		parsePendingMethods();
	}

	private void loadXmlResource() {
		// Spring may not know the real resource name so we check a flag
		// to prevent loading again a resource twice
		// this flag is set at XMLMapperBuilder#bindMapperForNamespace
		if (!configuration.isResourceLoaded("namespace:" + type.getName())) {
			String xmlResource = type.getName().replace('.', '/') + ".xml";
			// #1347
			InputStream inputStream = type.getResourceAsStream("/" + xmlResource);
			if (inputStream == null) {
				// Search XML mapper that is not in the module but in the classpath.
				try {
					inputStream = Resources.getResourceAsStream(type.getClassLoader(), xmlResource);
				} catch (IOException e2) {
					// ignore, resource is not required
				}
			}
			if (inputStream != null) {
			    // 创建 XMLMapperBuilder 对象
				XMLMapperBuilder xmlParser = new XMLMapperBuilder(inputStream, assistant.getConfiguration(),
						xmlResource, configuration.getSqlFragments(), type.getName());
				// 解析该 XML 文件
				xmlParser.parse();
			}
		}
	}
}

在构造函数中，会创建一个MapperBuilderAssistant对象，Mapper 构造器小助手，用于创建XML映射文件中对应相关对象

parse()方法，用于解析Mapper接口：

1. 获取Mapper接口的名称，例如interface xxx.xxx.xxx，根据Configuration全局配置对象判断该Mapper接口是否被解析过
2. 没有解析过则调用loadXmlResource()方法解析对应的XML映射文件
3. 然后解析接口的@CacheNamespace和@CacheNamespaceRef注解，再依次解析方法上面的MyBatis相关注解

注解的相关解析这里就不讲述了，因为我们通常都是使用XML映射文件，逻辑没有特别复杂，都在MapperAnnotationBuilder中进行解析，

loadXmlResource()方法，解析Mapper接口对应的XML映射文件：

1. 根据Configuration全局配置对象判断该Mapper接口对应的XML映射文件是否被解析过，例如判断namespace:xxx.xxx.xxx是否在已加载的资源中
2. 获取XML映射文件资源，例如：获取xxx/xxx/xxx.xml文件流，与接口名称对应
3. 创建XMLMapperBuilder对象，调用其parse()方法解析该XML映射文件

那么接下来我们来看看XMLMapperBuilder是如何解析XML映射文件的

XMLMapperBuilder

org.apache.ibatis.builder.xml.XMLMapperBuilder：解析XML映射文件

继承org.apache.ibatis.builder.BaseBuilder抽象类，该基类提供了类型转换以及一些其他的工具方法，比较简单，这里就不做展述了

构造方法

public class XMLMapperBuilder extends BaseBuilder {

	/**
	 * 基于 Java XPath 解析器
	 */
	private final XPathParser parser;
	/**
	 * Mapper 构造器助手
	 */
	private final MapperBuilderAssistant builderAssistant;
	/**
	 * 可被其他语句引用的可重用语句块的集合，实际上就是 Configuration 全局配置中的 sqlFragments
	 *
	 * 例如： ${alias}.id,${alias}.username,${alias}.password 
     * 可能在很多地方被引用
	 */
	private final Map<String, XNode> sqlFragments;
	/**
	 * 资源引用的地址，例如：com/aaa/bbb.xml
	 */
	private final String resource;
    
    public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resource,
			Map<String, XNode> sqlFragments, String namespace) {
		this(inputStream, configuration, resource, sqlFragments);
		this.builderAssistant.setCurrentNamespace(namespace);
	}

	public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resource,
			Map<String, XNode> sqlFragments) {
		this(new XPathParser(inputStream, true, configuration.getVariables(), new XMLMapperEntityResolver()), 
             configuration, resource,  sqlFragments);
	}

	private XMLMapperBuilder(XPathParser parser, Configuration configuration, String resource,
			Map<String, XNode> sqlFragments) {
		super(configuration);
		// 创建 MapperBuilderAssistant 对象
		this.builderAssistant = new MapperBuilderAssistant(configuration, resource);
		this.parser = parser;
		this.sqlFragments = sqlFragments;
		this.resource = resource;
	}
}

1. 首先会进入XPathParser的构造方法，将XML映射文件解析成org.w3c.dom.Document对象，这里传入了XMLMapperEntityResolver作为解析实例对象，其中使用到本地的DTD文件
2. 然后创建一个 Mapper 构造器助手 MapperBuilderAssistant 对象
3. 其中一些属性都是从Configuration全局配置对象中获取的，例如：typeAliasRegistry、typeHandlerRegistry、sqlFragments

parse方法

parse()方法用于解析XML映射文件，在MapperAnnotationBuilder中被调用，代码如下：

public class XMLMapperBuilder extends BaseBuilder {
    public void parse() {
		// <1> 判断当前 Mapper 是否已经加载过
		if (!configuration.isResourceLoaded(resource)) {
			// <2> 解析 `` 节点
			configurationElement(parser.evalNode("/mapper"));
			// <3> 标记该 Mapper 已经加载过
			configuration.addLoadedResource(resource);
			// <4> 绑定 Mapper
			bindMapperForNamespace();
		}
		// <5> 解析待定的  节点
		parsePendingResultMaps();
		// <6> 解析待定的  节点
		parsePendingCacheRefs();
		// <7> 解析待定的 SQL 语句的节点
		parsePendingStatements();
	}
}

<1> 根据Configuration全局配置判断当前XML映射文件是否已经加载过，例如resource为：xxx/xxx/xxx.xml

<2> 解析 节点，也就是解析整个的XML映射文件，在下面的configurationElement方法中讲解

<3> 标记该XML映射文件已经加载过，往Configuration全局配置添加该字段文件，例如添加：xxx/xxx/xxx.xml

<4> 绑定 Mapper 到该命名空间，避免在MapperAnnotationBuilder#loadXmlResource方法中重复加载该XML映射文件

<5> 解析待定的 、节点以及 Statement 对象，因为我们配置的这些对象可能还依赖的其他对象，在解析的过程中这些依赖可能还没解析出来，导致这个对象解析失败，所以先保存在Configuration全局配置对象中，待整个XML映射文件解析完后，再遍历之前解析失败的对象进行初始化，这里就不做详细的讲述了，感兴趣的小伙伴可以看一下

这里我们来看一下configurationElement(XNode context)方法是如何解析XML映射文件中的节点

configurationElement方法

configurationElement(XNode context)方法就是来解析XML映射文件中我们定义的SQL相关信息，代码如下：

public class XMLMapperBuilder extends BaseBuilder {
    private void configurationElement(XNode context) {
		try {
			// <1> 获得 namespace 属性
			String namespace = context.getStringAttribute("namespace");
			if (namespace == null || namespace.equals("")) {
				throw new BuilderException("Mapper's namespace cannot be empty");
			}
			builderAssistant.setCurrentNamespace(namespace);
			// <2> 解析  节点
			cacheRefElement(context.evalNode("cache-ref"));
			// <3> 解析  节点
			cacheElement(context.evalNode("cache"));
			// 已废弃！老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除，这里不会记录。
			parameterMapElement(context.evalNodes("/mapper/parameterMap"));
			// <4> 解析  节点
			resultMapElements(context.evalNodes("/mapper/resultMap"));
			// <5> 解析  节点们
			sqlElement(context.evalNodes("/mapper/sql"));
			// <6> 解析     节点
			buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
		} catch (Exception e) {
			throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
		}
	}
}
 
  
<1> 获得 namespace 属性，如果 XML 映射文件中定义的 namespace 和接口名称不相等会抛出异常<2> 解析  节点，调用cacheRefElement方法 <3> 解析  节点，调用cacheElement方法 <4> 解析  节点，调用resultMapElements方法 <5> 解析  节点们，调用sqlElement方法 <6> 解析     节点，调用`buildStatementFromContext方法
 
  
cacheRefElement方法
 
  
cacheRefElement(XNode context)方法用于解析XML映射文件中的节点，代码如下：
 
  
private void cacheRefElement(XNode context) {
    if (context != null) {
        // <1> 获得指向的 namespace 名字，并添加到 configuration 的 cacheRefMap 中
        configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
        // <2> 创建 CacheRefResolver 对象
        CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
        try {
            // 执行解析，获取引用的缓存对象到自己这里
            cacheRefResolver.resolveCacheRef();
        } catch (IncompleteElementException e) {
            configuration.addIncompleteCacheRef(cacheRefResolver);
        }
    }
}
 
  
解析当前XML映射文件的缓存配置，将当前namespace缓存引用其他的namespace的缓存形成映射关系保存在Configuration全局配置对象中
 
  
获取引用的namespace的缓存实例，将其设置到MapperBuilderAssistant构造器助手中，在后续构建相关对象时使用
 
  
cacheElement方法
 
  
cacheElement(XNode context)方法用于XML映射文件中的节点，代码如下：
 
  
private void cacheElement(XNode context) {
    if (context != null) {
        // <1> 获得负责存储的 Cache 实现类
        String type = context.getStringAttribute("type", "PERPETUAL");
        Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
        // <2> 获得负责过期的 Cache 实现类
        String eviction = context.getStringAttribute("eviction", "LRU");
        Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
        // <3> 获得 flushInterval、size、readWrite、blocking 属性
        Long flushInterval = context.getLongAttribute("flushInterval");
        Integer size = context.getIntAttribute("size");
        boolean readWrite = !context.getBooleanAttribute("readOnly", false);
        boolean blocking = context.getBooleanAttribute("blocking", false);
        // <4> 获得 Properties 属性
        Properties props = context.getChildrenAsProperties();
        // <5> 创建 Cache 对象
        builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
    }
}
 
  
解析该节点的相关配置，然后通过MapperBuilderAssistant构造器小助手创建一个Cache缓存实例，添加到Configuration全局配置对象中，并设置到构造器助手中，在后续构建相关对象时使用
 
  
resultMapElements方法
 
  
resultMapElements(List list)方法用于解析节点，最后会调用
 
  
resultMapElement(XNode resultMapNode, List additionalResultMappings, Class enclosingType)方法逐个解析生成ResultMap对象
 
  
整体的流程图：
 
  
 
  
例如这样配置RresultMap：
 
  
<mapper namespace="com.mybatis3.mappers.StudentMapper">
    
    <resultMap id="StudentResult" type="Student">
        <result column="id" property="studentId" jdbcType="INTEGER" />
        <result column="name" property="name" jdbcType="VARCHAR" />
        <result column="age" property="age" jdbcType="INTEGER" />
        
        <association property="teacher" javaType="Teacher">
            <result column="teacher_id" property="id" jdbcType="INTEGER" />
        	<result column="teacher_name" property="name" jdbcType="VARCHAR" />
        	<result column="teacher_age" property="age" jdbcType="INTEGER" />
        association>
    resultMap>
mapper>
 
  
resultMapElement方法代码如下：
 
  
public class XMLMapperBuilder extends BaseBuilder {
    private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings, Class<?> enclosingType) throws Exception {
	    // 获取当前线程的上下文
		ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
		// <1> 获得 type 属性
		String type = resultMapNode.getStringAttribute("type", resultMapNode.getStringAttribute("ofType",
				resultMapNode.getStringAttribute("resultType", resultMapNode.getStringAttribute("javaType"))));
		// 获得 type 对应的类
		Class<?> typeClass = resolveClass(type);
		if (typeClass == null) {
            // 从 enclosingType Class 对象获取该 property 属性的 Class 对象
			typeClass = inheritEnclosingType(resultMapNode, enclosingType);
		}
		Discriminator discriminator = null;
		// 创建 ResultMapping 集合
		List<ResultMapping> resultMappings = new ArrayList<>();
        // 添加父 ResultMap 的 ResultMapping 集合
		resultMappings.addAll(additionalResultMappings);
		// <2> 遍历  的子节点
		List<XNode> resultChildren = resultMapNode.getChildren();
		for (XNode resultChild : resultChildren) {
			if ("constructor".equals(resultChild.getName())) { // <2.1> 处理  节点
				processConstructorElement(resultChild, typeClass, resultMappings);
			} else if ("discriminator".equals(resultChild.getName())) { // <2.2> 处理  节点
				discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
			} else { // <2.3> 处理其它节点
				List<ResultFlag> flags = new ArrayList<>();
				if ("id".equals(resultChild.getName())) {
				  // 为添加该 ResultMapping 添加一个 Id 标志
					flags.add(ResultFlag.ID);
				}
				// 生成对应的 ResultMapping 对象
				resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
			}
		}
		// 获得 id 属性，没有的话自动生成
		String id = resultMapNode.getStringAttribute("id", resultMapNode.getValueBasedIdentifier());
		// 获得 extends 属性
		String extend = resultMapNode.getStringAttribute("extends");
		// 获得 autoMapping 属性
		Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
		// <3> 创建 ResultMapResolver 对象，执行解析
		ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend,
				discriminator, resultMappings, autoMapping);
		try {
		  // 处理 ResultMap 并添加到 Configuration 全局配置中
			return resultMapResolver.resolve();
		} catch (IncompleteElementException e) {
			configuration.addIncompleteResultMap(resultMapResolver);
			throw e;
		}
	}
}
 
  
关于元素的属性配置参考MyBatis官方文档配置说明
 
  
resultMapElement(XNode resultMapNode, List additionalResultMappings, Class enclosingType)方法的入参分别是：
 
  
 
   
当前节点Node的封装，封装成XNode便于操作
 
   
继承的ResultMap所对应的ResultMapping的集合，可以通过extend属性配置继承哪个ResultMap，没有继承的话就是空集合
 
   
所属的ResultMap的类型，例如中的也会被解析成ResultMap，那么它的enclosingType就是所属ResultMap的Class对象
 
  
 
  
处理逻辑：
 
  
 
   
获得 type 属性，生成该ResultMap对应Class对象，如果没有定义type属性，则可能是标签，尝试从所属ResultMap的Class对象获取property的Class对象，因为标签中配置的标签也会解析成一个ResultMap对象
 
   
遍历  的子节点，依次处理 
    
 
     
如果是节点，则调用processConstructorElement方法进行解析，再获取它的子节点生成对应的RequestMapping对象，这些RequestMapping对象会添加ResultFlag.CONSTRUCTOR标记，如果是标签则再添加一个ResultFlag.ID标记，这些对象会在实例化类时，注入到构造方法中
 
     
如果是节点，则调用processDiscriminatorElement方法进行解析，创建一个Discriminator选择器对象，用于可以使用结果值来决定这个属性使用哪个ResultMap，基于子节点来进行映射
 
     
其他节点，则调用buildResultMappingFromContext方法进行解析，如果是则添加一个ResultFlag.ID标记，生成对应的RequestMapping对象
 
    
 
 
   
创建ResultMapResolver对象，调用其resolve()方法执行解析，内部调用MapperBuilderAssistant构造器小助手的addResultMap来生成ResultMap对象的
 
  
 
  
上面的2.1和2.2并不复杂，感兴趣的小伙伴可以查看相关方法，我们来看下2.3是如何解析成ResultMapping对象的
 
  
buildResultMappingFromContext方法
 
  
buildResultMappingFromContext(XNode context, Class resultType, List flags)方法将标签中的子标签解析成RequestMapping对象，代码如下：
 
  
public class XMLMapperBuilder extends BaseBuilder {
    private ResultMapping buildResultMappingFromContext(XNode context, Class<?> resultType, List<ResultFlag> flags)
			throws Exception {
		String 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");
		// 解析  标签中的 ，， 标签，生成 ResultMap 对象
		String nestedResultMap = context.getStringAttribute("resultMap", processNestedResultMappings(context, Collections.emptyList(), resultType));
		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<?> javaTypeClass = resolveClass(javaType);
		// typeHandler 属性
		Class<? extends TypeHandler<?>> typeHandlerClass = 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);
	}
}
 
  
依次从该节点中获取相关属性
 
  
 
   
这里我们看到nestedResultMap的获取，如果这个是，或者，则会调用processNestedResultMappings方法解析成ResultMap对象，然后返回该对象的id（没有定义会自动生成），这样这个RequestMapping对象就会关联这个ResultMap对象了，这个方法内部也是调用resultMapElement方法生成ResultMap对象的，可以回过头再看下这个方法
 
   
最后通过MapperBuilderAssistant构造器小助手的buildResultMapping方法根据这些属性构建一个ResultMapping对象并返回
 
  
 
  
整个的ResultMap对象的解析过程到这里就结束了，关于MapperBuilderAssistant在后续会讲到，接下来我们来看看节点的解析
 
  
sqlElement方法
 
  
sqlElement(List list)方法用于解析所有的节点，内部调用sqlElement(List list, String requiredDatabaseId)方法，代码如下：
 
  
public class XMLMapperBuilder extends BaseBuilder {
    private void sqlElement(List<XNode> list, String requiredDatabaseId) {
		// <1> 遍历所有  节点
		for (XNode context : list) {
			// <2> 获得 databaseId 属性
			String databaseId = context.getStringAttribute("databaseId");
			// <3> 获得完整的 id 属性
			String id = context.getStringAttribute("id");
			// 设置为 `${namespace}.${id}` 格式
			id = builderAssistant.applyCurrentNamespace(id, false);
			// <4> 判断 databaseId 是否匹配
			if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) {
				// <5> 添加到 sqlFragments 中
				sqlFragments.put(id, context);
			}
		}
	}
}
 
  
这里仅仅是将该节点保存至Map sqlFragments对象中（该对象保存与Configuration全局配置对象中），后续解析其他SQL语句中会使用到，例如查询语句中使用了标签，则需要获取到对应的节点将其替换
 
  
buildStatementFromContext方法
 
  
buildStatementFromContext(List list)方法用于解析    节点
 
  
内部调用buildStatementFromContext(List list, String requiredDatabaseId)方法逐个解析生成MappedStatement对象，代码如下：
 
  
public class XMLMapperBuilder extends BaseBuilder {
    private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
		// <1> 遍历     节点
		for (XNode context : list) {
			// <1> 创建 XMLStatementBuilder 对象
			final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
			try {
				// 解析成 MappedStatement 对象
				statementParser.parseStatementNode();
			} catch (IncompleteElementException e) {
				// <2> 解析失败，添加到 configuration 中
				configuration.addIncompleteStatement(statementParser);
			}
		}
	}
}

为该节点创建XMLStatementBuilder对象，然后调用其parseStatementNode()解析成MappedStatement对象，解析过程在下面的XMLStatementBuilder中讲到

XMLStatementBuilder

org.apache.ibatis.builder.xml.XMLStatementBuilder：解析XML映射文件中的Statement配置

也就是解析 节点，解析过程在parseStatementNode()方法中

构造方法

public class XMLStatementBuilder extends BaseBuilder {

	private final MapperBuilderAssistant builderAssistant;
	/**
	 * 当前 XML 节点，例如：

、、、 标签 */ private final XNode context; /** * 要求的 databaseId */ private final String requiredDatabaseId; public XMLStatementBuilder(Configuration configuration, MapperBuilderAssistant builderAssistant, XNode context) { this(configuration, builderAssistant, context, null); } public XMLStatementBuilder(Configuration configuration, MapperBuilderAssistant builderAssistant, XNode context, String databaseId) { super(configuration); this.builderAssistant = builderAssistant; this.context = context; this.requiredDatabaseId = databaseId; } }

parseStatementNode方法

parseStatementNode()方法用于解析 Statement 对应节点，也就是 节点，代码如下：

public class XMLStatementBuilder extends BaseBuilder {
    public void parseStatementNode() {
		// 获得 id 属性，编号。
		String id = context.getStringAttribute("id");
		// 获得 databaseId ， 判断 databaseId 是否匹配
		String databaseId = context.getStringAttribute("databaseId");

		if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
			return;
		}

		// 获取该节点名称
		String nodeName = context.getNode().getNodeName();
		// <1> 根据节点名称判断 SQL 类型
		SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
		// 是否为 Select 语句
		boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
		// <2> 是否清空缓存
		boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
		// <3> 是否使用缓存
		boolean useCache = context.getBooleanAttribute("useCache", isSelect);
		boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

		// Include Fragments before parsing
		XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
		// <4> 将该节点的子节点  转换成  节点
		includeParser.applyIncludes(context.getNode());

		// 获取参数类型名称
		String parameterType = context.getStringAttribute("parameterType");
		// <5> 参数类型名称转换成 Java Type
		Class<?> parameterTypeClass = resolveClass(parameterType);

		// <6> 获得 lang 对应的 LanguageDriver 对象
		String lang = context.getStringAttribute("lang");
		LanguageDriver langDriver = getLanguageDriver(lang);

		// Parse selectKey after includes and remove them.
        // <7> 将该节点的子节点  解析成 SelectKeyGenerator 生成器
		processSelectKeyNodes(id, parameterTypeClass, langDriver);

		// Parse the SQL (pre:  and  were parsed and removed)
		KeyGenerator keyGenerator;
		String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
		keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
        /*
         * <8> 
         * 1. 如果上面存在  子节点，则获取上面对其解析后生成的 SelectKeyGenerator
         * 2. 否则判断该节点是否配置了 useGeneratedKeys 属性为 true 并且是 插入语句，则使用 Jdbc3KeyGenerator
         */
		if (configuration.hasKeyGenerator(keyStatementId)) {
			keyGenerator = configuration.getKeyGenerator(keyStatementId);
		} else {
            keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
            configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
            ? Jdbc3KeyGenerator.INSTANCE
            : NoKeyGenerator.INSTANCE;
		}

		// <9> 创建对应的 SqlSource 对象，保存了该节点下 SQL 相关信息
		SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
		// <10> 获得 Statement 类型，默认 PREPARED
		StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
		Integer fetchSize = context.getIntAttribute("fetchSize");
		Integer timeout = context.getIntAttribute("timeout");
		String parameterMap = context.getStringAttribute("parameterMap");
		// <11> 获得返回结果类型名称
		String resultType = context.getStringAttribute("resultType");
		// 获取返回结果的 Java Type
		Class<?> resultTypeClass = resolveClass(resultType);
		// 获取 resultMap
		String resultMap = context.getStringAttribute("resultMap");
		String resultSetType = context.getStringAttribute("resultSetType");
		ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
		if (resultSetTypeEnum == null) {
			resultSetTypeEnum = configuration.getDefaultResultSetType();
		}
		// 对应的 java 属性，结合 useGeneratedKeys 使用
		String keyProperty = context.getStringAttribute("keyProperty");
        // 对应的 column 列名，结合 useGeneratedKeys 使用
		String keyColumn = context.getStringAttribute("keyColumn");
		String resultSets = context.getStringAttribute("resultSets");
        // <12> 
		builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType, fetchSize, timeout,
				parameterMap, parameterTypeClass, resultMap, resultTypeClass, resultSetTypeEnum, flushCache, useCache,
				resultOrdered, keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
	}
}

解析方法有点长，我们一步一步来看

1. 根据节点名称设置SQL语句类型，SqlCommandType：UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH
2. 获取flushCache属性，是否清空缓存，非查询语句默认都是true
3. 获取useCache属性，是否开启缓存，查询语句默认为true
4. 创建XMLIncludeTransformer对象，调用其applyIncludes方法将转换成节点，大致逻辑就是从sqlFragments（前面已经将所有的节点进行解析存放在其中了）获取对应的节点，然后替换节点，具体的转换过程这里就不讲述了，没有特别复杂，感兴趣的小伙伴可以查看相关方法
5. 获取parameterType属性，参数类型，转换成Class对象
6. 获取lang属性，LanguageDriver语言驱动器，默认为XMLLanguageDriver
7. 将该节点的子节点解析成 SelectKeyGenerator 生成器，用于生成一个key设置到返回对象中，在processSelectKeyNodes方法中可以看到，该过程也会生成一个MappedStatement对象，生成的对象的 id 为 statementId+'!selectKey'
8. 解析useGeneratedKeys属性，获取 SelectKeyGenerator 生成器，如果第7步没有生成才会进入这里，直接返回Jdbc3KeyGenerator单例
9. 根据XMLLanguageDriver语言驱动创建SqlSource对象，通过这个对象可以获取到对应的SQL语句，在后面的《MyBatis初始化之SQL初始化》分析该创建过程
10. 获取statementType属性，Statement类型，默认PREPARED
11. 获取其他的一下相关信息，例如：timeout、resultMap、keyProperty、keyColumn等属性，其中配置的resultType也会转换成ResultMap对象
12. 通过MapperBuilderAssistant构造器小助手根据这些属性信息构建一个MappedStatement对象

MapperBuilderAssistant

org.apache.ibatis.builder.MapperBuilderAssistant：Mapper构造器小助手，在前面整个XML映射文件的解析过程中，所需要创建ResultMapping、ResultMap和MappedStatement对象都是通过这个助手来创建的，那么我们来看看它提供了哪些功能

构造方法

public class MapperBuilderAssistant extends BaseBuilder {
    /**
	 * 当前 Mapper 命名空间
	 */
	private String currentNamespace;
	/**
	 * 资源引用的地址
     * 解析Mapper接口：xxx/xxx/xxx.java (best guess)
     * 解析Mapper映射文件：xxx/xxx/xxx.xml
	 */
	private final String resource;
	/**
	 * 当前 Cache 对象
	 */
	private Cache currentCache;
	/**
	 * 是否未解析成功 Cache 引用
	 */
	private boolean unresolvedCacheRef; // issue #676

	public MapperBuilderAssistant(Configuration configuration, String resource) {
		super(configuration);
		ErrorContext.instance().resource(resource);
		this.resource = resource;
	}
}

这个小助手是为了 XMLMapperBuilder 和 MapperAnnotationBuilder 都能调用到一些公用方法

useCacheRef方法

前面在XMLMapperBuilder的cacheRefElement方法解析节点的过程中有调用这个方法，用来设置当前Cache缓存实例所引用的那个对象，代码如下：

public Cache useCacheRef(String namespace) {
    if (namespace == null) {
        throw new BuilderException("cache-ref element requires a namespace attribute.");
    }
    try {
        unresolvedCacheRef = true; // 标记未解决
        // <1> 获得 Cache 对象
        Cache cache = configuration.getCache(namespace);
        // 获得不到，抛出 IncompleteElementException 异常
        if (cache == null) {
            throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.");
        }
        // 记录当前 Cache 对象
        currentCache = cache;
        unresolvedCacheRef = false; // 标记已解决
        return cache;
    } catch (IllegalArgumentException e) {
        throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.", e);
    }
}

入参namespace：所引用的缓存所在的namespace

根据该namespace获取到其缓存实例对象，然后设置为当前需要使用的缓存实例

useNewCache方法

前面在XMLMapperBuilder的cacheElement方法解析节点的过程中有调用这个方法，用来创建一个Cache缓存实例，代码如下：

public Cache useNewCache(Class<? extends Cache> typeClass, Class<? extends Cache> evictionClass, Long flushInterval,
        Integer size, boolean readWrite, boolean blocking, Properties props) {
    // <1> 创建 Cache 对象
    // 缓存实例默认为 PerpetualCache 类型，Cache 装饰器默认为 LruCache
    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();
    // <2> 添加到 configuration 的 caches 中
    configuration.addCache(cache);
    // <3> 赋值给 currentCache
    currentCache = cache;
    return cache;
}

1. 根据节点中的相关信息通过CacheBuilder构造器创建一个缓存实例（被装饰的Cache实例），如何构建的代码有点长，这里就不讲述了，感兴趣的小伙伴可以查看相关方法，都已经注释好了
2. 将缓存实例添加到Configuration全局对象中
3. 设置为当前需要使用的缓存实例

buildResultMapping方法

前面在XMLMapperBuilder的resultMapElement方法调用的buildResultMappingFromContext方法中有调用这个方法，用来创建一个RequestMapping对象，代码如下：

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) {
    // <1> 解析对应的 Java Type
    Class<?> javaTypeClass = resolveResultJavaType(resultType, property, javaType);
    // 解析对应的 TypeHandler ，一般不会设置
    TypeHandler<?> typeHandlerInstance = resolveTypeHandler(javaTypeClass, typeHandler);
    List<ResultMapping> composites;
    // <2> 解析组合字段名称成 ResultMapping 集合，涉及「关联的嵌套查询」
    if ((nestedSelect == null || nestedSelect.isEmpty()) && (foreignColumn == null || foreignColumn.isEmpty())) {
        composites = Collections.emptyList();
    } else {
        // RequestMapping 关联了子查询，如果 column 配置了多个则一一再创建 RequestMapping 对象
        composites = parseCompositeColumnName(column);
    }
    // <3> 创建 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<>() : flags)
            .composites(composites).notNullColumns(parseMultipleColumnNames(notNullColumn))
            .columnPrefix(columnPrefix).foreignColumn(foreignColumn).lazy(lazy).build();
}

入参有点多，不过根据名称可以知道其意思，大致逻辑如下：

1. 解析对应的 Java Type 和 TypeHandler 的 Class 对象

2. 如果嵌套的子查询存在组合字段，则一一解析成 ResultMapping 对象，例如需要在返回的结果集中取多个列作为嵌套查询的入参，那么你需要配置多个映射关系

   例如子查询的入参对象有两个属性，分别是name和age，而上一层查询从数据库返回的列名是studentName和studentAge，那么你需要在嵌套查询配置column属性为：{name=studentName,age=studentAge}，不然没有映射关系无法设置子查询的入参，这样就会为该属性创建两个ResultMapping添加到composites集合中

3. 调用applyCurrentNamespace方法，拼接命名空间

4. 调用parseMultipleColumnNames方法，将字符串（以逗号分隔）解析成集合，作用： 默认情况下，在至少一个被映射到属性的列不为空时，子对象才会被创建。

5. 通过ResultMapping.Builder构建一个ResultMapping对象

addResultMap方法

前面在XMLMapperBuilder的resultMapElement方法使用ResultMapResolver生成ResultMap对象时会调用这个方法，用来解析生成ResultMap对象，代码如下：

public ResultMap addResultMap(String id, Class<?> type, String extend, Discriminator discriminator,
        List<ResultMapping> resultMappings, Boolean autoMapping) {
    // <1> 获得 ResultMap 编号，即格式为 `${namespace}.${id}`
    id = applyCurrentNamespace(id, false);
    // <2.1> 获取完整的父 ResultMap 属性，即格式为 `${namespace}.${extend}`。从这里的逻辑来看，貌似只能获取自己 namespace 下的 ResultMap 。
    extend = applyCurrentNamespace(extend, true);

    // <2.2> 如果有父类，则将父类的 ResultMap 集合，添加到 resultMappings 中。
    if (extend != null) {
        // <2.2.1> 获得 extend 对应的 ResultMap 对象。如果不存在，则抛出 IncompleteElementException 异常
        // 所以说  标签如果有继承关系就必须有先后顺序？
        if (!configuration.hasResultMap(extend)) {
            throw new IncompleteElementException("Could not find a parent resultmap with id '" + extend + "'");
        }
        ResultMap resultMap = configuration.getResultMap(extend);
        // 获取 extend 的 ResultMap 对象的 ResultMapping 集合，并移除 resultMappings
        List<ResultMapping> extendedResultMappings = new ArrayList<>(resultMap.getResultMappings());
        extendedResultMappings.removeAll(resultMappings);
        // Remove parent constructor if this resultMap declares a constructor.
        // 判断当前的 resultMappings 是否有构造方法，如果有，则从 extendedResultMappings 移除所有的构造类型的 ResultMapping
        boolean declaresConstructor = false;
        for (ResultMapping resultMapping : resultMappings) {
            if (resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR)) {
                declaresConstructor = true;
                break;
            }
        }
        if (declaresConstructor) {
            extendedResultMappings.removeIf(resultMapping -> resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR));
        }
        // 将 extendedResultMappings 添加到 resultMappings 中
        resultMappings.addAll(extendedResultMappings);
    }
    // <3> 创建 ResultMap 对象
    ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping)
            .discriminator(discriminator).build();
    // <4> 添加到 configuration 中
    configuration.addResultMap(resultMap);
    return resultMap;
}

1. 调用applyCurrentNamespace方法拼接namespace与id，获得ResultMap的唯一编号，格式为 ${namespace}.${id}
2. 获得父ResultMap的唯一编号extend，格式为${namespace}.${extend}
   1. extend为null则直接忽略
   2. 否则获取对应的ResultMap对象，则将extend的ResultMapping集合和自己的ResultMapping集合进行合并
3. 通过ResultMap.Builder构建一个ResultMap对象，并添加到Configuration全局配置中

addMappedStatement方法

在XMLStatementBuilder的parseStatementNode方法中会调用该方法，用来构建一个MappedStatement对象，代码如下：

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) {

    // <1> 如果的指向的 Cache 未解析，抛出异常
    if (unresolvedCacheRef) {
        throw new IncompleteElementException("Cache-ref not yet resolved");
    }

    // <2> 获得 id 编号，格式为 `${namespace}.${id}`
    id = applyCurrentNamespace(id, false);
    // 是否为查询语句
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

    // <3> 创建 MappedStatement.Builder 对象
    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);

    // <4> 生成 ParameterMap 对象
    ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
    if (statementParameterMap != null) {
        statementBuilder.parameterMap(statementParameterMap);
    }

    // <5> 创建 MappedStatement 对象
    MappedStatement statement = statementBuilder.build();
    // <6> 添加到 configuration 中
    configuration.addMappedStatement(statement);
    return statement;
}

入参有点多，这里就不一一进行说明了，通过其名称大致可以知道其意思

1. 如果的指向的 Cache 未解析，抛出异常

2. 获得MappedStatement的唯一编号id，格式为${namespace}.${id}

3. 创建MappedStatement.Builder对象

4. 创建ParameterMap对象，进入getStatementParameterMap方法可以看到，ParameterMap的Class type属性设置为入参类型，String id设置为statementId

   标签已经被废弃，所以这里不会配置parameterMap属性

5. 通过MappedStatement.Builder构建一个MappedStatement对象，并添加到Configuration全局配置中

RequestMapping

org.apache.ibatis.mapping.ResultMapping：保存ResultMap相关子节点的信息，也就是 Java Type 与 Jdbc Type 的映射信息

内部定义了Builder构造器，使用构建者模式创建实例对象，有以下属性：

public class ResultMapping {
    private Configuration configuration;
    /**
    * Java 字段
    */
    private String property;
    /**
    * JDBC 列名
    */
    private String column;
    /**
    * Java 类型
    */
    private Class<?> javaType;
    /**
    * JDBC 类型
    */
    private JdbcType jdbcType;
    /**
    * 类型处理器
    */
    private TypeHandler<?> typeHandler;
    /**
    * 对应的 resultMapId
    * 例如  标签中的  标签会生成一个 ResultMap 对象，则这个属性对应该 ResultMap 对象的Id
    */
    private String nestedResultMapId;
    /**
    * 关联的子查询 Id
    */
    private String nestedQueryId;
    /**
    * 不能为 null 的列名
    */
    private Set<String> notNullColumns;
    /**
    * 列名前缀
    */
    private String columnPrefix;
    /**
    * 具有的标记
    */
    private List<ResultFlag> flags;
    /**
    * 关联嵌套查询的属性映射
    */
    private List<ResultMapping> composites;
    private String resultSet;
    private String foreignColumn;
    private boolean lazy;

    ResultMapping() {
    }
}

构建过程这里就不列出来了，最终会生成以上这些属性

ResultMap

org.apache.ibatis.mapping.ResultMap：保存了配置的所有信息

内部定义了Builder构造器，使用了构建者模式创建实例对象，构建的时候进行了相关属性的分类，有以下属性：

public class ResultMap {
	/**
	 * Configuration 对象
	 */
	private Configuration configuration;

	/**
	 * ResultMap 对象
	 */
	private String id;
	/**
	 * 类型
	 */
	private Class<?> type;
	/**
	 * ResultMapping 集合
	 */
	private List<ResultMapping> resultMappings;
	/**
	 * ID ResultMapping 集合
	 *
	 * 当 idResultMappings 为空时，使用 {@link #resultMappings} 赋值
	 */
	private List<ResultMapping> idResultMappings;
	/**
	 * 构造方法的入参 ResultMapping 集合
   * 根据参数名称已经排序好了
	 *
	 * 和 {@link #propertyResultMappings} 不存在相同元素
	 */
	private List<ResultMapping> constructorResultMappings;
	/**
	 * 属性 ResultMapping 集合
	 */
	private List<ResultMapping> propertyResultMappings;
	/**
	 * 数据库的字段集合（全部大写）
	 */
	private Set<String> mappedColumns;
	/**
	 * Java 对象的属性集合
	 */
	private Set<String> mappedProperties;
	/**
	 * Discriminator 选择器对象
	 */
	private Discriminator discriminator;
	/**
	 * 是否有内嵌的 ResultMap
	 */
	private boolean hasNestedResultMaps;
	/**
	 * 是否有嵌套关联的子查询
	 */
	private boolean hasNestedQueries;
	/**
	 * 是否开启自动匹配
	 *
	 * 如果设置这个属性，MyBatis将会为这个ResultMap开启或者关闭自动映射。这个属性会覆盖全局的属性
	 * autoMappingBehavior。默认值为：unset。
	 */
	private Boolean autoMapping;

	private ResultMap() {
	}
}

构建过程这里就不列出来了，最终会生成以上这些属性

MappedStatement

org.apache.ibatis.mapping.MappedStatement：保存了解析

标签内的SQL语句所生成的所有信息

内部定义了Builder构造器，使用了构建者模式构建对象，有以下属性：

public final class MappedStatement {
    /**
     * XML 映射文件路径，例如：xxx/xxx/xxx.xml
     */
    private String resource;
    /**
     * 全局配置对象
     */
    private Configuration configuration;
    /**
     * 唯一编号：`${namespace}.${id}`
     */
    private String id;
    /**
     * 这是一个给驱动的建议值，尝试让驱动程序每次批量返回的结果行数等于这个设置值
     * 默认值为未设置（unset）（依赖驱动）
     */
    private Integer fetchSize;
    /**
     * 这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数
     * 默认值为未设置（unset）（依赖数据库驱动）
     */
    private Integer timeout;
    /**
     * Statement 的类型：STATEMENT PREPARED CALLABLE，默认 PREPARED
     * 分别对应：Statement PreparedStatement  CallableStatement
     */
    private StatementType statementType;
    private ResultSetType resultSetType;
    /**
     * SQL 相关信息
     */
    private SqlSource sqlSource;
    /**
     * 缓存对象
     */
    private Cache cache;
    private ParameterMap parameterMap;
    /**
     * ResultMap对象
     * 配置多个时需要加上 namespace 并以逗号分隔
     */
    private List<ResultMap> resultMaps;
    /**
     * 是否清空缓存
     */
    private boolean flushCacheRequired;
    /**
     * 是否使用缓存
     */
    private boolean useCache;
    /**
     * 这个设置仅针对嵌套结果 select 语句，默认值：false
     * 如果为 true，将会假设包含了嵌套结果集或是分组，当返回一个主结果行时，就不会产生对前面结果集的引用
     * 这就使得在获取嵌套结果集的时候不至于内存不够用
     */
    private boolean resultOrdered;
    /**
     * SQL 语句类型
     */
    private SqlCommandType sqlCommandType;
    /**
     * key 的生成器
     */
    private KeyGenerator keyGenerator;
    /**
     * key 的生成器的 Java 属性
     */
    private String[] keyProperties;
    /**
     * key 的生成器的 column 列名
     */
    private String[] keyColumns;
    /**
     * 是否有内嵌的 ResultMap
     */
    private boolean hasNestedResultMaps;
    /**
     * 数据库表示
     */
    private String databaseId;
    /**
     * 日志对象
     */
    private Log statementLog;
    /**
     * 语言驱动，默认为XMLLanguageDriver
     */
    private LanguageDriver lang;
    /**
     * 这个设置仅适用于多结果集的情况
     * 它将列出语句执行后返回的结果集并赋予每个结果集一个名称，多个名称之间以逗号分隔
     */
    private String[] resultSets;

    MappedStatement() {
        // constructor disabled
    }
}

构建过程这里就不列出来了，最终会生成以上这些属性

其中SqlSource是通过XMLLanguageDriver语言驱动创建的，可以回到XmlStatementBuilder的**parseStatementNode()**方法看看，在后面的《MyBatis初始化之SQL初始化》分析整个创建过程

总结

本分分析了MyBatis在初始化时加载Mapper接口与XML映射文件的整个过程

1. 在XMLConfigBuilder中将用户配置的Mapper接口所在包路径package添加到MapperRegistry注册表中
2. 在MapperRegistry注册表中会对包下的所有Mapper接口进行解析，每个接口都会创建对应的MapperProxyFactory动态代理对象工厂，并保存，也会通过MapperAnnotationBuilder对该接口进行解析，解析过程：
   1. 首先通过该Mapper接口的名称获取对应的XML映射文件，获取到该文件资源进行加载解析，解析后的对象都会跟XML映射文件中配置的namespace属性关联，所以XML映射文件的名称要与Mapper接口的名称保持一致，配置的namespace属性要与接口的全名保持一致
   2. 然后解析Mapper接口的MyBatis相关注解
3. 解析XML映射文件的过程中是在XMLMapperBuilder中进行的，会使用到MapperBuilderAssistant小助手用于创建ResultMapping、ResultMap和MappedStatement对象
4. 其中解析 标签的解析过程又在XMLStatementBuilder对象中进行

   在XMLStatementBuilder解析上面标签的时候需要通过XMLLanguageDriver语言驱动创建SqlSource对象，这个过程涉及到的篇幅有点多，会在接下来的《MyBatis初始化（三）之SQL初始化（上）》中开始分析

   最终所有的MyBatis配置、Mapper接口和XML映射文件生成的相应对象都保存在了Configuration全局配置对象中，那么接下来我们来看看SQL语句在MyBatis中是如何初始化的

   参考文章：《MyBatis 源码分析》

   --------------最后感谢大家的阅读，愿大家技术越来越流弊！--------------

   

   --------------也希望大家给我点支持，谢谢各位大佬了！！！--------------

   你可能感兴趣的:(MyBatis系列,mybatis,spring,java,数据库)

   • 使用sqlite创建数据库 @云初 sqlite数据库database
     使用sqlite创建数据库#sqlite3.exe数据库名.dbSQLiteversion3.36.02021-06-1818:36:39Enter".help"forusagehints.sqlite>在sqlite里面创建一张表并添加数据#.databases#.tables#createtableperson(idint,namevarchar(20),addressvarchar(20))
   • Websoft9 开源软件实操平台：快速积累企业级软件技能，深入理解真实业务场景 开源创业
     引言：打破“纸上谈兵”的实训困境当前高校技术教育普遍面临一个矛盾：学生对开源工具的理论知识掌握充分，但在真实业务场景中常因环境配置复杂、工具链割裂而难以落地。例如，部署一套完整的电商系统需协调数据库、服务器、安全策略等多环节，传统虚拟机环境难以模拟企业级复杂度。Websoft9作为开源软件自动化部署工具，通过预集成200+企业级应用模板（如GitLab、Odoo、Jenkins）和全流程管理能力，
   • Python自动化运维开发系列—CICD项目 weixin_46240874
     导语都忘记是什么时候知道python的了，我是搞linux运维的，早先只是知道搞运维必须会shell,要做一些运维自动化的工作，比如实现一些定时备份数据啊、批量执行某个操作啊、写写监控脚本什么的。后来发现工作量大的时候shell开始变慢，实现某个功能使用shell感觉力不从心，听人说python能实现shell能做的一切功能，而且开发效率高，速度快，慢慢的就认识了python,多多少少看点简单的东
   • 乐观锁与悲观锁的 MyBatis-Plus 实现 drebander mybatis-plusmybatis
     在高并发场景下，数据库的并发控制是确保数据一致性的关键。乐观锁和悲观锁是两种常见的并发控制机制，它们分别适用于不同的场景。MyBatis-Plus提供了对乐观锁的支持，使得开发者可以轻松实现并发控制。本文将详细介绍乐观锁与悲观锁的概念、MyBatis-Plus如何实现乐观锁、实现乐观锁的场景，以及如何使用@Version注解进行版本控制。1.乐观锁与悲观锁的概念1.1乐观锁（OptimisticL
   • 扩展 MyBatis-Plus 支持的查询条件 drebander mybatis-plus数据库mybatispythonMybatis-Plus
     MyBatis-Plus是一个强大的MyBatis增强工具，提供了丰富的查询条件构造器和便捷的CRUD操作。然而，在实际开发中，我们可能会遇到一些复杂的查询需求，需要扩展MyBatis-Plus的功能。本文将详细介绍如何扩展MyBatis-Plus支持的查询条件，包括自定义SQL查询、Lambda查询与条件构造器扩展、动态查询条件的实现，以及扩展自定义查询方法与接口。1.自定义SQL查询1.1使用
   • 数据库 + Spring Boot + Vue 全栈交互逻辑详解 代码CC Java项目-开发springbootvue.jsmysql数据库开发语言
     目录整体架构概述技术栈说明数据库设计规范SpringBoot后端架构Vue前端架构完整交互流程关键技术实现细节安全与性能优化异常处理机制整体架构概述graphTDA[Vue前端]-->|HTTP请求|B(SpringBoot后端)B-->|JDBC/ORM|C[(数据库)]C-->|返回数据|BB-->|JSON响应|AA-->|状态管理|D[VuexStore]B-->|缓存|E[Redis]B
   • Java 大视界 -- Java 大数据在智能体育赛事直播数据分析与观众互动优化中的应用（142） 青云交 大数据新视界Java大视界java大数据体育赛事直播数据分析观众互动数据采集个性化推荐
     亲爱的朋友们，热烈欢迎来到青云交的博客！能与诸位在此相逢，我倍感荣幸。在这飞速更迭的时代，我们都渴望一方心灵净土，而我的博客正是这样温暖的所在。这里为你呈上趣味与实用兼具的知识，也期待你毫无保留地分享独特见解，愿我们于此携手成长，共赴新程！一、欢迎加入【福利社群】点击快速加入：青云交灵犀技韵交响盛汇福利社群点击快速加入2：2024CSDN博客之星创作交流营（NEW)二、本博客的精华专栏：大数据新视
   • C++与C语言的区别 @haihi c++c语言开发语言
     前言本文主要用C语言和C++做对比来学习C++，便于个人理解。C++包含C语言，是对C语言的扩展，在C++中，支持C语言的语法使用，C++是C语言的超集一、C++与C语言的区别C语言简单高效，适合低级系统编程和硬件相关的开发。C++更加灵活、强大，适合大型项目开发，尤其是需要面向对象、代码复用和复杂数据结构的应用。1.编程范式C语言：C是一种过程式编程语言，主要关注函数和过程。程序是通过一系列函数
   • 从C语言开始的C++编程生活（1） Elnaij C++基础知识c语言c++
     前言本系列文章承接C语言的学习，需要有C语言的基础才能学会哦。第1篇主要讲的是有关于C++的命名空间、输入和输出。C++才起步，都很简单呢！目录前言命名空间namespace基本语法作用使用命名空间域作用限定符::基本语法usingnamespace命名空间域名基本语法作用using命名空间域名::变量名基本语法作用C++的输入和输出“>”流提取符基本语法代码解释命名空间namespace基本语法
   • HarmonyOS开发，A持有B，B引用A的场景会不会导致内存泄漏，代码示例告诉你答案 MardaWang HarmonyOSNEXTOpenHarmonyharmonyos华为
     问题：A持有B，B引用A的场景会不会导致内存泄漏？答案：方舟虚拟机的内存管理和GC采用的是根可达算法，根可达算法可以解决循环引用问题，不会导致A引用B，B引用A的内存泄漏。根可达算法原理根可达算法以一系列被称为“根对象”（如栈中的局部变量、静态变量等）作为起始点，从这些根对象开始向下搜索，能够被搜索到的对象被认为是可达对象，而那些无法被搜索到的对象则被判定为不可达对象，会在垃圾回收时被清理。所以，
   • deepseek 对于 Web 前端过去，现在，未来的看法！称未来可能不叫前端工程师... CoderBin_ 与deepseek的对话前端
     一、你对于过去的web前端有什么看法？对早期的Web前端开发（大致在2000年代至2010年代初），可以总结出以下几个关键看法：1.技术原始，但充满探索精神基础技术简单：主要依赖HTML、CSS和原生JavaScript，缺乏现代框架和工具链的支持。兼容性噩梦：不同浏览器（尤其是IE6/7）的渲染差异极大，开发者需要大量Hack代码（如条件注释、CSS滤镜）来适配。创新萌芽：AJAX（2005年）
   • 汇川EASY系列之以太网通讯（MODBUS_TCP做从站） Amos_ FAT 汇川EASY网络服务器经验分享
     汇川easy系列PLC做MODBUS_TCP从站，不需要任何操作，但是有一些需要知道的东西。具体如下：1、汇川easy系列PLC做MODBUS_TCP从站，，ModbusTCP服务器默认开启，无需设置通信协议（即不需要配置），端口号为“502”。ModbusTCP从站最多支持31个ModbusTCP客户端（ModbusTCP主站）同时连接。2、做为串口通讯的衍生，功能码是应知应会的。具体如下：关于
   • 【etcd】 茉菇 etcd数据库
     一、ETCD简介etcd是一个由CoreOS团队开发的开源项目，旨在提供一个高可用的、分布式的、一致的键值存储，用于配置共享和服务发现。尽管它看起来像一个键值存储，但etcd的设计目标远远超出了传统数据库的功能范围。etcd的核心特性包括：高可用性和容错性：etcd使用Raft共识算法来确保数据的一致性和服务的高可用性。这意味着即使集群中的某些节点出现故障，etcd也能继续提供服务，并保证数据的一
   • 使用Pinecone实现自查询检索器的实现步骤 vaidfl python
     ##技术背景介绍Pinecone是一款功能强大的向量数据库，适用于处理复杂的检索需求。在本文中，我们将演示如何结合Pinecone向量存储使用SelfQueryRetriever实现自查询功能。为了更方便的了解原理，我们将以电影总结数据集为例进行展示。##核心原理解析自查询检索器(SelfQueryRetriever)的核心思想是通过提供文档的元数据和内容描述，结合语言模型生成查询条件来完成数据检
   • 【一起学Rust | Tauri2.0框架】基于 Rust 与 Tauri 2.0 框架实现跨平台二维码扫描应用 金枝玉叶9 程序员知识储备1程序员知识储备2程序员知识储备3rust开发语言后端
     《一起学Rust|Tauri2.0框架》是一个结合Rust语言与Tauri框架开发跨平台应用的教程。Tauri2.0是一个非常适合构建跨平台桌面应用的框架，它让开发者可以使用Web技术（如HTML、CSS、JavaScript）来创建前端，同时利用Rust编写后端逻辑，确保应用运行高效且轻量。在这个教程中，开发者可以学习如何使用Rust与Tauri2.0框架实现一个跨平台二维码扫描应用。具体步骤可
   • 第十三章 Java多线程——阻塞队列 龙少丶 javajava开发语言
     13.1阻塞队列的由来我们假设一种场景，生产者一直生产资源，消费者一直消费资源，资源存储在一个缓存池中，生产者将生产的资源存进缓存池中，消费者从缓存池中拿到资源进行消费，这就是大名鼎鼎的生产者-消费者模式。该模式能够简化开发过程，一方面消除了生产者与消费者类之间的代码依赖性，另方面将生产数据的过程与使用数据的过程解耦简单化负载。我们⾃⼰coding实现这个模式的时候，因为需要让多个线程操作共享变量
   • SQL分类 penglaifei Websql数据库
     DDL(DataDefiationLanguage)数据定义语言，用来定义数据库对象（数据库、表、字段）数据库操作——查询所有数据库：show.databases；注：information_schemamysqlperformance_schemasys是系统自带的数据库——查询当前数据库selectdatabase();——使用/切换数据库usename#数据库名；——创建数据库（数据库名不可
   • 使用 DingoDB 创建自查询检索器的实战演示 fgayif python
     DingoDB深入解析与实战演示DingoDB是一种分布式多模向量数据库，它结合了数据湖和向量数据库的特点，能够存储任何类型和大小的数据（如Key-Value、PDF、音频、视频等）。它具有实时低延迟处理能力，可以快速获取洞察并响应，还能高效进行即时分析和处理多模数据。在本教程中，我们将演示如何使用DingoDB向量存储来创建一个自查询检索器。技术背景介绍DingoDB的设计结合了数据湖的灵活性和
   • 使用 DashVector 进行高效的矢量检索和自查询检索器演示 bavDHAUO python
     在当代AI应用中，向量数据的管理和检索是至关重要的部分。DashVector是一个完全托管的向量数据库服务，提供了对高维稠密和稀疏向量的支持，允许实时插入和过滤搜索。这个服务基于DAMOAcademy自研的高效向量引擎Proxima核心构建，具备云原生和横向扩展能力，能够快速适应不同应用需求。在本篇文章中，我们将演示如何使用DashVector和SelfQueryRetriever来高效地进行矢量
   • 【含文档+PPT+源码】基于微信小程序农家乐美食餐厅预约推广系统 编程毕设 微信小程序美食小程序
     项目介绍本课程演示的是一款基于微信小程序农家乐美食餐厅预约推广系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。1.包含：项目源码、项目文档、数据库脚本、软件工具等所有资料2.带你从零开始部署运行本套系统3.该项目附带的源码资料可作为毕设使用该系统功能架构图如下：技术栈说明技术栈：后端：SpringBoot+Vue+ElementUI（后端是前后端分离的）前端：Un
   • 【H2O2 | 软件开发】前端深拷贝的实现 过期的H2O2 【H2O2】全栈面试题javascript开发语言ecmascript前端
     目录前言开篇语准备工作正文概述JSON方法递归其他结束语前言开篇语本系列为短篇，每次讲述少量知识点，无需一次性灌输太多的新知识点。该主题文章主要是围绕前端、全栈开发相关面试常见问题撰写的，希望对诸位有所帮助。如果您需要为面试八股文做准备，笔者建议重点关注加粗强调部分，它们是概念中的关键词。准备工作软件：【参考版本】VisualStudioCode系统版本：Win10/11正文概述概括地来说，前端实
   • 什么是Apache Avro？ maozexijr apache
     什么是ApacheAvro？ApacheAvro是一个开源的数据序列化框架，主要用于高效的数据交换和存储。它由ApacheHadoop项目开发，广泛应用于大数据生态系统中（如Hadoop、Kafka等）。Avro提供了一种紧凑、快速的二进制数据格式，同时支持丰富的数据结构和模式演化。核心特性跨语言支持Avro支持多种编程语言（如Java、Python、C++、Go等），使得不同语言之间的数据交换变
   • 计算机毕业设计之基于Hadoop的热点新闻分析系统的设计与实现 微信bishe69 课程设计pythondjangomysql
     近些年来，随着科技的飞速发展，互联网的普及逐渐延伸到各行各业中，给人们生活带来了十分的便利，热点新闻分析系统利用计算机网络实现信息化管理，使整个热点新闻分析的发展和服务水平有显著提升。本文拟采用PyCharm开发工具，django框架、Python语言、Hadoop大数据处理技术进行开发，后台使用MySQL数据库进行信息管理，设计开发的热点新闻分析系统。通过调研和分析，系统拥有管理员和用户两个模块
   • Oracle 19c数据库REDO日志更换 deadknight9 Oracle运维oracle数据库
     一、增加新日志组，并放在不同磁盘SQL>alterdatabaseaddlogfilethread1group10('+DATA','+OCR')size50M;Databasealtered.SQL>alterdatabaseaddlogfilethread1group11('+DATA','+OCR')size50M;Databasealtered.SQL>alterdatabaseaddlo
   • 【AI大模型前沿】浙大携手阿里推出HealthGPT：医学视觉语言大模型助力智能医疗新突破 寻道AI小兵 AI大模型前沿技术追踪人工智能语言模型AIGC
     系列篇章No.文章1【AI大模型前沿】深度剖析瑞智病理大模型RuiPath：如何革新癌症病理诊断技术2【AI大模型前沿】清华大学CLAMP-3：多模态技术引领音乐检索新潮流3【AI大模型前沿】浙大携手阿里推出HealthGPT：医学视觉语言大模型助力智能医疗新突破目录系列篇章前言一、项目概述二、技术原理（一）异构低秩适应（H-LoRA）（二）分层视觉感知（HVP）（三）三阶段学习策略（TLS）三、
   • Spring常见面试题 风清扬，夏邑 Springspringjava后端
     1.Spring框架中的单例bean是线程安全的吗?不是线程安全的，当多用户同时请求一个服务时，容器会给每一个请求分配一个线程，这时多个线程会并发执行该请求对应的业务逻辑(成员方法)，如果该处理逻辑中有对该单列状态的修改(体现为该单例的成员属性)，则必须考虑线程同步问题。Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。比如:我
   • Spring Boot 整合 Elasticsearch 实践：从入门到上手 遇见伯灵说 mysqlSpringelasticsearchjenkinsspringboot
     引言Elasticsearch是一个开源的分布式搜索引擎，广泛用于日志分析、搜索引擎、数据分析等场景。本文将带你通过一步步的教程，在SpringBoot项目中整合Elasticsearch，轻松实现数据存储与查询。1.创建SpringBoot项目首先，你需要创建一个SpringBoot项目。如果你还没有创建，可以使用SpringInitializr快速生成一个项目。在生成项目时，确保选择了以下依赖
   • 计算机毕业设计PHP保利和院物业服务管理系统小程序（源码+程序+uni+lw+部署） 计算机专业毕设程序 课程设计php小程序
     该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
   • 【含文档+PPT+源码】基于SpringBoot+vue的疫苗接种系统的设计与实现 小咕聊编程 springboot后端java
     项目介绍本课程演示的是一款基于SpringBoot+vue的疫苗接种系统的设计与实现，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。1.包含：项目源码、项目文档、数据库脚本、软件工具等所有资料2.带你从零开始部署运行本套系统3.该项目附带的源码资料可作为毕设使用疫苗接种系统包括管理员登录、用户管理、疫苗信息管理、疫苗接种管理、接种管理、疫苗百科知识管理、消息通知管理、
   • 一文搞懂MYSQL、SQL、SQLServer、SQLyog的区别和联系 码上就位 mysqlsqlsqlserver
     1.SQL（StructuredQueryLanguage）定义：SQL是结构化查询语言，主要用于管理和操作关系型数据库（RDBMS）。它是一种标准化语言，由ISO和ANSI定义，支持数据的查询、插入、更新、删除和数据库结构的定义。特点：通用性：SQL是关系型数据库的通用语言，支持多种数据库系统，如MySQL、SQLServer、Oracle、PostgreSQL等。功能性：DDL（数据定义语言）
   • VMware Workstation 11 或者 VMware Player 7安装MAC OS X 10.10 Yosemite iwindyforest vmwaremac os10.10workstationplayer
     最近尝试了下VMware下安装MacOS 系统， 安装过程中发现网上可供参考的文章都是VMware Workstation 10以下， MacOS X 10.9以下的文章， 只能提供大概的思路， 但是实际安装起来由于版本问题， 走了不少弯路， 所以我尝试写以下总结， 希望能给有兴趣安装OSX的人提供一点帮助。     写在前面的话： 其实安装好后发现， 由于我的th
   • 关于《基于模型驱动的B/S在线开发平台》源代码开源的疑虑？ deathwknight JavaScriptjava框架
     本人从学习Java开发到现在已有10年整，从一个要自学 java买成javascript的小菜鸟，成长为只会java和javascript语言的老菜鸟（个人邮箱：[email protected]） 一路走来，跌跌撞撞。用自己的三年多业余时间，瞎搞一个小东西（基于模型驱动的B/S在线开发平台，非MVC框架、非代码生成）。希望与大家一起分享，同时有许些疑虑，希望有人可以交流下 平台
   • 如何把maven项目转成web项目 Kai_Ge mavenMyEclipse
     创建Web工程，使用eclipse ee创建maven web工程 1.右键项目,选择Project Facets,点击Convert to faceted from 2.更改Dynamic Web Module的Version为2.5.(3.0为Java7的,Tomcat6不支持). 如果提示错误,可能需要在Java Compiler设置Compiler compl
   • 主管？？？ Array_06 工作
     转载：http://www.blogjava.net/fastzch/archive/2010/11/25/339054.html 很久以前跟同事参加的培训，同事整理得很详细，必须得转！ 前段时间，公司有组织中高阶主管及其培养干部进行了为期三天的管理训练培训。三天的课程下来，虽然内容较多，因对老师三天来的课程内容深有感触，故借着整理学习心得的机会，将三天来的培训课程做了一个
   • python内置函数大全 2002wmj python
     最近一直在看python的document，打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Constants、Build-in Types、Build-in Exception这四个方面，其实在看的时候发现整个《The Python Standard Library》章节都是很不错的，其中描述了很多不错的主题。先把Build-in Fu
   • JSP页面通过JQUERY合并行 357029540 JavaScriptjquery
     在写程序的过程中我们难免会遇到在页面上合并单元行的情况，如图所示 如果对于会的同学可能很简单，但是对没有思路的同学来说还是比较麻烦的，提供一下用JQUERY实现的参考代码 function mergeCell(){         var trs = $("#table tr"); &nb
   • Java基础 冰天百华 java基础
     学习函数式编程 package base; import java.text.DecimalFormat; public class Main { public static void main(String[] args) { // Integer a = 4; // Double aa = (double)a / 100000; // Decimal
   • unix时间戳相互转换 adminjun 转换unix时间戳
     如何在不同编程语言中获取现在的Unix时间戳(Unix timestamp)？ Java time JavaScript Math.round(new Date().getTime()/1000) getTime()返回数值的单位是毫秒 Microsoft .NET / C# epoch = (DateTime.Now.ToUniversalTime().Ticks - 62135
   • 作为一个合格程序员该做的事 aijuans 程序员
     作为一个合格程序员每天该做的事 1、总结自己一天任务的完成情况 最好的方式是写工作日志，把自己今天完成了什么事情，遇见了什么问题都记录下来，日后翻看好处多多 2、考虑自己明天应该做的主要工作 把明天要做的事情列出来，并按照优先级排列，第二天应该把自己效率最高的时间分配给最重要的工作 3、考虑自己一天工作中失误的地方，并想出避免下一次再犯的方法 出错不要紧，最重
   • 由html5视频播放引发的总结 ayaoxinchao html5视频video
     前言   项目中存在视频播放的功能，前期设计是以flash播放器播放视频的。但是现在由于需要兼容苹果的设备，必须采用html5的方式来播放视频。我就出于兴趣对html5播放视频做了简单的了解，不了解不知道，水真是很深。本文所记录的知识一些浅尝辄止的知识，说起来很惭愧。   视频结构   本该直接介绍html5的<video>的，但鉴于本人对视频
   • 解决httpclient访问自签名https报javax.net.ssl.SSLHandshakeException: sun.security.validat bewithme httpclient
          如果你构建了一个https协议的站点，而此站点的安全证书并不是合法的第三方证书颁发机构所签发，那么你用httpclient去访问此站点会报如下错误   javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path bu
   • Jedis连接池的入门级使用 bijian1013 redisredis数据库jedis
     Jedis连接池操作步骤如下：         a.获取Jedis实例需要从JedisPool中获取；         b.用完Jedis实例需要返还给JedisPool；         c.如果Jedis在使用过程中出错，则也需要还给JedisPool； packag
   • 变与不变 bingyingao 不变变亲情永恒
     变与不变    周末骑车转到了五年前租住的小区，曾经最爱吃的西北面馆、江西水饺、手工拉面早已不在，    各种店铺都换了好几茬，这些是变的。    三年前还很流行的一款手机在今天看起来已经落后的不像样子。    三年前还运行的好好的一家公司，今天也已经不复存在。    一座座高楼拔地而起，
   • 【Scala十】Scala核心四：集合框架之List bit1129 scala
     Spark的RDD作为一个分布式不可变的数据集合，它提供的转换操作，很多是借鉴于Scala的集合框架提供的一些函数，因此，有必要对Scala的集合进行详细的了解   1. 泛型集合都是协变的，对于List而言，如果B是A的子类，那么List[B]也是List[A]的子类，即可以把List[B]的实例赋值给List[A]变量   2. 给变量赋值(注意val关键字，a，b
   • Nested Functions in C bookjovi cclosure
       Nested Functions 又称closure，属于functional language中的概念，一直以为C中是不支持closure的，现在看来我错了，不过C标准中是不支持的，而GCC支持。   既然GCC支持了closure，那么 lexical scoping自然也支持了，同时在C中label也是可以在nested functions中自由跳转的
   • Java-Collections Framework学习与总结-WeakHashMap BrokenDreams Collections
             总结这个类之前，首先看一下Java引用的相关知识。Java的引用分为四种：强引用、软引用、弱引用和虚引用。         强引用：就是常见的代码中的引用，如Object o = new Object();存在强引用的对象不会被垃圾收集
   • 读《研磨设计模式》-代码笔记-解释器模式-Interpret bylijinnan java设计模式
     声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 解释器（Interpreter）模式的意图是可以按照自己定义的组合规则集合来组合可执行对象 * * 代码示例实现XML里面1.读取单个元素的值 2.读取单个属性的值 * 多
   • After Effects操作&快捷键 cherishLC After Effects
     1、快捷键官方文档 中文版：https://helpx.adobe.com/cn/after-effects/using/keyboard-shortcuts-reference.html 英文版：https://helpx.adobe.com/after-effects/using/keyboard-shortcuts-reference.html 2、常用快捷键
   • Maven 常用命令 crabdave maven
     Maven 常用命令   mvn archetype:generate mvn install mvn clean mvn clean complie mvn clean test mvn clean install mvn clean package mvn test mvn package mvn site   mvn dependency:res
   • shell bad substitution daizj shell脚本
     #!/bin/sh /data/script/common/run_cmd.exp 192.168.13.168 "impala-shell -islave4 -q 'insert OVERWRITE table imeis.${tableName} select ${selectFields}, ds, fnv_hash(concat(cast(ds as string), im
   • Java SE 第二讲（原生数据类型 Primitive Data Type） dcj3sjt126com java
     Java SE  第二讲： 1.   Windows: notepad, editplus, ultraedit, gvim Linux: vi, vim, gedit 2.   Java 中的数据类型分为两大类： 1）原生数据类型  （Primitive Data Type） 2）引用类型（对象类型）  （R
   • CGridView中实现批量删除 dcj3sjt126com PHPyii
     1，CGridView中的columns添加 array( 'selectableRows' => 2, 'footer' => '<button type="button" onclick="GetCheckbox();" style=&
   • Java中泛型的各种使用 dyy_gusi java泛型
     Java中的泛型的使用：1.普通的泛型使用 在使用类的时候后面的<>中的类型就是我们确定的类型。 public class MyClass1<T> {//此处定义的泛型是T private T var; public T getVar() { return var; } public void setVa
   • Web开发技术十年发展历程 gcq511120594 Web浏览器数据挖掘
     回顾web开发技术这十年发展历程： Ajax 03年的时候我上六年级，那时候网吧刚在小县城的角落萌生。传奇，大话西游第一代网游一时风靡。我抱着试一试的心态给了网吧老板两块钱想申请个号玩玩，然后接下来的一个小时我一直在，注，册，账，号。 彼时网吧用的512k的带宽，注册的时候，填了一堆信息，提交，页面跳转，嘣，”您填写的信息有误，请重填”。然后跳转回注册页面，以此循环。我现在时常想，如果当时a
   • openSession()与getCurrentSession()区别： hetongfei javaDAOHibernate
     来自 http://blog.csdn.net/dy511/article/details/6166134 1.getCurrentSession创建的session会和绑定到当前线程,而openSession不会。 2. getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭。 这里getCurrentSession本地事务(本地
   • 第一章 安装Nginx+Lua开发环境 jinnianshilongnian nginxluaopenresty
     首先我们选择使用OpenResty，其是由Nginx核心加很多第三方模块组成，其最大的亮点是默认集成了Lua开发环境，使得Nginx可以作为一个Web Server使用。借助于Nginx的事件驱动模型和非阻塞IO，可以实现高性能的Web应用程序。而且OpenResty提供了大量组件如Mysql、Redis、Memcached等等，使在Nginx上开发Web应用更方便更简单。目前在京东如实时价格、秒
   • HSQLDB In-Process方式访问内存数据库 liyonghui160com
         HSQLDB一大特色就是能够在内存中建立数据库，当然它也能将这些内存数据库保存到文件中以便实现真正的持久化。   先睹为快！   下面是一个In-Process方式访问内存数据库的代码示例：     下面代码需要引入hsqldb.jar包 （hsqldb-2.2.8）   import java.s
   • Java线程的5个使用技巧 pda158 java数据结构
     Java线程有哪些不太为人所知的技巧与用法？ 　　萝卜白菜各有所爱。像我就喜欢Java。学无止境，这也是我喜欢它的一个原因。日常 工作中你所用到的工具，通常都有些你从来没有了解过的东西，比方说某个方法或者是一些有趣的用法。比如说线程。没错，就是线程。或者确切说是Thread这个类。当我们在构建高可扩展性系统的时候，通常会面临各种各样的并发编程的问题，不过我们现在所要讲的可能会略有不同。
   • 开发资源大整合：编程语言篇——JavaScript（1） shoothao JavaScript
     概述：本系列的资源整合来自于github中各个领域的大牛，来收藏你感兴趣的东西吧。     程序包管理器   管理javascript库并提供对这些库的快速使用与打包的服务。 Bower - 用于web的程序包管理。 component - 用于客户端的程序包管理，构建更好的web应用程序。 spm - 全新的静态的文件包管
   • 避免使用终结函数 vahoa.ma javajvmC++
     终结函数（finalizer）通常是不可预测的，常常也是很危险的，一般情况下不是必要的。使用终结函数会导致不稳定的行为、更差的性能，以及带来移植性问题。不要把终结函数当做C++中的析构函数（destructors）的对应物。       我自己总结了一下这一条的综合性结论是这样的： 1）在涉及使用资源，使用完毕后要释放资源的情形下，首先要用一个显示的方
   按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
   首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

   版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.