"阅读目录：序言一、初始化二、mapper 接口方法是怎样被调用到的？三、Mapper 接口的代理创建过程 3.1、首先我们会配置需要扫描的基本包路径 3.2、开始扫描 3.3、bean 注册完成并创建 sqlSession 代理 3.4、创建 sqlSession 代理类 3.5、小结四、 ...."

someone1
AI专业者开发社区 1 号成员
AI开发者社区 • 0 回帖 • 1 浏览 • 5 个月前

mybatis 的 dao 接口跟 xml 文件里面的 sql 是如何建立关系的？一步步解析

阅读目录：

阅读正文：

回到顶部

序言

在开始正文之前，首先解释 Dao 接口和 XML 文件里的 SQL 是如何一一对应的？

一句话讲完就是：mybatis 会先解析这些 xml 文件，通过 xml 文件里面的命名空间（namespace）跟 dao 建立关系；然后 xml 中的每段 sql 会有一个 id 跟 dao 中的接口进行关联。

那么问题来了: "如果我有两个这个 xml 文件都跟这个 dao 建立关系了，那不是就是冲突了？"

带着这个疑问我们就要开始下面的正题了！

回到顶部

一、初始化

首先我们要知道每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为中心的，SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。

但SqlSessionFactory是一个接口，它里面其实就两个方法：openSession、getConfiguration

其中，openSession方法是为了获取一个 SqlSession 对象，完成必要数据库增删改查功能。但是，SqlSessionFactory 属性太少了，所以需要getConfiguration的配合；来配置 mapper 映射文件、SQL 参数、返回值类型、缓存等属性。

/**
 * Creates an {@link SqlSession} out of a connection or a DataSource
 * 
 * @author Clinton Begin
 */
public interface SqlSessionFactory {
SqlSession openSession();
SqlSession openSession(boolean autoCommit);
SqlSession openSession(Connection connection);
SqlSession openSession(TransactionIsolationLevel level);
SqlSession openSession(ExecutorType execType);
SqlSession openSession(ExecutorType execType, boolean autoCommit);
SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
SqlSession openSession(ExecutorType execType, Connection connection);
Configuration getConfiguration();
}

可以看到 getConfiguration 是属于 Configuration 类的一个方法。你可以把它当成一个配置管家。MyBatis 所有的配置信息都维持在 Configuration 对象之中，基本每个对象都会持有它的引用。

但日常开发中我们都是将 Mybatis 与 Spring 一起使用的，所以把实例化交给 Spring 处理。

因此我们可以看下org.mybatis.spring.SqlSessionFactoryBean，它实现了 InitializingBean 接口。这说明，在这个类被实例化之后会调用到 afterPropertiesSet()。它只有一个方法

public void afterPropertiesSet() throws Exception {
	this.sqlSessionFactory = buildSqlSessionFactory();
}

而这个afterPropertiesSet方法只有一个动作，就是buildSqlSessionFactory。它可以分为两部分来看:

1、从配置文件的 property 属性中加载各种组件，解析配置到 configuration 中
2、加载 mapper 文件，解析 SQL 语句，封装成 MappedStatement 对象，配置到 configuration 中。

回到顶部

二、mapper 接口方法是怎样被调用到的？

大致有如下两种方式：

Mybatis 提供的 API

使用 Mybatis 提供的 API 进行操作，通过获取 SqlSession 对象，然后根据 Statement Id 和参数来操作数据库。

String statement = "com.mmzsblog.business.dao.MemberMapper.getMemberList";
List<Member> result = sqlsession.selectList(statement);

mapper 接口

定义 Mapper 接口，并在里面定义一系列业务数据操作方法。在 Service 层通过注入 mapper 属性，调用其方法就可以执行数据库操作。就像下面这样

public interface MemberMapper {	
	List<Member> getMemberList();
}
@Service
public class MemberServiceImpl implements MemberService{
@Resource
private MemberMapper memberMapper;
<span class="hljs-meta">@Override</span>
<span class="hljs-keyword">public</span> List&lt;Member&gt; <span class="hljs-title function_">getMemberList</span><span class="hljs-params">()</span> {
	<span class="hljs-keyword">return</span> memberMapper.getMemberList();
}

}

