mybatis工作流程

  先来看一下MyBatis 的编程式使用的方法:

public void testMapper() throws IOException {
  String resource = "mybatis-config.xml";
  InputStream inputStream = Resources.getResourceAsStream(resource);
  SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  SqlSession session = sqlSessionFactory.openSession();
  try {
    BlogMapper mapper = session.getMapper(BlogMapper.class);
    Blog blog = mapper.selectBlogById(1);
    System.out.println(blog);
  } finally {
    session.close();
  }
}

  我们再来捋MyBatis 的主要工作流程:首先在MyBatis 启动的时候我们要去解析配置文件,包括全局配置文件和映射器配置文件,这里面包含了我们怎么控制MyBatis 的行为,和我们要对数据库下达的指令,也就是我们的SQL 信息。我们会把它们解析成一个Configuration 对象。接下来就是我们操作数据库的接口,它在应用程序和数据库中间,代表我们跟数据库之间的一次连接:这个就是SqlSession 对象。我们要获得一个会话, 必须有一个会话工厂SqlSessionFactory 。SqlSessionFactory 里面又必须包含我们的所有的配置信息,所以我们会通过一个Builder 来创建工厂类。

  我们知道,MyBatis 是对JDBC 的封装,也就是意味着底层一定会出现JDBC 的一些核心对象,比如执行SQL 的Statement,结果集ResultSet。在Mybatis 里面,SqlSession 只是提供给应用的一个接口,还不是SQL 的真正的执行对象。我们通过查看SqlSession源码发现,SqlSession 持有了一个Executor 对象,用来封装对数据库的操作。在执行器Executor 执行query 或者update 操作的时候我们创建一系列的对象,来处理参数、执行SQL、处理结果集,这里我们把它简化成一个对象:StatementHandler,这个就是MyBatis 主要的工作流程,如图:

MyBatis 架构分层与模块划分:

  在MyBatis 的主要工作流程里面,不同的功能是由很多不同的类协作完成的,它们分布在MyBatis jar 包的不同的package 里面。我们来看一下MyBatis 的jar 包(基于3.5.1)

跟Spring 一样,MyBatis 按照功能职责的不同,所有的package 可以分成不同的工作层次。我们可以把MyBatis 的工作流程类比成餐厅的服务流程。

  第一个是跟客户打交道的服务员,它是用来接收程序的工作指令的,我们把它叫做接口层。

  第二个是后台的厨师,他们根据客户的点菜单,把原材料加工成成品,然后传到窗口。这一层是真正去操作数据的,我们把它叫做核心层。

  最后就是餐厅也需要有人做后勤(比如清洁、采购、财务),来支持厨师的工作和整个餐厅的运营。我们把它叫做基础层。

来看一下这张图,我们根据刚才的分层,和大体的执行流程,做了这么一个总结。当然,从不同的角度来描述,架构图的划分有所区别,这张图画起来也有很多形式。我们先从总体上建立一个印象。

接口层:

  首先接口层是我们打交道最多的。核心对象是SqlSession,它是上层应用和MyBatis打交道的桥梁,SqlSession 上定义了非常多的对数据库的操作方法。接口层在接收到调用请求的时候,会调用核心处理层的相应模块来完成具体的数据库操作。

核心处理层:

  接下来是核心处理层。既然叫核心处理层,也就是跟数据库操作相关的动作都是在这一层完成的。核心处理层主要做了这几件事:

  1. 把接口中传入的参数解析并且映射成JDBC 类型;
  2. 解析xml 文件中的SQL 语句,包括插入参数,和动态SQL 的生成;
  3. 执行SQL 语句;
  4. 处理结果集,并映射成Java 对象。

  插件也属于核心层,这是由它的工作方式和拦截的对象决定的。

基础支持层:

  最后一个就是基础支持层。基础支持层主要是一些抽取出来的通用的功能(实现复用),用来支持核心处理层的功能。比如数据源、缓存(请点击跳转至缓存详解)、日志、xml 解析、反射、IO、事务等等这些功能。

  这个就是MyBatis 的主要工作流程和架构分层。

从以上的编程式的例子来看,mybatis的工作流程大致可以分为一下四步:

  1. 通过建造者模式创建一个工厂类,定位,加载,解析配置文件的就是在这一步完成的,包括mybatis-config.xml 和Mapper 适配器文件。
  2. 通过SqlSessionFactory 创建一个SqlSession。
  3. 获得Mapper 对象。
  4. 调用接口方法(insert,delete,update,select)。

