mybatis目录

1.核心执行步骤
2.配置文件解析
configuration（配置）

• properties（属性）
• settings（设置）
• typeAliases（类型别名）
• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins（插件）
• environments（环境配置）
  • environment（环境变量）
    • transactionManager（事务管理器）
    • dataSource（数据源）
• databaseIdProvider（数据库厂商标识）
• mappers（映射器）.
  3.mappers解析
  SQL 映射文件只有很少的几个顶级元素（按照应被定义的顺序列出）：

cache – 对给定命名空间的缓存配置。
cache-ref – 对其他命名空间缓存配置的引用。
resultMap – 是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。
parameterMap – 已被废弃！老式风格的参数映射。更好的办法是使用内联参数，此元素可能在将来被移除。文档中不会介绍此元素。
sql – 可被其他语句引用的可重用语句块。
insert – 映射插入语句
update – 映射更新语句
delete – 映射删除语句
select – 映射查询语句
4.SqlSession操作执行过程(以查询操作为例）
1.最终会调用jdbc的操作
Connection由DataSource调用DriverManager得到，然后Transaction给Connection设置隔离级别。
DataSource和Transaction对象的创建根据配置文件中的标签解析而来。

2.找到对应的执行SQL语句，有两种情况
1.mapper接口操作

  UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  User user = mapper.selectUser(2);

1.获取MapperProxyFactory，该对象已经在mapper文件解析的时候，注册到MapperRegistry中的knownMappers里面了。
和
，会自动注册
和
，会去查找是否有对应的接口，然后自动注册
2.构建MapperProxy作为Mapper接口的代理类（JDK的动态代理）,
最后执行的方法是代理类的invoke方法,
->PlainMethodInvoker#invoke -> MapperMethod#execute
这里产生的疑问有：
DefaultMethodInvoker和PlainMethodInvoker区别，它们是干啥的？
就是对MapperMethod的包了一层，只有一个invoke方法；
根据m.isDefault()和privateLookupInMethod参数来决定用哪一个

  private static class PlainMethodInvoker implements MapperMethodInvoker {
    private final MapperMethod mapperMethod;

    public PlainMethodInvoker(MapperMethod mapperMethod) {
      super();
      this.mapperMethod = mapperMethod;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
      return mapperMethod.execute(sqlSession, args);
    }
  }

 if (m.isDefault()) {
          try {
            if (privateLookupInMethod == null) {
              return new DefaultMethodInvoker(getMethodHandleJava8(method));
            } else {
              return new DefaultMethodInvoker(getMethodHandleJava9(method));
            }
          } catch (IllegalAccessException | InstantiationException | InvocationTargetException
              | NoSuchMethodException e) {
            throw new RuntimeException(e);
          }
        } else {
          return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
        }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else {
        return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

// MapperMethod#execute,只讨论SELECT类型
 public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    switch (command.getType()) {
         case SELECT:
        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        } else {
          Object param = method.convertArgsToSqlCommandParam(args);
          // 在这里又转化成statement操作了
          result = sqlSession.selectOne(command.getName(), param);
          if (method.returnsOptional()
              && (result == null || !method.getReturnType().equals(result.getClass()))) {
            result = Optional.ofNullable(result);
          }
        }
        break;
       default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
      throw new BindingException("Mapper method '" + command.getName()
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
  }

MapperMethod是什么？
从构造函数来看：它持有mapper接口，执行方法，配置类的引用
然后，根据这三个参数构建了SqlCommand和MethodSignature
SqlCommand是什么？

 public static class SqlCommand {
 // MappedStatement的id，
// 例如com.gupaoedu.lsj.mybatis.mapper.UserMapper.selectUser
    private final String name;
// enum类型:UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH
    private final SqlCommandType type;
｝

MethodSignature是什么？它是对执行的方法作了分析，包括它的返回值类型，返回的是多条还是单条，是否有mapKey等。

public class MapperMethod {

  private final SqlCommand command;
  private final MethodSignature method;

  public MapperMethod(Class mapperInterface, Method method, Configuration config) {
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, mapperInterface, method);
  }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import com.gupaoedu.lsj.mybatis.mapper.UserMapper;
import com.gupaoedu.lsj.mybatis.pojo.User;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements UserMapper {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final User selectUser(Integer var1) throws  {
        try {
            return (User)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.gupaoedu.lsj.mybatis.mapper.UserMapper").getMethod("selectUser", new Class[]{Class.forName("java.lang.Integer")});
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

2.statement操作

String  statement = "com.gupaoedu.lsj.mybatis.mapper.UserMapper.selectUser";
User user = (User)sqlSession.selectOne(statement,1);

以上两种情况，最后都调用的是DefaultSqlSession中的selectList方法，
根据statement获取到MappedStatement，然后由Executor对象去执行方法

public  List selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

疑问：
MappedStatement是什么，存储在哪里的？
它对应于mapper.xml文件中的四个标签
insert – 映射插入语句
update – 映射更新语句
delete – 映射删除语句
select – 映射查询语句
存储在Configuration中的Map mappedStatements

public final class MappedStatement {

  private String resource;

/**
*  配置类，config.xml解析来的
*  很多类都持有它的引用，它是全局的配置
*/
  private Configuration configuration;

/**
*  xml中的namespace+(crud的id)
*  例如：com.gupaoedu.lsj.mybatis.mapper.UserMapper.selectUser
*/
  private String id;

/**
*  fetchSize属性
*/
  private Integer fetchSize;

/**
*  timeout
*/
  private Integer timeout;

/*
*  statementType属性
*  STATEMENT, PREPARED, CALLABLE
*/
  private StatementType statementType;

  private ResultSetType resultSetType;
  private SqlSource sqlSource;
  private Cache cache;
  private ParameterMap parameterMap;
  private List resultMaps;

/*
*  flushCache属性
*/
  private boolean flushCacheRequired;

/*
*  useCache属性
*/
  private boolean useCache;

/*
* resultOrdered属性
*/
  private boolean resultOrdered;

/**
* enum:  UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH
*/
  private SqlCommandType sqlCommandType;

/**
*  新增操作，返回主键
*  useGeneratedKeys、keyColumn、keyProperty
*/
  private KeyGenerator keyGenerator;

  private String[] keyProperties;
  private String[] keyColumns;
  private boolean hasNestedResultMaps;
/**
*  databaseId属性
*/
  private String databaseId;
  private Log statementLog;
  private LanguageDriver lang;
  private String[] resultSets;

  MappedStatement() {
    // constructor disabled
  }
}

Executor是什么？
Executor是SQL执行的对外接口，sqlSession中调用的就是Executor；
Executor中创建了StatementHandler（同时也创建了ResultSetHandler和ParameterHandler）
然后由Connection,Statement,StatementHandler准备Statement，ParameterHandler解析参数
然后由StatementHandler执行Statement的execute方法
然后ResultSetHandler处理结果

image.png

SimpleExecutor：默认执行器，Statement用完销毁
ReuseExecutor：Statement重用，用完不销毁
BatchExecutor：批量执行器，Statement用完销毁

public enum ExecutorType {
/**
*分别对应：SimpleExecutor，ReuseExecutor，BatchExecutor
*默认是SimpleExecutor
*/
  SIMPLE, REUSE, BATCH
}

/**
*创建SqlSession 的时候，Executor 由configuration创建，指定了defaultExecutorType 
*protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;
*/
public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }
  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

核心方法对比：

 /**
  * SimpleExecutor
  */
 public  List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.query(stmt, resultHandler);
    } finally {
// 关闭了Statement 
      closeStatement(stmt);
    }
  }
  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection, transaction.getTimeout());
    handler.parameterize(stmt);
    return stmt;
  }

 /**
  * BatchExecutor
  */
 public  List doQuery(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
      throws SQLException {
    Statement stmt = null;
    try {
      // 最终调用的是doFlushStatements方法
      flushStatements();
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameterObject, rowBounds, resultHandler, boundSql);
      Connection connection = getConnection(ms.getStatementLog());
      stmt = handler.prepare(connection, transaction.getTimeout());
      handler.parameterize(stmt);
      return handler.query(stmt, resultHandler);
    } finally {
// 关闭了Statement 
      closeStatement(stmt);
    }
  }
 public List doFlushStatements(boolean isRollback) throws SQLException {
    try {
      List results = new ArrayList<>();
      if (isRollback) {
        return Collections.emptyList();
      }
      for (int i = 0, n = statementList.size(); i < n; i++) {
        Statement stmt = statementList.get(i);
        applyTransactionTimeout(stmt);
        BatchResult batchResult = batchResultList.get(i);
        try {
          batchResult.setUpdateCounts(stmt.executeBatch());
          MappedStatement ms = batchResult.getMappedStatement();
          List