// 1. 獲取數(shù)據(jù)源（模擬配置，實(shí)際可通過mybatis-config.xml配置）
DataSource dataSource = TestDataSourceFactory.getDataSource();
// 2. 創(chuàng)建事務(wù)工廠（JDBC事務(wù)工廠，依賴JDBC原生事務(wù)管理）
TransactionFactory transactionFactory = new JdbcTransactionFactory();
// 3. 構(gòu)建環(huán)境對(duì)象（包含環(huán)境名稱、事務(wù)工廠、數(shù)據(jù)源）
Environment environment = new Environment("dev", transactionFactory, dataSource);
// 4. 初始化配置對(duì)象（MyBatis核心配置載體，存儲(chǔ)所有配置信息）
Configuration configuration = new Configuration(environment);
// 5. 注冊(cè)Mapper接口（告知MyBatis需要掃描的Mapper，綁定SQL映射）
configuration.addMapper(TestMapper.class);
// 6. 構(gòu)建SqlSessionFactory（會(huì)話工廠，線程安全，全局單例）
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
// 7. 打開SqlSession（會(huì)話對(duì)象，非線程安全，單次請(qǐng)求/事務(wù)獨(dú)占）
SqlSession session = sqlSessionFactory.openSession();
try { 
  // 8. 獲取Mapper代理對(duì)象（MyBatis動(dòng)態(tài)生成，非真實(shí)Mapper實(shí)現(xiàn)類）
  TestMapper mapper = session.getMapper(TestMapper.class);
  // 9. 調(diào)用Mapper方法執(zhí)行查詢（觸發(fā)底層SQL執(zhí)行流程）
  List<Entity> entitys = mapper.selectList(101);
} finally {
  // 10. 關(guān)閉SqlSession（釋放資源，避免連接泄漏）
  session.close();
}

public class Configuration {
   /**
    * 獲取Mapper代理對(duì)象
    * 核心邏輯：委托MapperRegistry創(chuàng)建代理，將SqlSession傳入代理，便于后續(xù)調(diào)用
    */
   public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
	    return mapperRegistry.getMapper(type, sqlSession);
	}

	/**
	 * 創(chuàng)建元對(duì)象，用于反射操作對(duì)象屬性
	 * 支撐ParameterHandler、ResultSetHandler的底層屬性訪問
	 */
	public MetaObject newMetaObject(Object object) {
	    return MetaObject.forObject(object, objectFactory, objectWrapperFactory);
	}

	/**
	 * 創(chuàng)建ParameterHandler（參數(shù)處理器）
	 * 先通過語言驅(qū)動(dòng)創(chuàng)建默認(rèn)實(shí)現(xiàn)，再通過攔截器鏈增強(qiáng)
	 */
	public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
	    ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
        // 攔截器增強(qiáng)：允許插件修改參數(shù)處理邏輯
	    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
	    return parameterHandler;
	}

	/**
	 * 創(chuàng)建ResultSetHandler（結(jié)果處理器）
	 * 實(shí)例化默認(rèn)實(shí)現(xiàn)DefaultResultSetHandler，再通過攔截器鏈增強(qiáng)
	 */
	public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
	      ResultHandler resultHandler, BoundSql boundSql) {
	    ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
        // 攔截器增強(qiáng)：允許插件修改結(jié)果處理邏輯（如數(shù)據(jù)脫敏）
	    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
	    return resultSetHandler;
	}

	/**
	 * 創(chuàng)建StatementHandler（Statement封裝者）
	 * 實(shí)例化路由處理器RoutingStatementHandler，再通過攔截器鏈增強(qiáng)
	 */
	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);
        // 攔截器增強(qiáng)：允許插件修改SQL執(zhí)行邏輯（如分頁插件）
	    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
	    return statementHandler;
	}

	/**
	 * 創(chuàng)建Executor（執(zhí)行器）
	 * 根據(jù)執(zhí)行器類型實(shí)例化對(duì)應(yīng)實(shí)現(xiàn)，開啟緩存則包裝為CachingExecutor，最后通過攔截器增強(qiáng)
	 */
	public Executor newExecutor(Transaction transaction) {
	    return newExecutor(transaction, defaultExecutorType);
	}

	public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
	    executorType = executorType == null ? defaultExecutorType : executorType;
	    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
	    Executor 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);
	    }
	    // 若開啟二級(jí)緩存，包裝為CachingExecutor
	    if (cacheEnabled) {
	      executor = new CachingExecutor(executor);
	    }
        // 攔截器增強(qiáng)：允許插件修改執(zhí)行器邏輯（如事務(wù)增強(qiáng)、緩存擴(kuò)展）
	    executor = (Executor) interceptorChain.pluginAll(executor);
	    return executor;
	}
}

public class MapperMethod {
  // 存儲(chǔ)SQL命令信息（類型、語句ID等）
  private final SqlCommand command;
  // 存儲(chǔ)方法簽名信息（返回值類型、參數(shù)類型等）
  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);
  }

  // 核心方法：處理增刪改查方法執(zhí)行，分發(fā)至SqlSession
  public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    // 根據(jù)SQL命令類型分發(fā)執(zhí)行
    switch (command.getType()) {
      case INSERT: {
        // 處理參數(shù)映射，將args轉(zhuǎn)換為SQL參數(shù)
        Object param = method.convertArgsToSqlCommandParam(args);
        // 調(diào)用SqlSession.insert，返回影響行數(shù)
        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:
        // 無返回值且有ResultHandler參數(shù)（回調(diào)處理結(jié)果）
        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        }
        // 返回列表/數(shù)組
        else if (method.returnsMany()) {
          result = executeForMany(sqlSession, args);
        }
        // 返回Map
        else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        }
        // 返回Cursor（游標(biāo)，適用于大量數(shù)據(jù)流式查詢）
        else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        }
        // 返回單個(gè)對(duì)象
        else {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
        }
        break;
      case FLUSH:
        result = sqlSession.flushStatements();
        break;
      default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    // 處理返回值為null且方法返回類型為基本類型的情況（拋出異常）
    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;
  }

  // 執(zhí)行查詢列表邏輯
  private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    List<E> result;
    Object param = method.convertArgsToSqlCommandParam(args);
    // 若方法有RowBounds參數(shù)（分頁參數(shù)），調(diào)用帶分頁的selectList
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      result = sqlSession.selectList(command.getName(), param, rowBounds);
    } else {
      // 無分頁，調(diào)用普通selectList
      result = sqlSession.selectList(command.getName(), param);
    }
    // 若返回值需要轉(zhuǎn)換為數(shù)組，進(jìn)行類型轉(zhuǎn)換
    if (!method.getReturnType().isAssignableFrom(result.getClass())) {
      return method.convertResultToList(result);
    }
    return result;
  }

  // 其他輔助方法（executeWithResultHandler、executeForMap等）省略...

  // 處理影響行數(shù)返回結(jié)果（適配boolean/int等返回類型）
  private Object rowCountResult(int rowCount) {
    final Object result;
    if (method.returnsVoid()) {
      result = null;
    } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
      result = rowCount;
    } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
      result = (long) rowCount;
    } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
      result = rowCount > 0;
    } else {
      throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
    }
    return result;
  }
}