那么，MemberMapper 只是个接口，并没有任何实现类。我们在调用它的时候，它是怎样最终执行到我们的 SQL 语句的呢？

回到顶部

三、Mapper 接口的代理创建过程

3.1、首先我们会配置需要扫描的基本包路径

通过注解的方式配置：

@MapperScan({"com.mmzsblog.business.dao"})

或者 xml 的方式配置：

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
	<property name="basePackage" value="com.mmzsblog.business.dao" />
	<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
</bean>

3.2、开始扫描

我们来到org.mybatis.spring.mapper.MapperScannerConfigurer这个类，可以看到它实现了几个接口。

其中的重点是BeanDefinitionRegistryPostProcessor。它可以动态的注册 Bean 信息，方法为postProcessBeanDefinitionRegistry()。

    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        if (this.processPropertyPlaceHolders) {
            this.processPropertyPlaceHolders();
        }
    <span class="hljs-comment">// 创建ClassPath扫描器，设置属性，然后调用扫描方法</span>
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(<span class="hljs-keyword">this</span>.addToConfig);
    scanner.setAnnotationClass(<span class="hljs-keyword">this</span>.annotationClass);
    scanner.setMarkerInterface(<span class="hljs-keyword">this</span>.markerInterface);
    scanner.setSqlSessionFactory(<span class="hljs-keyword">this</span>.sqlSessionFactory);
    scanner.setSqlSessionTemplate(<span class="hljs-keyword">this</span>.sqlSessionTemplate);
    scanner.setSqlSessionFactoryBeanName(<span class="hljs-keyword">this</span>.sqlSessionFactoryBeanName);
    scanner.setSqlSessionTemplateBeanName(<span class="hljs-keyword">this</span>.sqlSessionTemplateBeanName);
    scanner.setResourceLoader(<span class="hljs-keyword">this</span>.applicationContext);
    scanner.setBeanNameGenerator(<span class="hljs-keyword">this</span>.nameGenerator);
    <span class="hljs-comment">// 创建ClassPath扫描器，设置属性，然后调用扫描方法</span>
    scanner.registerFilters();
    scanner.scan(StringUtils.tokenizeToStringArray(<span class="hljs-keyword">this</span>.basePackage, <span class="hljs-string">",; \t\n"</span>));
}

ClassPathMapperScanner继承自 Spring 中的类ClassPathBeanDefinitionScanner，所以它的 scan 方法会调用到父类ClassPathBeanDefinitionScanner的 scan 方法，

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
    ……
    public int scan(String... basePackages) {
        // 
        int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
        this.doScan(basePackages);
        if (this.includeAnnotationConfig) {
            AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
        }
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">this</span>.registry.getBeanDefinitionCount() - beanCountAtScanStart;
}
……

}

而在父类的 scan 方法中又调用到子类ClassPathMapperScanner重写的 doScan 方法。

public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
    ……
    public Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
        if (beanDefinitions.isEmpty()) {
            this.logger.warn("No MyBatis mapper was found in'" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
        } else {
            this.processBeanDefinitions(beanDefinitions);
        }
    <span class="hljs-keyword">return</span> beanDefinitions;
}
……

}

此处super.doScan(basePackages)是 Spring 中的方法, 就不贴代码多叙述了，想详细了解的话，可以自己翻一下源码哦。

3.3、bean 注册完成并创建 sqlSession 代理

并且经过上面这些步骤，此时已经扫描到了所有的 Mapper 接口，并将其注册为 BeanDefinition 对象。而注册的时候就是用到了上面doScan方法中的processBeanDefinitions方法。

public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
    ……
    // 设置 beanClass
    private MapperFactoryBean<?> mapperFactoryBean = new MapperFactoryBean();
    ……
