@Slf4j
public class Main {
  public static void main(String[] args) {
    String resource = "org/apache/ibatis/yyqtest/resource/mybatis-config.xml";
    InputStream inputStream = null;
    try {
      // 將XML配置文件構(gòu)建為Configuration配置類
      inputStream = Resources.getResourceAsStream(resource);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    // 通過加載配置文件流構(gòu)建一個SqlSessionFactory DefaultSqlSessionFactory
    SqlSessionFactory sqlSessionFactory = null;
    sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = null;
    try {
      sqlSession = sqlSessionFactory.openSession();
      RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
      //Role role = roleMapper.testManyParam(1L, "張三");
      //Role role = roleMapper.testAnnotation(1L);
      Role role = roleMapper.testDynamicParam(1L, "");

      log.info(role.getId() + ":" + role.getRoleName() + ":" + role.getNote());
      sqlSession.commit();

    } catch (Exception e) {
      // TODO Auto-generated catch block
      sqlSession.rollback();
      e.printStackTrace();
    } finally {
      sqlSession.close();
    }
  }
}

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
  try {
    // 2. 創(chuàng)建XMLConfigBuilder對象用來解析XML配置文件，生成Configuration對象
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    // 3. 將XML配置文件內(nèi)的信息解析成Java對象Configuration對象
    Configuration config = parser.parse();
    // 4. 根據(jù)Configuration對象創(chuàng)建出SqlSessionFactory對象
    return build(config);
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  } finally {
    ErrorContext.instance().reset();
    try {
      if (inputStream != null) {
        inputStream.close();
      }
    } catch (IOException e) {
      // Intentionally ignore. Prefer previous error.
    }
  }
}

public SqlSessionFactory build(Configuration config) {
  return new DefaultSqlSessionFactory(config);
}

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
  Transaction tx = null;
  try {
    final Environment environment = configuration.getEnvironment();
    final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
    // 通過事務(wù)工廠從一個數(shù)據(jù)源來產(chǎn)生一個事務(wù)
    tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
    // 獲取執(zhí)行器，這邊獲得的執(zhí)行器已經(jīng)代理攔截器的功能
    final Executor executor = configuration.newExecutor(tx, execType);
    // 獲取執(zhí)行器后，再將configuration和executor封裝成DefaultSqlSession
    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();
  }
}

/**
* 什么都不做，直接去configuration里面去找
* @param type Mapper interface class
* @param <T>
* @return
*/
@Override
public <T> T getMapper(Class<T> type) {
	return configuration.getMapper(type, this);
}

// mapperRegistry實質(zhì)上是一個Map，里面注冊了啟動過程中解析的各種Mapper.xml
protected final MapperRegistry mapperRegistry = new MapperRegistry(this);

/**
 * configuration也什么都不做，去mapperRegistry里面找
 * @param type
 * @param sqlSession
 * @param <T>
 * @return
 */
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
	return mapperRegistry.getMapper(type, sqlSession);
}

Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();

/**
 * MapperRegistry標(biāo)識很無奈，沒人做，只有我來做了
 * @param type
 * @param sqlSession
 * @param <T>
 * @return
 */
@SuppressWarnings("unchecked")
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  // MapperRegistry表示也要偷懶，偷偷的把粗活交給MapperProxyFactory去做。
  final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
  // 如果配置文件中沒有配置相關(guān)Mapper,直接拋異常
  if (mapperProxyFactory == null) {
    throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
  }
  try {
    // 我們看到mapper都是接口，因為接口是不能實例化的，這里通過動態(tài)代理實現(xiàn),具體可以看下MapperProxy這個類
    return mapperProxyFactory.newInstance(sqlSession);
  } catch (Exception e) {
    throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  }
}

public class MapperProxyFactory<T> {
  /**
   * 生成Mapper接口的動態(tài)代理類MapperProxy，MapperProxy實現(xiàn)了InvocationHandler接口
   *
   * @param mapperProxy
   * @return
   */
  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
      // 動態(tài)代理，我們寫的一些接口
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[]{mapperInterface}, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }
}

  RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
  Role role = roleMapper.testManyParam(1L, "張三");
  Role role = roleMapper.testAnnotation(1L);
  Role role = roleMapper.testDynamicParam(1L, "");