第一步配置解析过程:

  定位资源位置,加载资源,将xml加载成流这里就不分析了。

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);

  首先我们要清楚的是配置解析的过程全部只解析了两种文件。一个是mybatis-config.xml 全局配置文件。另外就是可能有很多个的Mapper.xml 文件,也包括在Mapper 接口类上面定义的注解。我们从mybatis-config.xml 开始。在之前已经分析了核心配置了,大概明白了MyBatis 有哪些配置项,和这些配置项的大致含义。这里我们再具体看一下这里面的标签都是怎么解析的,解析的时候做了什么。

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

  首先我们new 了一个SqlSessionFactoryBuilder,非常明显的建造者模式,它里面定义了很多个build 方法的重载,最终返回的是一个SqlSessionFactory 对象(单例模式)。我们点进去build 方法。这里面创建了一个XMLConfigBuilder 对象(Configuration 对象也是这个时候创建的)。

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        SqlSessionFactory var5;
        try {
// 创建全局文件解析器 XMLConfigBuilder parser
= new XMLConfigBuilder(inputStream, environment, properties);
// 调用解析,解析完构建默认的SessionFactory var5
= this.build(parser.parse()); } catch (Exception var14) { throw ExceptionFactory.wrapException("Error building SqlSession.", var14); } finally { ErrorContext.instance().reset(); try { inputStream.close(); } catch (IOException var13) { } } return var5; }

  XMLConfigBuilder 是抽象类BaseBuilder 的一个子类,专门用来解析全局配置文件,针对不同的构建目标还有其他的一些子类,比如:XMLMapperBuilder:解析Mapper 映射器,XMLStatementBuilder:解析增删改查标签。

  根据我们解析的文件流,这里后面两个参数都是空的,创建了一个parser。这里有两步,第一步是调用parser 的parse()方法,它会返回一个Configuration类。也就是配置文件里面所有的信息都会放在Configuration 里面。Configuration 类里面有很多的属性,有很多是跟config 里面的标签直接对应的。

public Configuration parse() {
   // 判断是否已经解析过
if (this.parsed) { throw new BuilderException("Each XMLConfigBuilder can only be used once."); } else { this.parsed = true;
      // 解析的开始
this.parseConfiguration(this.parser.evalNode("/configuration")); return this.configuration; } }

  首先会检查是不是已经解析过,也就是说在应用的生命周期里面,config 配置文件只需要解析一次,生成的Configuration 对象也会存在应用的整个生命周期中。接下来就是parseConfiguration 方法:

  这下面有十几个方法,对应着config 文件里面的所有一级标签。MyBatis 全局配置文件的顺序不可以颠倒。

private void parseConfiguration(XNode root) {
        try {
            this.propertiesElement(root.evalNode("properties"));
            Properties settings = this.settingsAsProperties(root.evalNode("settings"));
            this.loadCustomVfs(settings);
            this.loadCustomLogImpl(settings);
            this.typeAliasesElement(root.evalNode("typeAliases"));
            this.pluginElement(root.evalNode("plugins"));
            this.objectFactoryElement(root.evalNode("objectFactory"));
            this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            this.reflectorFactoryElement(root.evalNode("reflectorFactory"));
//解析settings标签
this.settingsElement(settings); this.environmentsElement(root.evalNode("environments")); this.databaseIdProviderElement(root.evalNode("databaseIdProvider")); this.typeHandlerElement(root.evalNode("typeHandlers")); this.mapperElement(root.evalNode("mappers")); } catch (Exception var3) { throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3); } }

  在settings标签的解析中,我们就可以看到对应官网上介绍的各种配置,及其默认值,所有的值,都会赋值到Configuration 的属性里面去。简单的来看一下:

