Configuration存储着mybatis运行时所需要的全部配置信息，那么它是如何从mybatis-config.xml转换过来的呢？实际运行中它又起到什么作用呢？今天我通过一个小例子，结合源码一步一步探索一下Configuration的解析流程，以便更加深入的了解其运行机制。 # 从Demo开始 下面是一个小小的示例。指定了配置文件mybatis-config.xml，通过SqlSessionFactoryBuilder创建SqlSessionFactory，打开SqlSession获取Mapper，执行Mapper方法。 ~~~java public static void main(String[] args) throws IOException { // mybatis配置文件 String path = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(path); // 获取 SqlSessionFactory SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); // 创建 SqlSession try (SqlSession sqlSession = sqlSessionFactory.openSession()) { CompanyDao dao = sqlSession.getMapper(CompanyDao.class); CompanyDO companyDO = dao.selectById(1, "test"); System.out.println(companyDO); } } 复制代码 ~~~ 从main方法中我们并没有看到Configuration的影子，是因为在实际运行中，操作数据库是使用SqlSession，而SqlSession是由SqlSessionFactory按需创建的，Configuration对象保存在SqlSessionFactory中，当创建SqlSession时会把Configuration传递到SqlSession。 # 配置解析流程 示例代码3-6行就完成了Configuration的解析工作，这个过程发生在方法SqlSessionFactoryBuilder#build()中，进入方法内部会发现实际执行xml解析的是类XMLConfigBuilder。 ~~~java public SqlSessionFactory build(InputStream inputStream) { // 调用重载方法 return build(inputStream, null, null); } public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { try { // 创建XMLConfigBuilder对象，这个是Configuration解析类 XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties); // 首先把xml解析为Configuration对象，然后创建SqlSessionFactory对象。 // 我们下来主要关心parse()方法 return build(parser.parse()); } catch (Exception e) { throw ExceptionFactory.wrapException("Error building SqlSession.", e); } finally { ErrorContext.instance().reset(); try { inputStream.close(); } catch (IOException e) { // Intentionally ignore. Prefer previous error. } } } 复制代码 ~~~ 在mybatis中XMLConfigBuilder负责解析mybatis-config.xml，实现配置信息从文件到内存对象的转换与映射。首先看下构造方法。 ~~~java // 接收配置文件流对象、environment以及通过代码传入的属性配置。 public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) { this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props); } private XMLConfigBuilder(XPathParser parser, String environment, Properties props) { super(new Configuration()); ErrorContext.instance().resource("SQL Mapper Configuration"); this.configuration.setVariables(props); this.parsed = false; this.environment = environment; this.parser = parser; } 复制代码 ~~~ XMLConfigBuilder构造方法创建了xml的解析器parser，parser负责处理复杂的xml读取工作。另外，构造方法还接收了props对象，它会覆盖从配置文件中解析的同名属性信息。 parse()方法及parseConfiguration()是解析流程的主干流程，其中，parseConfiguration中逐个完成了xml中各部分的解析，每种配置封装为了独立的方法，理解起来比较容易。每个XMLConfigBuilder只能解析一次，重复解析会导致异常。 ~~~java public Configuration parse() { //只能解析一次，否则异常 if (parsed) { throw new BuilderException("Each XMLConfigBuilder can only be used once."); } // 标记为已解析 parsed = true; //解析configuration节点下的内容 parseConfiguration(parser.evalNode("/configuration")); return configuration; } private void parseConfiguration(XNode root) { try { //issue #117 read properties first //解析属性 propertiesElement(root.evalNode("properties")); //解析配置 Properties settings = settingsAsProperties(root.evalNode("settings")); //加载vfs loadCustomVfs(settings); //加载自定义日志 loadCustomLogImpl(settings); //加载类型别名 typeAliasesElement(root.evalNode("typeAliases")); //加载插件 pluginElement(root.evalNode("plugins")); //加载对象工厂 objectFactoryElement(root.evalNode("objectFactory")); //加载对象包装器工厂 objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); //加载反射器工厂 reflectorFactoryElement(root.evalNode("reflectorFactory")); //设置配置信息 settingsElement(settings); // read it after objectFactory and objectWrapperFactory issue #631 //加载环境配置 environmentsElement(root.evalNode("environments")); databaseIdProviderElement(root.evalNode("databaseIdProvider")); //加载类型处理器 typeHandlerElement(root.evalNode("typeHandlers")); //加载mapper mapperElement(root.evalNode("mappers")); } catch (Exception e) { throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e); } } 复制代码 ~~~ 以上每部分配置的加载方法，其内部都会为configuration赋值，最终解析完成所有配置，再由parse方法返回给调用方。下面逐个了解各部分mybatis配置的解析流程。 ## 属性（properties） 用于定义mybatis运行所需的属性信息，如数据库连接相关配置。属性的定义有三种方式：在mybatis-config.xml#properties中定义属性、通过外部properties文件定义，然后使用resource方式引入mybatis-config.xml、通过 SqlSessionFactoryBuilder.build() 方法中传入属性值。 ~~~java // 入参为root.evalNode("properties")，即properties节点下所有子节点 private void propertiesElement(XNode context) throws Exception { if (context != null) { //读取所有子节点中配置的属性信息，所有信息存储defaults Properties defaults = context.getChildrenAsProperties(); //若以resource或url方式导入外部配置，则加载resource或url中配置信息 String resource = context.getStringAttribute("resource"); 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."); } //外部配置写入defaults，这里需要注意：外部配置会覆盖上面从properties中读取的配置信息 if (resource != null) { defaults.putAll(Resources.getResourceAsProperties(resource)); } else if (url != null) { defaults.putAll(Resources.getUrlAsProperties(url)); } //从configuration读取以代码方式传入的配置信息，如果有也写入defaults， //此时也会覆盖前两步加载的同名配置 Properties vars = configuration.getVariables(); if (vars != null) { defaults.putAll(vars); } //属性解析完成，存储。 parser.setVariables(defaults); configuration.setVariables(defaults); } } 复制代码 ~~~ 从这个方法的执行流程可知，如果同一个属性在不同的位置进行重复配置，那么MyBatis 将按照下面的顺序来加载： * 首先读取在 properties 元素体内指定的属性。 * 然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。 * 最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。 ## 设置（settings） ### 设置项 这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。通过以下代码+注释解释各个setting及其用途。其中，大部分setting都拥有默认值，实际可按需更改。 ~~~java public class Configuration { //环境配置 protected Environment environment; //是否允许在嵌套语句中使用分页（RowBounds），默认false protected boolean safeRowBoundsEnabled; //是否允许在嵌套语句中使用结果处理器（ResultHandler），默认true protected boolean safeResultHandlerEnabled = true; //是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。 protected boolean mapUnderscoreToCamelCase; //开启时，任一方法的调用都会加载该对象的所有延迟加载属性。 否则，每个延迟加载属性会按需加载。 protected boolean aggressiveLazyLoading; //是否允许单个语句返回多结果集（需要数据库驱动支持），默认值true protected boolean multipleResultSetsEnabled = true; //允许 JDBC 支持自动生成主键，需要数据库驱动支持。如果设置为 true，将强制使用自动生成主键。 // 尽管一些数据库驱动不支持此特性，但仍可正常工作（如 Derby）。 protected boolean useGeneratedKeys; //使用列标签代替列名。实际表现依赖于数据库驱动，具体可参考数据库驱动的相关文档，或通过对比测试来观察。 protected boolean useColumnLabel = true; //全局性地开启或关闭所有映射器配置文件中已配置的任何缓存，默认true protected boolean cacheEnabled = true; //指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值进行初始化时比较有用。 // 注意基本类型（int、boolean 等）是不能设置成 null 的。 // 默认false protected boolean callSettersOnNulls; //允许使用方法签名中的名称作为语句参数名称。 //为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 -parameters 选项。 //默认值true protected boolean useActualParamName = true; //当返回行的所有列都是空时，MyBatis默认返回 null。 当开启这个设置时，MyBatis会返回一个空实例。 // 请注意，它也适用于嵌套的结果集（如集合或关联），默认false protected boolean returnInstanceForEmptyRow; //指定 MyBatis 增加到日志名称的前缀。默认无 protected String logPrefix; //指定 MyBatis 所用日志的具体实现，未指定时将自动查找。 //SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING //默认无 protected Class <? extends Log> logImpl; //指定 VFS 的实现 protected Class <? extends VFS> vfsImpl; //MyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。 // 默认值为 SESSION，会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。 // 可选值：SESSION | STATEMENT protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION; //当没有为参数指定特定的 JDBC 类型时，空值的默认 JDBC 类型。 //某些数据库驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。 //默认值：OTHER protected JdbcType jdbcTypeForNull = JdbcType.OTHER; //指定对象的哪些方法触发一次延迟加载。用逗号分隔的方法列表。 //例如：equals,clone,hashCode,toString protected Set<String> lazyLoadTriggerMethods = new HashSet<>(Arrays.asList("equals", "clone", "hashCode", "toString")); //设置超时时间，它决定数据库驱动等待数据库响应的秒数。默认未设置。 protected Integer defaultStatementTimeout; //为驱动的结果集获取数量（fetchSize）设置一个建议值。此参数只可以在查询设置中被覆盖。默认未设置 protected Integer defaultFetchSize; //配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（PreparedStatement）； BATCH 执行器不仅重用语句还会执行批量更新。 //可选值：SIMPLE，REUSE，BATCH，默认值：SIMPLE protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE; //指定 MyBatis 应如何自动映射列到字段或属性。 // NONE 表示关闭自动映射； // PARTIAL 只会自动映射没有定义嵌套结果映射的字段。 // FULL 会自动映射任何复杂的结果集（无论是否嵌套）。 //默认值：PARTIAL protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL; //指定发现自动映射目标未知列（或未知属性类型）的行为。 //NONE: 不做任何反应 //WARNING: 输出警告日志（'org.apache.ibatis.session.AutoMappingUnknownColumnBehavior' 的日志等级必须设置为 WARN） //FAILING: 映射失败 (抛出 SqlSessionException) //默认值：NONE protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE; // 属性列表 protected Properties variables = new Properties(); protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory(); //每次 MyBatis 创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成实例化工作。 //默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认无参构造方法，要么通过存在的参数映射来调用带有参数的构造方法。 //如果想覆盖对象工厂的默认行为，可以通过创建自己的对象工厂来实现。 protected ObjectFactory objectFactory = new DefaultObjectFactory(); protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory(); //延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 //默认值：false protected boolean lazyLoadingEnabled = false; protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL protected String databaseId; /** * Configuration factory class. * Used to create Configuration for loading deserialized unread properties. * * @see <a href='https://code.google.com/p/mybatis/issues/detail?id=300'>Issue 300 (google code)</a> */ protected Class<?> configurationFactory; //语言驱动注册中心 protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry(); //存储所有Mapper中的映射声明，k-v结构 protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection") .conflictMessageProducer((savedValue, targetValue) -> ". please check " + savedValue.getResource() + " and " + targetValue.getResource()); //数据缓存，k-v结构 protected final Map<String, Cache> caches = new StrictMap<>("Caches collection"); //存储所有结果映射，来自Mapper protected final Map<String, ResultMap> resultMaps = new StrictMap<>("Result Maps collection"); //存储所有参数迎神，来自Mapper protected final Map<String, ParameterMap> parameterMaps = new StrictMap<>("Parameter Maps collection"); protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<>("Key Generators collection"); //存储已加载的资源文件，如mapper.xml protected final Set<String> loadedResources = new HashSet<>(); //存储sql片段 protected final Map<String, XNode> sqlFragments = new StrictMap<>("XML fragments parsed from previous mappers"); //存储未解析完成的声明 protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<>(); //存储未解析完成的缓存解析 protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<>(); //存储未解析完成的结果映射 protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<>(); //存储未解析完成的方法 protected final Collection<MethodResolver> incompleteMethods = new LinkedList<>(); //…… } 复制代码 ~~~ ### 加载流程 mybatis提供的配置项很多，为了方便使用，都提供了默认值。多数情况下，我们只需要按需更改即可。settingsAsProperties用于完成setting的配置解析工作： ~~~java private Properties settingsAsProperties(XNode context) { //节点为空，返回空的属性对象 if (context == null) { return new Properties(); } //读取所有设置信息，存入props Properties props = context.getChildrenAsProperties(); // Check that all settings are known to the configuration class // 通过反射方式检查props加载的配置信息是否为已知的配置项，如果存在未知配置项，抛出异常。 MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory); 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; } 复制代码 ~~~ 设置加载过程中采用了反射方式检查配置文件中配置项的合法性，存在未知配置项会导致异常。另外，这个方法把解析到的配置项返回，并没有直接为configuration设置，而是通过后面的settingsElement方法进行初始化。因为还要继续加载vfs、logImpl的配置信息。 ## 类型别名 类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。例如： ~~~java <typeAliases> <typeAlias type="com.raysonxin.dataobject.CompanyDO" alias="CompanyDO"/> </typeAliases> 复制代码 ~~~ 别名降低了使用的复杂度，它在类型查找、映射方面起到很大的作用，typeAliasesElement负责完成别名的解析加载工作： ~~~java 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); //别名为空，默认类名首字母小写；不是空，按照alias注册 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); } } } } } 复制代码 ~~~ 从代码可知，mybatis支持两种别名的注册方式： * 按照包名注册：按照指定的包扫描类，若存在别名注解，则使用注解指定的名称；否则使用类的首字母小写默认； * 按照类全限定名称注册：指定了别名则使用其作为别名，否则使用类的首字母小写默认； **另外需要注意的是，这是mybatis提供的自定义别名的方式，其实mybatis已经提供了绝大多数常用的别名，具体在Configuration的构造方法中，大家可以自行查看。** ## 插件（plugins） MyBatis 允许我们在映射语句执行过程中的某一点进行拦截调用，这可以很方便的让我们扩展mybatis的能力。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括： * Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed) * ParameterHandler (getParameterObject, setParameters) * ResultSetHandler (handleResultSets, handleOutputParameters) * StatementHandler (prepare, parameterize, batch, update, query) 这些类中方法的细节可以通过查看每个方法的签名来发现，或者直接查看 MyBatis 发行包中的源代码。先看下接口Interceptor的定义： ~~~java public interface Interceptor { //拦截接口，这里面实现拦截处理逻辑 Object intercept(Invocation invocation) throws Throwable; //为上述目标增加拦截，增强 Object plugin(Object target); //设置插件属性 void setProperties(Properties properties); } 复制代码 ~~~ ### 自定义插件 自定义插件只需实现 Interceptor 接口，并指定想要拦截的方法签名即可，这里的接口方法和签名必须与Mybatis源码中的定义完全一致，下面通过一个例子进行说明。 ~~~java @Intercepts( @Signature( type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class} ) ) public class CustomInterceptor implements Interceptor { Properties properties = new Properties(); @Override public Object intercept(Invocation invocation) throws Throwable { System.out.println("before CustomInterceptor"); Object object = invocation.proceed(); System.out.println("after CustomInterceptor"); return object; } @Override public Object plugin(Object target) { return target instanceof Executor ? Plugin.wrap(target, this) : target; } @Override public void setProperties(Properties properties) { this.properties = properties; } } 复制代码 ~~~ CustomInterceptor对Executor#query方法进行了拦截，在query前后输出一些埋点信息（可以替换为自己的业务逻辑）；plugin方法实现逻辑是：当目标组件为Executor时使用Plugin.wrap方法会为其增加插件功能。接下来在mybatis-config.xml中进行配置： ~~~xml <plugins> <plugin interceptor="com.raysonxin.plugin.CustomInterceptor"> <property name="name" value="abcd"/> </plugin> </plugins> 复制代码 ~~~ 看下运行效果： **** ### 插件加载与执行流程 直接上代码：org.apache.ibatis.builder.xml.XMLConfigBuilder#pluginElement ~~~java //入参为root.evalNode("plugins")节点 private void pluginElement(XNode parent) throws Exception { //节点为空不处理 if (parent != null) { //依次遍历子节点 for (XNode child : parent.getChildren()) { //获取插件名称 String interceptor = child.getStringAttribute("interceptor"); //获取插件属性列表 Properties properties = child.getChildrenAsProperties(); //实例化插件对象 Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance(); //设置插件属性字段 interceptorInstance.setProperties(properties); //添加插件信息到configurtation configuration.addInterceptor(interceptorInstance); } } } 复制代码 ~~~ 插件加载流程比较简单：获取名称，获取属性，实例化插件，设置插件属性，最终添加到configuration。XMLConfigBuilder完成插件加载后把插件保存在Configuration#interceptorChain，那实际运行中是如何应用的呢？ 如前文所说，mybatis支持在Executor、StatementHandler、ParameterHandler、ResultSetHandler四大组件的若干方法上通过插件增强，mybatis正是在四大组件的创建过程中采用动态代理的方式应用插件的。四大组件的创建方法在Configuration中，如下所示，以newExecutor为例对插件应用过程进行梳理。 ~~~java public Executor newExecutor(Transaction transaction, ExecutorType executorType) { executorType = executorType == null ? defaultExecutorType : executorType; executorType = executorType == null ? ExecutorType.SIMPLE : executorType; Executor executor; if (ExecutorType.BATCH == executorType) { executor = new BatchExecutor(this, transaction); } else if (ExecutorType.REUSE == executorType) { executor = new ReuseExecutor(this, transaction); } else { executor = new SimpleExecutor(this, transaction); } if (cacheEnabled) { executor = new CachingExecutor(executor); } //添加插件逻辑，采用动态代理进行包装 executor = (Executor) interceptorChain.pluginAll(executor); return executor; } 复制代码 ~~~ 组件对象创建完成后通过interceptorChain.pluginAll()方法依次应用插件，四个方法的逻辑类似。interceptor.plugin()由插件实现，它会调用Plugin#wrap方法进行增强。看下这一段的源码逻辑： ~~~java public Object pluginAll(Object target) { //循环依次遍历插件 for (Interceptor interceptor : interceptors) { target = interceptor.plugin(target); } return target; } private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) { this.target = target; this.interceptor = interceptor; this.signatureMap = signatureMap; } public static Object wrap(Object target, Interceptor interceptor) { //获取插件类的签名：就是确认插件为哪个方法进行增强 Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor); Class<?> type = target.getClass(); //获取插件类实现的所有接口 Class<?>[] interfaces = getAllInterfaces(type, signatureMap); if (interfaces.length > 0) { //采用动态代理创建代理类实现，在我们的例子中相当于为Executor对象进行了增强。 return Proxy.newProxyInstance( type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap)); } return target; } 复制代码 ~~~ 所以，经过Plugin#wrap包装后的Executor对象其实是一个代理对象，其中包含了Executor原有的逻辑，按照动态代理的原理，我们看下Plugin#invoke的执行逻辑： ~~~java @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { //从缓存中查询缓存的方法 Set<Method> methods = signatureMap.get(method.getDeclaringClass()); //判断当前方式是否为插件增强的方法 if (methods != null && methods.contains(method)) { //如果是则执行插件的intercept方法，内部会调用原有的method，入口是：Invocation#proceed return interceptor.intercept(new Invocation(target, method, args)); } //未被增强，直接调用原来的方法 return method.invoke(target, args); } catch (Exception e) { throw ExceptionUtil.unwrapThrowable(e); } } 复制代码 ~~~ 编写插件需要注意对原有mybatis的影响，防止破坏 MyBatis 的核心模块。通过 MyBatis 提供的强大机制，使用插件是非常简单的，只需实现 Interceptor 接口，并指定想要拦截的方法签名即可。 ## 类型处理器（typeHandler） MyBatis 在设置预处理语句（PreparedStatement）中的参数或从结果集中取出一个值时， 都会用类型处理器将获取到的值以合适的方式转换成 Java 类型。通过TypeHandler接口定义也可以清晰的看到TypeHandler的作用： ~~~java public interface TypeHandler<T> { void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException; T getResult(ResultSet rs, String columnName) throws SQLException; T getResult(ResultSet rs, int columnIndex) throws SQLException; T getResult(CallableStatement cs, int columnIndex) throws SQLException; } 复制代码 ~~~ ### 自定义类处理器 如果默认的类型处理器不能满足使用需求，可以按照要求自定义类型处理器。 具体做法为：实现 org.apache.ibatis.type.TypeHandler 接口， 或继承类 org.apache.ibatis.type.BaseTypeHandler， 并且可以（可选地）将它映射到一个 JDBC 类型。 以第二种方式举例，自定义类型处理器CustomTypeHandler，该处理器对应的java类型是String，jdbc类型是VARCHAR，includeNullJdbcType为true。 ~~~java @MappedJdbcTypes(value = JdbcType.VARCHAR,includeNullJdbcType = true) public class CustomTypeHandler extends BaseTypeHandler<String> { @Override public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException { ps.setString(i, parameter); } @Override public String getNullableResult(ResultSet rs, String columnName) throws SQLException { return rs.getString(columnName); } @Override public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException { return rs.getString(columnIndex); } @Override public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException { return cs.getString(columnIndex); } } 复制代码 ~~~ 然后在mybatis-config.xml中添加如下配置： ~~~xml <typeHandlers> <typeHandler handler="com.raysonxin.typehandler.CustomTypeHandler"/> </typeHandlers> 复制代码 ~~~ ### 加载流程 类型处理器的注册过程比较复杂，原因是代码中包含了许多个重载方法，看上去晕头转向，我们先来认识一下TypeHandlerRegistry是如何设计的，直接看代码。 ~~~java public final class TypeHandlerRegistry { //这个字段存储了jdbcType到类型处理器的映射，使用EnumMap private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap<>(JdbcType.class); //存储javaType对应的处理器映射，需要根据jdbcType选择处理器 private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new ConcurrentHashMap<>(); //未知类型处理器，内部会进一步解析处理器类型并路由 private final TypeHandler<Object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this); //存储所有的类型与类型处理器的映射，jdbcType或者javaType private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = new HashMap<>(); //NULL处理器 private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap(); //默认枚举类型处理器 private Class<? extends TypeHandler> defaultEnumTypeHandler = EnumTypeHandler.class; //构造方法内默认注册了常用的类型处理器 public TypeHandlerRegistry() { register(Boolean.class, new BooleanTypeHandler()); register(boolean.class, new BooleanTypeHandler()); register(JdbcType.BOOLEAN, new BooleanTypeHandler()); register(JdbcType.BIT, new BooleanTypeHandler()); //.... } //... } 复制代码 ~~~ TypeHandlerRegistry内部维护了java类型、jdbc类型与类型处理器之间的关系，分别从不同的角度进行映射： * JdbcType对应的处理器（JDBC\_TYPE\_HANDLER\_MAP）：意思是当处理一个jdbc类型时，可以从这里获取处理器； * javaType对应的处理器（TYPE\_HANDLER\_MAP）：这个字段使用了两层映射。第一层是javaType，代表了该javaType具有的处理器列表；第二层是jdbcType与处理器之间的对应关系。综合下来，确认一个处理器需要进行最终确认处理器。 * 全类型映射（ALL\_TYPE\_HANDLERS\_MAP）：维护了jdbc类型和java类型所对应的所有映射器。 * 空类型处理器和默认枚举类型处理器。 ~~~java //入参为root.evalNode("typeHandlers")节点 private void typeHandlerElement(XNode parent) { if (parent != null) { //遍历节点的子节点 for (XNode child : parent.getChildren()) { if ("package".equals(child.getName())) { String typeHandlerPackage = child.getStringAttribute("name"); typeHandlerRegistry.register(typeHandlerPackage); } else { //单个类型处理器注册的配置方式 //获取javaType，这个是类型的别名，应该注册在typeAliasRegistry String javaTypeName = child.getStringAttribute("javaType"); //获取jdbcType String jdbcTypeName = child.getStringAttribute("jdbcType"); //获取handler名称，这是类的全限定名称 String handlerTypeName = child.getStringAttribute("handler"); //通过javaType获取其对应的类型，可能为空；若指定了但是没有找到，会报异常 Class<?> javaTypeClass = resolveClass(javaTypeName); //获取JdbcType，枚举类型 JdbcType jdbcType = resolveJdbcType(jdbcTypeName); //获取处理器对应的类型 Class<?> typeHandlerClass = resolveClass(handlerTypeName); if (javaTypeClass != null) { if (jdbcType == null) { //Case-1:按照java类型、处理器类型注册 //a、根据typeHandlerClass创建处理器对象typeHandler； //b、获取typeHandler注解中的jdbcTypes，可能为空 //c、jdbcTypes!=null：注册javaType-jdbcType-handler，如果注解中includeNullJdbcType=true，注册空类型； // jdbcTypes==null：仅注册javaType-handler； typeHandlerRegistry.register(javaTypeClass, typeHandlerClass); } else { //Case-2:按照java类型、jdbc类型、处理器类型注册 //a、创建typeHandler对象； //b、注册关联javaType-jdbcType-handler typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass); } } else { //Case-3:按照处理器类型注册 //a、获取typeHandlerClass的MappedTypes注解； //b、javaType不为空：按照javatype注册，内部会获取MappedJdbcTypes，关联三者。 //c、这种情况还没看明白。。。 typeHandlerRegistry.register(typeHandlerClass); } } } } } //Case-1～3，最终都会走到这里 private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) { if (javaType != null) { //从map中查询已有的javaType对应的处理器 Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType); //不存在或者为空，执行初始化与添加操作 if (map == null || map == NULL_TYPE_HANDLER_MAP) { map = new HashMap<>(); TYPE_HANDLER_MAP.put(javaType, map); } //关联javaType-jdbcType-handler map.put(jdbcType, handler); } //加入总的映射 ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler); } 复制代码 ~~~ 通过代码可以发现，JDBC\_TYPE\_HANDLER\_MAP仅仅是在构造方法逻辑中进行了添加，相当于是mybatis默认的处理器。我们自定义的处理器会添加到TYPE\_HANDLER\_MAP、ALL\_TYPE\_HANDLERS\_MAP，虽然有不同的注册方式，但是殊途同归，都是通过上述方法实现了注册。 总结一下： * 通过配置文件自定义的类型处理器，会添加到TYPE\_HANDLER\_MAP、ALL\_TYPE\_HANDLERS\_MAP，而获取类型处理器是优先使用javaType来查询的。如果自定义的类型处理器了重复定义了javaType或jdbcType，会对系统默认的处理器产生覆盖。 * 如果在类型处理器的注解和xml配置中同时声明了javaType，那么xml中配置的javaType会生效。 ## 映射器（mapper） MyBatis 的真正强大在于它的语句映射，这是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 致力于减少使用成本，让用户能更专注于 SQL 代码。——*摘自《XML 映射器》* 映射器是mybatis面向接口编程的利器，它使用动态代理技术，实现了接口与mapper中sql语句的动态绑定，免去了JDBC中手动实现执行Statement的繁杂过程。mybatis提供多种方式支持mapper资源查找：可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。 ### 映射器元素 SQL 映射文件只有很少的几个顶级元素（按照应被定义的顺序列出）： * cache – 该命名空间的缓存配置。 * cache-ref – 引用其它命名空间的缓存配置。 * resultMap – 描述如何从数据库结果集中加载对象，是最复杂也是最强大的元素。 * ~parameterMap – 老式风格的参数映射。此元素已被废弃，并可能在将来被移除！请使用行内参数映射。文档中不会介绍此元素。~ * sql – 可被其它语句引用的可重用语句块。 * insert – 映射插入语句。 * update – 映射更新语句。 * delete – 映射删除语句。 * select – 映射查询语句 以上顶级元素还有较多的属性用于控制其行为，大家可以自行查阅官方文档，这里不再贴出来了。 ### 加载流程 我们随着示例及源码来看下mybatis是如何加载解析mapper的，然后通过另外一篇文章来剖析其执行过程。示例配置信息，示例中定义了CompanyMapper.xml，以资源方式引入到mybatis-config.xml。 ~~~xml <!--mybatis-config.xml--> <mappers> <mapper resource="mapper/CompanyMapper.xml"/> </mappers> <!--CompanyMapper.xml--> <mapper namespace="com.raysonxin.dao.CompanyDao"> <resultMap id="baseResultMap" type="com.raysonxin.dataobject.CompanyDO"> <id column="id" property="id"/> <result column="name" property="name"/> <result column="cpy_type" property="cpyType"/> </resultMap> <sql id="BaseColumns"> id,name,cpy_type </sql> <select id="selectById" resultMap="baseResultMap"> select <include refid="BaseColumns"></include> from company where id= #{id} and name = #{name} </select> </mapper> 复制代码 ~~~ mapper解析入口为XMLConfigBuilder#mapperElement，通过代码注释走下流程。 ~~~java //入参为root.evalNode("mappers")，即示例中的mappers节点，它可包含多个mapper子节点 private void mapperElement(XNode parent) throws Exception { if (parent != null) { for (XNode child : parent.getChildren()) { // 整包方式添加mapper if ("package".equals(child.getName())) { String mapperPackage = child.getStringAttribute("name"); configuration.addMappers(mapperPackage); } else { //这里包含了三种方式：资源导入、资源全限定路径、类名，分别获取mapper节点属性值 //三个值中只能配置一个，否则会报异常（最后的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类进行mapper解析，这里是重点。 XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments()); mapperParser.parse(); } //资源全限定路径方式 else if (resource == null && url != null && mapperClass == null) { ErrorContext.instance().resource(url); InputStream inputStream = Resources.getUrlAsStream(url); //使用XMLMapperBuilder类进行mapper解析，同上。 XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments()); mapperParser.parse(); } //类名方式 else if (resource == null && url == null && mapperClass != null) { Class<?> mapperInterface = Resources.classForName(mapperClass); configuration.addMapper(mapperInterface); } //非以上三种情况，异常 else { throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one."); } } } } } 复制代码 ~~~ 示例代码以resource方式引入mapper，按照这条线走下去，创建XMLMapperBuilder后调用其parse方法。这里与XMLConfigBuilder类似，同样使用XPathParser进行xml解析，另外使用MapperBuilderAssistant构建MappedStatement。 ~~~java private XMLMapperBuilder(XPathParser parser, Configuration configuration, String resource, Map<String, XNode> sqlFragments) { super(configuration); this.builderAssistant = new MapperBuilderAssistant(configuration, resource); this.parser = parser; this.sqlFragments = sqlFragments; this.resource = resource; } 复制代码 ~~~ 接下来进入解析流程，即XMLMapperBuilder#parse方法。大体流程是：若资源未被加载过，则解析mapper文件中的元素，把mapper添加到已加载资源，绑定mapper与namespace。无论是否加载过当前资源，都会处理那些之前未完成的ResultMap、CacheRef、Statement。 ~~~java public void parse() { //判断资源是否已经加载 if (!configuration.isResourceLoaded(resource)) { //这个是mapper解析的核心方法，入参是mapper对应的资源文件，示例中的CompanyMapper.xml configurationElement(parser.evalNode("/mapper")); //添加已加载资源到configuration configuration.addLoadedResource(resource); //这个方法是绑定mapper与namespace bindMapperForNamespace(); } parsePendingResultMaps(); parsePendingCacheRefs(); parsePendingStatements(); } 复制代码 ~~~ 核心解析方式是configurationElement，它依次解析mapper文件中的cache-ref、cache、parameterMap、resultMap、sql、select|insert|update|delete，本次重点分析后面三者的解析过程。 ~~~java private void configurationElement(XNode context) { try { //获取mapper中的namespace，示例中为：com.raysonxin.dao.CompanyDao String namespace = context.getStringAttribute("namespace"); if (namespace == null || namespace.equals("")) { throw new BuilderException("Mapper's namespace cannot be empty"); } //设置builderAssistant的namespace builderAssistant.setCurrentNamespace(namespace); //解析cache-ref内容 cacheRefElement(context.evalNode("cache-ref")); //解析cache内容 cacheElement(context.evalNode("cache")); //解析parameterMap节点 parameterMapElement(context.evalNodes("/mapper/parameterMap")); //解析resultMap节点 resultMapElements(context.evalNodes("/mapper/resultMap")); //解析sql节点 sqlElement(context.evalNodes("/mapper/sql")); //构建statement 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); } } 复制代码 ~~~ #### resultMap 下可以定义多个resultMap，通常我们会把常用的返回字段定义为一个resultMap，方便在查询语句中引用。我们从resultMapElements开始看下源码： ~~~java private void resultMapElements(List<XNode> list) throws Exception { for (XNode resultMapNode : list) { try { resultMapElement(resultMapNode); } catch (IncompleteElementException e) { // ignore, it will be retried } } } private ResultMap resultMapElement(XNode resultMapNode) throws Exception { return resultMapElement(resultMapNode, Collections.<ResultMapping> emptyList(), null); } //真正的解析工作从这里开始 private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings, Class<?> enclosingType) throws Exception { ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier()); //获取resultMap的id属性，示例中baseResultMap String id = resultMapNode.getStringAttribute("id", resultMapNode.getValueBasedIdentifier()); //获取resultMap的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"); //获取type对应的类型对象，首先从typeAliasRegistry获取，否则按照全路径限定名称反射创建 Class<?> typeClass = resolveClass(type); if (typeClass == null) { typeClass = inheritEnclosingType(resultMapNode, enclosingType); } Discriminator discriminator = null; List<ResultMapping> resultMappings = new ArrayList<>(); resultMappings.addAll(additionalResultMappings); List<XNode> resultChildren = resultMapNode.getChildren(); //依次解析子节点 for (XNode resultChild : resultChildren) { //是否为构造方法 if ("constructor".equals(resultChild.getName())) { //处理构造方法 processConstructorElement(resultChild, typeClass, resultMappings); } //discriminator鉴别器 else if ("discriminator".equals(resultChild.getName())) { discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings); } //其他节点 else { List<ResultFlag> flags = new ArrayList<>(); // 是否为id节点 if ("id".equals(resultChild.getName())) { flags.add(ResultFlag.ID); } //构建resultMap：buildResultMappingFromContext resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags)); } } ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping); try { return resultMapResolver.resolve(); } catch (IncompleteElementException e) { configuration.addIncompleteResultMap(resultMapResolver); throw e; } } 复制代码 ~~~ 不考虑复杂的resultMap，我们示例中的节点类型为id和result两种，我们直接进入方法buildResultMappingFromContext： ~~~java 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值，对应javaType的字段 property = context.getStringAttribute("property"); } //数据表的字段 String column = context.getStringAttribute("column"); //获取javaType String javaType = context.getStringAttribute("javaType"); //获取jdbcType String jdbcType = context.getStringAttribute("jdbcType"); String nestedSelect = context.getStringAttribute("select"); String nestedResultMap = context.getStringAttribute("resultMap", processNestedResultMappings(context, Collections.<ResultMapping> 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); //获取类型处理器 Class<? extends TypeHandler<?>> typeHandlerClass = resolveClass(typeHandler); //jdbc类型枚举 JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType); //创建ResultMapping对象并返回 return builderAssistant.buildResultMapping(resultType, property, column, javaTypeClass, jdbcTypeEnum, nestedSelect, nestedResultMap, notNullColumn, columnPrefix, typeHandlerClass, flags, resultSet, foreignColumn, lazy); } 复制代码 ~~~ 这个解析过程包含了resultMap高级用法的逻辑，比如association、collections等，我们先从简单、常用的方式入手。buildResultMappingFromContext最终返回了resultMap中某个字段的映射信息，构建了java类型与数据库字段的映射关系。这样，通过遍历所有字段把resultMap下的所有字段一一映射。 我们再回到方法resultMapElement，遍历所有节点后得到resultMappings，创建了ResultMapResolver对象。从名称可以知道，这个类是ResultMap的解析器，它最终把resultMap配置信息转为mybaits的ResultMap对象并添加到configuration。 #### sql 实际开发中，我们可以使用sql标签定义那些可复用的sql片段，简化mapper文件的配置。在mybatis解析sql时，它也只是一个中间过程，它是解析select|update|insert|delete语句的基础。 ~~~java private void sqlElement(List<XNode> list) { if (configuration.getDatabaseId() != null) { sqlElement(list, configuration.getDatabaseId()); } sqlElement(list, null); } private void sqlElement(List<XNode> list, String requiredDatabaseId) { for (XNode context : list) { String databaseId = context.getStringAttribute("databaseId"); String id = context.getStringAttribute("id"); //拼接namespace，结果为：namespace+"."+id id = builderAssistant.applyCurrentNamespace(id, false); //是否符合datbaseId要求 if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) { //sqlFragments保存所有sql片段 sqlFragments.put(id, context); } } } 复制代码 ~~~ #### select|insert|update|delete select|insert|update|delete对于sql语句中的同名命令，是我们使用最频繁的部分，最终mybatis会把这些标签转为MappedStatement，存储在configuration，同时与Mapper接口方法在运行时绑定。 ~~~java private void buildStatementFromContext(List<XNode> list) { if (configuration.getDatabaseId() != null) { buildStatementFromContext(list, configuration.getDatabaseId()); } buildStatementFromContext(list, null); } 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) { configuration.addIncompleteStatement(statementParser); } } } 复制代码 ~~~ 从代码可以看到XMLStatementBuilder，它是命令标签的处理器，核心方法是parseStatementNode。到这里，我们已经见过了XMLConfigBuilder、XMLMapperBuilder。看下处理过程： ~~~java public void parseStatementNode() { //获取标签中的id属性，如：selectById String id = context.getStringAttribute("id"); //databaseId，为空 String databaseId = context.getStringAttribute("databaseId"); if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) { return; } //属性fetchSize Integer fetchSize = context.getIntAttribute("fetchSize"); //属性timeout Integer timeout = context.getIntAttribute("timeout"); //属性parameterMap String parameterMap = context.getStringAttribute("parameterMap"); //属性parameterType String parameterType = context.getStringAttribute("parameterType"); //解析参数类型信息 Class<?> parameterTypeClass = resolveClass(parameterType); //获取属性resultMap String resultMap = context.getStringAttribute("resultMap"); //获取属性resultType String resultType = context.getStringAttribute("resultType"); String lang = context.getStringAttribute("lang"); LanguageDriver langDriver = getLanguageDriver(lang); Class<?> resultTypeClass = resolveClass(resultType); String resultSetType = context.getStringAttribute("resultSetType"); //获取属性statementType，未设置时使用默认值PREPARED StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString())); ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType); //获取nodeName，就是标签的类型，select、insert之类 String nodeName = context.getNode().getNodeName(); //命令类型 SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH)); //判断是否为select命令 boolean isSelect = sqlCommandType == SqlCommandType.SELECT; //是否刷新缓存 boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect); //是否使用缓存 boolean useCache = context.getBooleanAttribute("useCache", isSelect); boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false); // Include Fragments before parsing //这里解析sql语句中的include标签 XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant); includeParser.applyIncludes(context.getNode()); // Parse selectKey after includes and remove them. //解析selectKey标签 processSelectKeyNodes(id, parameterTypeClass, langDriver); // Parse the SQL (pre: <selectKey> and <include> were parsed and removed) //创建SqlSource，必须在inclue和selectKey解析完成后执行， //内部会根据sql语句是否包含动态标签创建不同类型的sqlSource，解析sql所需的参数映射信息 //这个地方需要一篇单独的文章来分析 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 = builderAssistant.applyCurrentNamespace(keyStatementId, true); 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); } 复制代码 ~~~ 源码的过程梳理一下： * 首先解析标签的基础属性，如id、fetchSize等， * 解析sql语句中inclue标签（把include的内容替换拼接进来）， * 处理selcetKey标签（特定的databaseProvider需要）， * 接下来创建SqlSource：这个是mybatis的核心内容，涉及到sql语句中参数提取、动态赋值等，以后在详细说明； * 处理KeyGenerator； * 使用builderAssistant创建MappedStatement，添加到configuration # 总结 Configuration是mybatis的全局配置类，mybatis运行时所需的一切都缓存在这里，它伴随mybatis的整个生命周期。理论上讲，Configuration是配置文件mybatis-config.xml的代码映射，mybatis提供了充分的灵活性、可扩展性，方便开发人员通过配置文件改变其运行行为。 本文通过示例及源码把mybatis-config.xml的解析过程、Configuration配置的大部分内容进行了梳理，通过梳理确实获益匪浅。由于水平优先，文中很多内容确实没有描述清楚，随着学习的不断深入，再做完善。 作者：码路印记 链接：https://juejin.cn/post/6878979290252361741 来源：掘金 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。