<span class="hljs-keyword">private</span> void processBeanDefinitions(Set&lt;BeanDefinitionHolder&gt; beanDefinitions) {
    Iterator var3 = beanDefinitions.iterator();

    <span class="hljs-keyword">while</span>(var3.hasNext()) {
        BeanDefinitionHolder holder = (BeanDefinitionHolder)var3.next();
        GenericBeanDefinition definition = (GenericBeanDefinition)holder.getBeanDefinition();
        <span class="hljs-keyword">if</span> (<span class="hljs-keyword">this</span>.logger.isDebugEnabled()) {
            <span class="hljs-keyword">this</span>.logger.debug(<span class="hljs-string">"Creating MapperFactoryBean with name '"</span> + holder.getBeanName() + <span class="hljs-string">"' and '"</span> + definition.getBeanClassName() + <span class="hljs-string">"' mapperInterface"</span>);
        }
        <span class="hljs-comment">// 将mapper接口的名称添加到构造参数</span>
        definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName());
        <span class="hljs-comment">// 设置BeanDefinition的class</span>
        definition.setBeanClass(<span class="hljs-keyword">this</span>.mapperFactoryBean.getClass());
        <span class="hljs-comment">// 添加属性addToConfig</span>
        definition.getPropertyValues().add(<span class="hljs-string">"addToConfig"</span>, <span class="hljs-keyword">this</span>.addToConfig);
        boolean explicitFactoryUsed = <span class="hljs-literal">false</span>;
        <span class="hljs-comment">// 添加属性sqlSessionFactory</span>
        <span class="hljs-keyword">if</span> (StringUtils.hasText(<span class="hljs-keyword">this</span>.sqlSessionFactoryBeanName)) {
            definition.getPropertyValues().add(<span class="hljs-string">"sqlSessionFactory"</span>, new RuntimeBeanReference(<span class="hljs-keyword">this</span>.sqlSessionFactoryBeanName));
            explicitFactoryUsed = <span class="hljs-literal">true</span>;
        } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-keyword">this</span>.sqlSessionFactory != <span class="hljs-literal">null</span>) {
            definition.getPropertyValues().add(<span class="hljs-string">"sqlSessionFactory"</span>, <span class="hljs-keyword">this</span>.sqlSessionFactory);
            explicitFactoryUsed = <span class="hljs-literal">true</span>;
        }

        <span class="hljs-keyword">if</span> (StringUtils.hasText(<span class="hljs-keyword">this</span>.sqlSessionTemplateBeanName)) {
            <span class="hljs-keyword">if</span> (explicitFactoryUsed) {
                <span class="hljs-keyword">this</span>.logger.warn(<span class="hljs-string">"Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored."</span>);
            }

            definition.getPropertyValues().add(<span class="hljs-string">"sqlSessionTemplate"</span>, new RuntimeBeanReference(<span class="hljs-keyword">this</span>.sqlSessionTemplateBeanName));
            explicitFactoryUsed = <span class="hljs-literal">true</span>;
        } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (<span class="hljs-keyword">this</span>.sqlSessionTemplate != <span class="hljs-literal">null</span>) {
            <span class="hljs-keyword">if</span> (explicitFactoryUsed) {
                <span class="hljs-keyword">this</span>.logger.warn(<span class="hljs-string">"Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored."</span>);
            }

            definition.getPropertyValues().add(<span class="hljs-string">"sqlSessionTemplate"</span>, <span class="hljs-keyword">this</span>.sqlSessionTemplate);
            explicitFactoryUsed = <span class="hljs-literal">true</span>;
        }

        <span class="hljs-keyword">if</span> (!explicitFactoryUsed) {
            <span class="hljs-keyword">if</span> (<span class="hljs-keyword">this</span>.logger.isDebugEnabled()) {
                <span class="hljs-keyword">this</span>.logger.debug(<span class="hljs-string">"Enabling autowire by type for MapperFactoryBean with name '"</span> + holder.getBeanName() + <span class="hljs-string">"'."</span>);
            }

            definition.setAutowireMode(<span class="hljs-number">2</span>);
        }
    }
}
……

}

处理的过程相对比较简单，只是往 BeanDefinition 对象中设置了一些属性。例如：

设置 beanClass

设置 BeanDefinition 对象的 BeanClass 为MapperFactoryBean<?>。这就相当于使用 MemberMapper 注册时：当前的 mapper 接口在 Spring 容器中，beanName 是 memberMapper，beanClass 是 MapperFactoryBean.class。故在 Spring 的 IOC 初始化的时候，实例化的对象就是 MapperFactoryBean 对象。

设置 sqlSessionFactory 属性