private void settingsElement(Properties props) {
        this.configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
        this.configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
        this.configuration.setCacheEnabled(this.booleanValueOf(props.getProperty("cacheEnabled"), true));//二级缓存
        this.configuration.setProxyFactory((ProxyFactory)this.createInstance(props.getProperty("proxyFactory")));
        this.configuration.setLazyLoadingEnabled(this.booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
        this.configuration.setAggressiveLazyLoading(this.booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
        this.configuration.setMultipleResultSetsEnabled(this.booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
        this.configuration.setUseColumnLabel(this.booleanValueOf(props.getProperty("useColumnLabel"), true));
        this.configuration.setUseGeneratedKeys(this.booleanValueOf(props.getProperty("useGeneratedKeys"), false));
        this.configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));//默认执行器类型
        this.configuration.setDefaultStatementTimeout(this.integerValueOf(props.getProperty("defaultStatementTimeout"), (Integer)null));
        this.configuration.setDefaultFetchSize(this.integerValueOf(props.getProperty("defaultFetchSize"), (Integer)null));
        this.configuration.setMapUnderscoreToCamelCase(this.booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
        this.configuration.setSafeRowBoundsEnabled(this.booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
        this.configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));//本地缓存级别
        this.configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
        this.configuration.setLazyLoadTriggerMethods(this.stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
        this.configuration.setSafeResultHandlerEnabled(this.booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
        this.configuration.setDefaultScriptingLanguage(this.resolveClass(props.getProperty("defaultScriptingLanguage")));
        this.configuration.setDefaultEnumTypeHandler(this.resolveClass(props.getProperty("defaultEnumTypeHandler")));
        this.configuration.setCallSettersOnNulls(this.booleanValueOf(props.getProperty("callSettersOnNulls"), false));
        this.configuration.setUseActualParamName(this.booleanValueOf(props.getProperty("useActualParamName"), true));
        this.configuration.setReturnInstanceForEmptyRow(this.booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
        this.configuration.setLogPrefix(props.getProperty("logPrefix"));
        this.configuration.setConfigurationFactory(this.resolveClass(props.getProperty("configurationFactory")));
}

  最后就是<mappers>标签的解析,对应匹配如下四种方式:

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>
<!-- 使用完全限定资源定位符(URL) -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>
<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>
<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

  首先会判断是不是接口,只有接口才解析;然后判断是不是已经注册了,单个Mapper重复注册会抛出异常。如果是以资源位置及URL的配置方式,还需要创建Mapper解析器解析。

private void mapperElement(XNode parent) throws Exception {
        if (parent != null) {
            Iterator var2 = parent.getChildren().iterator();
            while(true) {
                while(var2.hasNext()) {
                    XNode child = (XNode)var2.next();
                    String resource;
//配置包的方式
if ("package".equals(child.getName())) { resource = child.getStringAttribute("name");
               //解析完加入全局配置类,填充属性
this.configuration.addMappers(resource); } else { resource = child.getStringAttribute("resource"); String url = child.getStringAttribute("url"); String mapperClass = child.getStringAttribute("class"); XMLMapperBuilder mapperParser; InputStream inputStream;
//配置以资源的方式
if (resource != null && url == null && mapperClass == null) { ErrorContext.instance().resource(resource); inputStream = Resources.getResourceAsStream(resource); mapperParser = new XMLMapperBuilder(inputStream, this.configuration, resource, this.configuration.getSqlFragments()); mapperParser.parse();
//配置以URL的方式 }
else if (resource == null && url != null && mapperClass == null) { ErrorContext.instance().resource(url); inputStream = Resources.getUrlAsStream(url); mapperParser = new XMLMapperBuilder(inputStream, this.configuration, url, this.configuration.getSqlFragments()); mapperParser.parse();
// 配置以class单个接口 方式 }
else {//都没配置报异常 if (resource != null || url != null || mapperClass == null) { throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one."); } Class<?> mapperInterface = Resources.classForName(mapperClass); this.configuration.addMapper(mapperInterface); } } } return; } } }

  XMLMapperBuilder.parse()方法,是对Mapper 映射器的解析。里面有两个方法:configurationElement()—— 解析所有的子标签, 其中 buildStatementFromContext()最终获得MappedStatement 对象。bindMapperForNamespace()——把namespace(接口类型)和工厂类绑定起来。

  无论是按package 扫描,还是按接口扫描,最后都会调用到MapperRegistry 的addMapper()方法。最后,MapperRegistry 也会放到Configuration 里面去。MapperRegistry 里面维护的其实是一个Map 容器,存储接口和代理工厂的映射关系。

public <T> void addMapper(Class<T> type) {
        if (type.isInterface()) {//判断是否接口
            if (this.hasMapper(type)) { //是否已经注册
                throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
            }
            boolean loadCompleted = false;
            try {//利用Map来维护mapper
                this.knownMappers.put(type, new MapperProxyFactory(type));
                MapperAnnotationBuilder parser = new MapperAnnotationBuilder(this.config, type);
                parser.parse();//解析
                loadCompleted = true;
            } finally {
                if (!loadCompleted) {//注册过程出现异常,移除
                    this.knownMappers.remove(type);
                }
            }
        }
}

  除了映射器文件,在这里也会去解析Mapper 接口方法上的注解。在addMapper()方法里面创建了一个MapperAnnotationBuilder,我们点进去看一下parse()方法。parseCache() 和parseCacheRef() 方法其实是对@CacheNamespace 和@CacheNamespaceRef 这两个注解的处理。parseStatement()方法里面的各种getAnnotation(),都是对注解的解析,比如@Options,@SelectKey,@ResultMap 等等。最后同样会解析成MappedStatement 对象,也就是说在XML 中配置,和使用注解配置,最后起到一样的效果。

public void parse() {
        String resource = this.type.toString();
        if (!this.configuration.isResourceLoaded(resource)) {
            this.loadXmlResource();//加载XML资源
            this.configuration.addLoadedResource(resource);
            this.assistant.setCurrentNamespace(this.type.getName());
            this.parseCache();//解析@CacheNamespace注解
            this.parseCacheRef();//解析@CacheNamespaceRef注解
            Method[] methods = this.type.getMethods();
            Method[] var3 = methods;
            int var4 = methods.length;

            for(int var5 = 0; var5 < var4; ++var5) {
                Method method = var3[var5];
                try {
                    if (!method.isBridge()) {
                        this.parseStatement(method);//处理各种注解
                    }
                } catch (IncompleteElementException var8) {
                    this.configuration.addIncompleteMethod(new MethodResolver(this, method));
                }
            }
        }
        this.parsePendingMethods();
}

  最后会将这些解析的结果填充倒Configuration中。在这一步,我们主要完成了config 配置文件、Mapper 文件、Mapper 接口上的注解的解析。我们得到了一个最重要的对象Configuration,这里面存放了全部的配置信息,它在属性里面还有各种各样的容器。最后,返回了一个DefaultSqlSessionFactory,里面持有了Configuration 的实例。如下是第一阶段的时序图:

 第二步会话创建过程:

  这是第二步, 我们跟数据库的每一次连接, 都需要创建一个会话, 我们用openSession()方法来创建。

SqlSession session = sqlSessionFactory.openSession();
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;

DefaultSqlSession var8;
try {
//从先前所解析的配置中获取环境
Environment environment = this.configuration.getEnvironment();
//获取事务工厂类
TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);
//创建事务
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
//创建执行器类 默认SIMPLE
Executor executor = this.configuration.newExecutor(tx, execType);
//创建默认的SqlSession
var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);
} catch (Exception var12) {
this.closeTransaction(tx);
throw ExceptionFactory.wrapException("Error opening session. Cause: " + var12, var12);
} finally {
ErrorContext.instance().reset();
}
return var8;
}

  这个会话里面,需要包含一个Executor 用来执行SQL。Executor 又要指定事务类型和执行器的类型。所以我们会先从Configuration 里面拿到Enviroment,Enviroment 里面就有事务工厂。创建事务会有以下两种选择:

  如果配置的是JDBC,则会使用Connection 对象的commit()、rollback()、close()管理事务。如果配置成MANAGED,会把事务交给容器来管理,比如JBOSS,Weblogic。如果是Spring + MyBatis , 则没有必要配置, 因为我们会直接在applicationContext.xml 里面配置数据源和事务管理器,覆盖MyBatis 的配置。

  我们知道,Executor 的基本类型有三种:SIMPLE、BATCH、REUSE,默认是SIMPLE(settingsElement()读取默认值),他们都继承了抽象类BaseExecutor。

  • SimpleExecutor:每执行一次update 或select,就开启一个Statement 对象,用完立刻关闭Statement 对象。
  • ReuseExecutor:执行update 或select,以sql 作为key 查找Statement 对象,存在就使用,不存在就创建,用完后,不关闭Statement 对象,而是放置于Map 内,供下一次使用。简言之,就是重复使用Statement 对象。
  • BatchExecutor:执行update(没有select,JDBC 批处理不支持select),将所有sql 都添加到批处理中(addBatch()),等待统一执行(executeBatch()),它缓存了多个Statement 对象,每个Statement 对象都是addBatch()完毕后,等待逐一执行executeBatch()批处理。与JDBC 批处理相同。
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
//判断使用的执行器类型,之所以判断两次是防止手贱的人把执行器配置为空 executorType
= executorType == null ? this.defaultExecutorType : executorType; executorType = executorType == null ? ExecutorType.SIMPLE : executorType; Object 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 (this.cacheEnabled) {//是否启用二级缓存,启用了进行包装 executor = new CachingExecutor((Executor)executor); }
//插件包装,转换成拦截器链interceptorChain,对于插件我下一篇博客会详细介绍 Executor executor
= (Executor)this.interceptorChain.pluginAll(executor); return executor; }

  如果配置了cacheEnabled=ture,会用装饰器模式对executor 进行包装:newCachingExecutor(executor)。最终返回DefaultSqlSession,属性包括Configuration、Executor 对象。

  总结:创建会话的过程,我们获得了一个DefaultSqlSession,里面包含了一个Executor,它是SQL 的执行者。

 

第三步获得Mapper 对象:

  现在我们已经有一个DefaultSqlSession 了,必须找到Mapper.xml 里面定义的Statement ID,才能执行对应的SQL 语句。找到Statement ID 有两种方式:一种是直接调用session 的方法,在参数里面传入Statement ID,这种方式属于硬编码,我们没办法知道有多少处调用,修改起来也很麻烦。另一个问题是如果参数传入错误,在编译阶段也是不会报错的,不利于预先发现问题。

Blog blog = (Blog) session.selectOne("com.wuzz.mapper.BlogMapper.selectBlogById", 1);

  所以在MyBatis 后期的版本提供了第二种方式,就是定义一个接口,然后再调用Mapper 接口的方法。由于我们的接口名称跟Mapper.xml 的namespace 是对应的,接口的方法跟statement ID 也都是对应的,所以根据方法就能找到对应的要执行的SQL。

BlogMapper mapper = session.getMapper(BlogMapper.class);

  在这里我们主要研究一下Mapper 对象是怎么获得的,它的本质是什么。DefaultSqlSession 的getMapper()方法,调用了Configuration 的getMapper()方法。继而调到 MapperRegistry.getMapper:

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return this.mapperRegistry.getMapper(type, sqlSession);
}
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);
    if (mapperProxyFactory == null) {
        throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    } else {
        try {
            return mapperProxyFactory.newInstance(sqlSession);
        } catch (Exception var5) {
            throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
        }
    }
}

  我们知道,在解析mapper 标签和Mapper.xml 的时候已经把接口类型和类型对应的MapperProxyFactory 放到了一个Map 中。获取Mapper 代理对象,实际上是从Map 中获取对应的工厂类后,最终通过代理模式返回代理对象。

  那么JDK 动态代理和MyBatis 用到的JDK 动态代理有什么区别呢?JDK 动态代理代理,在实现了InvocationHandler 的代理类里面,需要传入一个被代理对象的实现类。而在mybatis里面,我们并没有实现了InvocationHandler 的代理类。不需要实现类的原因:我们只需要根据接口类型+方法的名称,就可以找到Statement ID 了,而唯一要做的一件事情也是这件,所以不需要实现类。在MapperProxy里面直接执行逻辑(也就是执行SQL)就可以。

  获得Mapper 对象的过程,实质上是获取了一个MapperProxy 的代理对象。MapperProxy 中有sqlSession、mapperInterface、methodCache。

第四步执行sql:

  由于所有的Mapper 都是MapperProxy 代理对象,所以任意的方法都是执行MapperProxy 的invoke()方法。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {//首先判断是否需要去执行SQL,还是直接执行方法。
            if (Object.class.equals(method.getDeclaringClass())) {
                return method.invoke(this, args);
            }
            //Object 本身的方法和Java 8 中接口的默认方法不需要去执行SQL。
            if (this.isDefaultMethod(method)) {
                return this.invokeDefaultMethod(proxy, method, args);
            }
        } catch (Throwable var5) {
            throw ExceptionUtil.unwrapThrowable(var5);
        }
      //获取缓存  这里加入缓存是为了提升MapperMethod 的获取速度
        MapperMethod mapperMethod = this.cachedMapperMethod(method);
        return mapperMethod.execute(this.sqlSession, args);
    }

   接下来又调用了mapperMethod 的execute 方法,我们debug来看一下:

  MapperMethod 里面主要有两个属性, 一个是SqlCommand (SQL命令), 一个是MethodSignature(方法签名),这两个都是MapperMethod 的内部类。另外定义了多个execute()方法。

public Object execute(SqlSession sqlSession, Object[] args) {
        Object result;
        Object param;//根据不同的type 和返回类型 调用sqlSession 的insert()、update()、delete()、selectOne ()方法
        switch(this.command.getType()) {
        case INSERT:
       // 调用convertArgsToSqlCommandParam()将参数转换为SQL 的参数。 param
= this.method.convertArgsToSqlCommandParam(args); result = this.rowCountResult(sqlSession.insert(this.command.getName(), param)); break; case UPDATE: param = this.method.convertArgsToSqlCommandParam(args); result = this.rowCountResult(sqlSession.update(this.command.getName(), param)); break; case DELETE: param = this.method.convertArgsToSqlCommandParam(args); result = this.rowCountResult(sqlSession.delete(this.command.getName(), param)); break; case SELECT://查询的方法又要根据返回类型进行区分执行 if (this.method.returnsVoid() && this.method.hasResultHandler()) { this.executeWithResultHandler(sqlSession, args); result = null; } else if (this.method.returnsMany()) { result = this.executeForMany(sqlSession, args); } else if (this.method.returnsMap()) { result = this.executeForMap(sqlSession, args); } else if (this.method.returnsCursor()) { result = this.executeForCursor(sqlSession, args); } else { param = this.method.convertArgsToSqlCommandParam(args); result = sqlSession.selectOne(this.command.getName(), param); if (this.method.returnsOptional() && (result == null || !this.method.getReturnType().equals(result.getClass()))) { result = Optional.ofNullable(result); } } break; case FLUSH://刷新statement result = sqlSession.flushStatements(); break; default: throw new BindingException("Unknown execution method for: " + this.command.getName()); } if (result == null && this.method.getReturnType().isPrimitive() && !this.method.returnsVoid()) { throw new BindingException("Mapper method '" + this.command.getName() + " attempted to return null from a method with a primitive return type (" + this.method.getReturnType() + ")."); } else { return result; } }

  我们以查询  (mapper1.selectBlogById(1002))  为例 会走如下代码,会走到selectOne()方法。

public <T> T selectOne(String statement, Object parameter) {
        List<T> list = this.selectList(statement, parameter);
        if (list.size() == 1) {
            return list.get(0);
        } else if (list.size() > 1) {
            throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
        } else {
            return null;
        }
    }

  这里抛得异常是不是很熟悉,经常有小伙伴在开发过程中会发现sql执行报这个异常,是因为定义的sql是查询的一个结果,可是返回了多个,这里会执行selectList(statement, parameter):

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
        List var5;
        try {//获取初始化阶段所封装的对象先根据command name(Statement ID)从Configuration中拿到MappedStatement
       MappedStatement ms = this.configuration.getMappedStatement(statement);
            var5 = this.executor.query(ms, this.wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
        } catch (Exception var9) {
            throw ExceptionFactory.wrapException("Error querying database.  Cause: " + var9, var9);
        } finally {
            ErrorContext.instance().reset();
        }
        return var5;
}

  这个ms 上面有我们在xml 中配置的所有属性,包括id、statementType、sqlSource、useCache、入参、出参等等。

  然后执行了Executor 的query()方法。前面我们说到了Executor 有三种基本类型,SIMPLE/REUSE/BATCH,还有一种包装类型,CachingExecutor。那么在这里到底会选择哪一种执行器呢?我们要回过头去看看DefaultSqlSession 在初始化的时候是怎么赋值的,这个就是我们的会话创建过程。如果启用了二级缓存,就会先调用CachingExecutor 的query()方法,里面有缓存相关的操作,然后才是再调用基本类型的执行器,比如默认的SimpleExecutor。在没有开启二级缓存的情况下,先会走到BaseExecutor 的query()方法(否则会先走到CachingExecutor)。

  BaseExecutor:

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameter);
        CacheKey key = this.createCacheKey(ms, parameter, rowBounds, boundSql);
        return this.query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }

  从Configuration 中获取MappedStatement, 然后从BoundSql 中获取SQL 信息,创建CacheKey。这个CacheKey 就是缓存的Key。然后再调用另一个query()方法。

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if (this.closed) {
            throw new ExecutorException("Executor was closed.");
        } else {//queryStack 用于记录查询栈,防止递归查询重复处理缓存。flushCache=true 的时候,会先清理本地缓存(一级缓存)
            if (this.queryStack == 0 && ms.isFlushCacheRequired()) {
//清除缓存
this.clearLocalCache(); } List list; try { ++this.queryStack; list = resultHandler == null ? (List)this.localCache.getObject(key) : null; if (list != null) {//从缓存中获取数据 this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql); } else {//如果没有缓存,会从数据库查询:queryFromDatabase() list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql); } } finally { --this.queryStack; } if (this.queryStack == 0) { Iterator var8 = this.deferredLoads.iterator(); while(var8.hasNext()) { BaseExecutor.DeferredLoad deferredLoad = (BaseExecutor.DeferredLoad)var8.next(); deferredLoad.load(); } this.deferredLoads.clear();
//如果LocalCacheScope == STATEMENT,会清理本地缓存。
if (this.configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { this.clearLocalCache(); } } return list; } }

  从数据库查询(queryFromDatabase):

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
     // 先在缓存用占位符占位。执行查询后,移除占位符,放入数据。
this.localCache.putObject(key, ExecutionPlaceholder.EXECUTION_PLACEHOLDER); List list; try {//执行Executor 的doQuery();默认是SimpleExecutor。 list = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql); } finally { this.localCache.removeObject(key); } this.localCache.putObject(key, list); if (ms.getStatementType() == StatementType.CALLABLE) { this.localOutputParameterCache.putObject(key, parameter); } return list; }

  SimpleExecutor.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        Statement stmt = null;

        List var9;
        try {
            Configuration configuration = ms.getConfiguration();
            StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            stmt = this.prepareStatement(handler, ms.getStatementLog());
            var9 = handler.query(stmt, resultHandler);
        } finally {
            this.closeStatement(stmt);
        }

        return var9;
    }

  在configuration.newStatementHandler()中,new 一个StatementHandler,先得到RoutingStatementHandler。RoutingStatementHandler 里面没有任何的实现, 是用来创建基本的StatementHandler 的。这里会根据MappedStatement 里面的statementType 决定StatementHandler 的类型。默认是PREPARED ( STATEMENT 、PREPARED 、CALLABLE)。

public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        switch(ms.getStatementType()) {
        case STATEMENT:
            this.delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
        case PREPARED:
            this.delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
        case CALLABLE:
            this.delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
        default:
            throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
        }
}

  StatementHandler 里面包含了处理参数的ParameterHandler 和处理结果集的ResultSetHandler。这两个对象都是在上面new 的时候创建的。

this.parameterHandler = this.configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
this.resultSetHandler = this.configuration.newResultSetHandler(executor, mappedStatement, rowBounds, this.parameterHandler, resultHandler, boundSql);

  这三个对象都是可以被插件拦截的四大对象之一,所以在创建之后都要用拦截器进行包装的方法。(对于详细的插件机制将在下篇博客中详细介绍)

StatementHandler statementHandler = (StatementHandler)this.interceptorChain.pluginAll(statementHandler);
parameterHandler = (ParameterHandler)this.interceptorChain.pluginAll(parameterHandler);
ResultSetHandler resultSetHandler = (ResultSetHandler)this.interceptorChain.pluginAll(resultSetHandler);

  四大对象还有一个是谁?在什么时候创建的?(Executor)在第二步创建会话的时候创建的。用new 出来的StatementHandler 创建Statement 对象——prepareStatement()方法对语句进行预编译,处理参数。执行的StatementHandler 的query()方法,RoutingStatementHandler 的query()方法。

delegate 委派,最终执行PreparedStatementHandler 的query()方法。

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        PreparedStatement ps = (PreparedStatement)statement;
        ps.execute();
        return this.resultSetHandler.handleResultSets(ps);
}

  执行PreparedStatement 的execute()方法,后面就是JDBC 包中的PreparedStatement 的执行了。

  最后通过 resultSetHandler.handleResultSets(ps) 处理结果集。

 

   最后总结一下整个源码的过程所涉及的核心类:

 

posted @ 2019-07-02 14:37  吴振照  阅读(6394)  评论(0编辑  收藏