/**
 * Executor分成兩大類，一類是CacheExecutor，另一類是普通Executor。
 *
 * @param transaction
 * @param executorType
 * @return
 */
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
  executorType = executorType == null ? defaultExecutorType : executorType;
  // 這句再做一下保護(hù),囧,防止粗心大意的人將defaultExecutorType設(shè)成null?
  executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
  Executor executor;
  // 普通Executor又分為三種基本的Executor執(zhí)行器，SimpleExecutor、ReuseExecutor、BatchExecutor。
  if (ExecutorType.BATCH == executorType) {
    executor = new BatchExecutor(this, transaction);
  } else if (ExecutorType.REUSE == executorType) {
    // 執(zhí)行update或select，以sql作為key查找Statement對象，存在就使用，不存在就創(chuàng)建，用完后，不關(guān)閉Statement對象，而是放置于Map<String,Statement>內(nèi)，供下一次使用。簡言之，就是重復(fù)使用Statement對象
    executor = new ReuseExecutor(this, transaction);
  } else {
    // 每執(zhí)行一次update或select，就開啟一個Statement對象，用完立刻關(guān)閉Statement對象。
    executor = new SimpleExecutor(this, transaction);
  }
  if (cacheEnabled) {
    // CacheExecutor其實是封裝了普通的Executor，和普通的區(qū)別是在查詢前先會查詢緩存中
    // 是否存在結(jié)果，如果存在就使用緩存中的結(jié)果，如果不存在還是使用普通的Executor進(jìn)行
    // 查詢，再將查詢出來的結(jié)果存入緩存。
    executor = new CachingExecutor(executor);
  }
  // 調(diào)用每個攔截器的方法，這里的話應(yīng)該是為了方便擴(kuò)展,方便開發(fā)者自定義攔截器做一些處理
  executor = (Executor) interceptorChain.pluginAll(executor);
  return executor;
}

/**
 * 通過動態(tài)代理后，所有的Mapper方法調(diào)用都會走這個invoke方法
 *
 * @param proxy
 * @param method
 * @param args
 * @return
 * @throws Throwable
 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    // 并不是任何一個方法都需要執(zhí)行調(diào)用代理對象進(jìn)行執(zhí)行，如果這個方法是Object中通用的方法（toString、hashCode等）無需執(zhí)行
    if (Object.class.equals(method.getDeclaringClass())) {
      return method.invoke(this, args);
    } else {
      // cachedInvoker封裝了一個MapperMethod對象
      // 拆分出來更好理解
      MapperMethodInvoker mapperMethodInvoker = cachedInvoker(method);
      return mapperMethodInvoker.invoke(proxy, method, args, sqlSession);
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
}

/**
 * 這里其實就是先判斷CRUD的類型，根據(jù)類型去選擇到底執(zhí)行了sqlSession中的哪個方法
 * @param sqlSession
 * @param args
 * @return
 */
public Object execute(SqlSession sqlSession, Object[] args) {
  Object result;
  switch (command.getType()) {
    case INSERT: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.insert(command.getName(), param));
      break;
    }
    case UPDATE: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.update(command.getName(), param));
      break;
    }
    case DELETE: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.delete(command.getName(), param));
      break;
    }
    case SELECT:
      if (method.returnsVoid() && method.hasResultHandler()) {
        executeWithResultHandler(sqlSession, args);
        result = null;
      } else if (method.returnsMany()) {
        // 多條記錄
        result = executeForMany(sqlSession, args);
      } else if (method.returnsMap()) {
        // 如果結(jié)果是map
        result = executeForMap(sqlSession, args);
      } else if (method.returnsCursor()) {
        result = executeForCursor(sqlSession, args);
      } else {
        // 從字面意義上看，講轉(zhuǎn)換的參數(shù)放到sql里面
        // Map<String, Object> param
        Object param = method.convertArgsToSqlCommandParam(args);
        result = sqlSession.selectOne(command.getName(), param);
        if (method.returnsOptional()
            && (result == null || !method.getReturnType().equals(result.getClass()))) {
          result = Optional.ofNullable(result);
        }
      }
      break;
    case FLUSH:
      result = sqlSession.flushStatements();
      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;
}

@Override
public <T> T selectOne(String statement, Object parameter) {
  // Popular vote was to return null on 0 results and throw exception on too many.
  // 轉(zhuǎn)而去調(diào)用selectList,很簡單的，如果得到0條則返回null，得到1條則返回1條，得到多條報TooManyResultsException錯
  // 這里沒有查詢到結(jié)果的時候會返回null。因此一般建議mapper中編寫resultType使用包裝類型
  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;
  }
}

/**
 *
 * @param statement 全限定名稱+方法名 例如org.apache.ibatis.yyqtest.mapper.RoleMapper.testAnnotation
 * @param parameter
 * @param rowBounds
 * @param handler
 * @param <E>
 * @return
 */
private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
  try {
    // 根據(jù)傳入的全限定命+方法名從映射的map中取出MappedStatement對象
    MappedStatement ms = configuration.getMappedStatement(statement);
    // 之類能看到CRUD實際上是交給Executor處理
    return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}

protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
    .conflictMessageProducer((savedValue, targetValue) ->
      ". please check " + savedValue.getResource() + " and " + targetValue.getResource());


public MappedStatement getMappedStatement(String id, boolean validateIncompleteStatements) {
  if (validateIncompleteStatements) {
    buildAllStatements();
  }
  return mappedStatements.get(id);
}

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
  statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
  return statementHandler;
}

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

@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  PreparedStatement ps = (PreparedStatement) statement;
  ps.execute();
  // 將處理好的結(jié)果交給了ResultSetHandler
  return resultSetHandler.handleResultSets(ps);
}