为 BeanDefinition 对象添加属性 sqlSessionFactory，是为了 BeanDefinition 对象设置 PropertyValue 的时候，方便调用到 setSqlSessionFactory()。

3.4、创建 sqlSession 代理类

最终在 setSqlSessionFactory 这个方法里，sqlSession 获取到的是 SqlSessionTemplate 实例。而在 SqlSessionTemplate 对象中，主要包含 sqlSessionFactory 和 sqlSessionProxy，而 sqlSessionProxy 实际上是 SqlSession 接口的代理对象。实际调用的是代理类的 invoke 方法。

public class MapperProxy<T> implements InvocationHandler, Serializable {
  ……
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }
  ……
}

3.5、小结

Mapper 接口的代理创建过程大致如下：

1、扫描 mapper 接口基本包路径下的所有对象，将其注册为 BeanDefinition 对象
2、设置 BeanDefinition 的对象的 beanClass 和 sqlSessionFactory 属性（而其中获取 BeanDefinition 对象的时候，调用其工厂方法 getObject，返回 mapper 接口的代理类）
3、设置 sqlSessionFactory 属性的时候，会调用 SqlSessionTemplate 的构造方法，创建 SqlSession 接口的代理类

最后我们在 Service 层，通过

@Resource 
private MemberMapper memberDao;

注入属性的时候，返回的就是代理类。执行 memberDao 的方法的时候，实际调用的也是代理类的 invoke 方法。

回到顶部

四、回答最开始的问题

Mybatis 在初始化 SqlSessionFactoryBean 的时候，找到配置需要扫描的基本包路径去解析里面所有的 XML 文件。重点就在如下两个地方：

1、创建 SqlSource

Mybatis 会把每个 SQL 标签封装成 SqlSource 对象。然后根据 SQL 语句的不同，又分为动态 SQL 和静态 SQL。其中，静态 SQL 包含一段 String 类型的 sql 语句；而动态 SQL 则是由一个个 SqlNode 组成。

2、创建 MappedStatement

XML 文件中的每一个 SQL 标签就对应一个 MappedStatement 对象，这里面有两个属性很重要。

全限定类名 + 方法名组成的 ID。

sqlSource

当前 SQL 标签对应的 SqlSource 对象。
创建完MappedStatement对象，会将它缓存到Configuration#mappedStatements中。

前面初始化中提到的 Configuration 对象，我们知道它就是 Mybatis 中的配置大管家，基本所有的配置信息都维护在这里。

例如下面这样一段代码：

<!-- namespace 的值就是全限定类名 -->
<mapper namespace="com.java.mmzsblog.dao.MemberMapper">
    ……
    <!-- select 标签中 id 的值就是方法名，它和全限定类中的方法名是对应的 -->
    <select id="getMemberById" resultType="com.java.mmzsblog.entity.member">
        select * from member
        <where>
            <if test="memberId!=null">
                and member_id=#{memberId}
            </if>
        </where>
    </select>
    ……
</mapper>

把所有的 XML 都解析完成之后，Configuration 就包含了所有的 SQL 信息。然后解析完成的 XML 大概就是这样了：

看到上面的图示，聪明如你，也许就大概知道了。当我们执行 Mybatis 方法的时候，就通过全限定类名+方法名找到 MappedStatement 对象，然后解析里面的 SQL 内容，执行即可。

回到顶部

参考原文

https://juejin.im/post/5c9f4af6f265da30bf15c45a

作者：淼淼之森
欢迎任何形式的转载，但请务必注明出处。
如果你觉得本文还可以，那就点击一下推荐，让更多人看到吧！
限于本人水平，如果文章和代码有表述不当之处，还请不吝赐教。

mybatis 的 dao 接口跟 xml 文件里面的 sql 是如何建立关系的？一步步解析

序言

一、初始化

二、mapper 接口方法是怎样被调用到的？

三、Mapper 接口的代理创建过程

3.1、首先我们会配置需要扫描的基本包路径

3.2、开始扫描

3.3、bean 注册完成并创建 sqlSession 代理

3.4、创建 sqlSession 代理类

3.5、小结

四、回答最开始的问题

参考原文

相关帖子

随便看看

mybatis 的 dao 接口跟 xml 文件里面的 sql 是如何建立关系的？一步步解析