mybatis 的 dao 接口跟 xml 文件里面的 sql 是如何创建关系的？

时间  2020-01-01
标签 mybatis dao 接口 xml 文件 里面 sql 如何 创建 关系 栏目 MyBatis 繁體版
原文   原文链接

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

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

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

带着这个疑问咱们就要开始下面的正题了！数据库

1、初始化

首先咱们要知道每一个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为中心的，SqlSessionFactory 的实例能够经过 SqlSessionFactoryBuilder 得到。缓存

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

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

/**
 * 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

但平常开发中咱们都是将Mybatis与Spring一块儿使用的，因此把实例化交给Spring处理。app

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

public void afterPropertiesSet() throws Exception {
    this.sqlSessionFactory = buildSqlSessionFactory();
}复制代码

而这个afterPropertiesSet方法只有一个动做，就是buildSqlSessionFactory。它能够分为两部分来看:

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

2、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;
    
    @Override
    public List<Member> getMemberList() {
        return memberMapper.getMemberList();
    }
}复制代码

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

3、Mapper接口的代理建立过程

3.一、首先咱们会配置须要扫描的基本包路径

经过注解的方式配置：

@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.二、开始扫描

咱们来到org.mybatis.spring.mapper.MapperScannerConfigurer这个类，能够看到它实现了几个接口。

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

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        if (this.processPropertyPlaceHolders) {
            this.processPropertyPlaceHolders();
        }
        
        // 建立ClassPath扫描器，设置属性，而后调用扫描方法
        ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
        scanner.setAddToConfig(this.addToConfig);
        scanner.setAnnotationClass(this.annotationClass);
        scanner.setMarkerInterface(this.markerInterface);
        scanner.setSqlSessionFactory(this.sqlSessionFactory);
        scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
        scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
        scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
        scanner.setResourceLoader(this.applicationContext);
        scanner.setBeanNameGenerator(this.nameGenerator);
        // 建立ClassPath扫描器，设置属性，而后调用扫描方法
        scanner.registerFilters();
        scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ",; \t\n"));
    }复制代码

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);
        }

        return this.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);
        }

        return beanDefinitions;
    }
    ……
}    复制代码

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

3.三、bean注册完成并建立sqlSession代理

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

public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
    ……
    // 设置beanClass
    private MapperFactoryBean<?> mapperFactoryBean = new MapperFactoryBean();
    ……
    
    private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
        Iterator var3 = beanDefinitions.iterator();

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

            if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
                if (explicitFactoryUsed) {
                    this.logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
                }

                definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
                explicitFactoryUsed = true;
            } else if (this.sqlSessionTemplate != null) {
                if (explicitFactoryUsed) {
                    this.logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
                }

                definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
                explicitFactoryUsed = true;
            }

            if (!explicitFactoryUsed) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
                }

                definition.setAutowireMode(2);
            }
        }
    }
    ……
}    复制代码

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

  • 设置beanClass

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

  • 设置sqlSessionFactory属性

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

3.四、建立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.五、小结

Mapper接口的代理建立过程大体以下：

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

最后咱们在Service层，经过

@Resource 
private MemberMapper memberDao;复制代码

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

4、回答最开始的问题

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

一、建立SqlSource

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

二、建立MappedStatement

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

  • id

全限定类名+方法名组成的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内容，执行便可。


欢迎关注公众号：Java学习之道

我的博客网站：www.mmzsblog.cn

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程