public class DefaultSqlSession implements SqlSession {
    private final Configuration configuration;
    private final Executor executor;
    private final boolean autoCommit;
    // ... 其他字段

    public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
        this.configuration = configuration;
        this.executor = executor;
        this.autoCommit = autoCommit;
        // ... 初始化
    }

    @Override
    public <T> T selectOne(String statement, Object parameter) {
        try {
            MappedStatement ms = configuration.getMappedStatement(statement);
            List<T> list = executor.query(ms, wrapCollection(parameter), RowBounds.DEFAULT, Executor.NO_RESULT_HANDLER);
            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;
            }
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
        }
    }
    // ... 其他方法如 update、insert 等类似
}

private final Map<String, Statement> statementMap = new HashMap<>();

@Override
protected int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {
    // ... 获取 BoundSql
    String sql = boundSql.getSql();
    Statement stmt = statementMap.get(sql);
    if (stmt == null) {
        stmt = handler.prepare(connection, transaction.getTimeout());
        statementMap.put(sql, stmt);
    }
    // ... 设置参数并执行
}

String sql = "SELECT * FROM user WHERE id = ?";
StaticSqlSource sqlSource = new StaticSqlSource(configuration, sql, parameterMappings);
BoundSql boundSql = sqlSource.getBoundSql(parameterObject);  // 直接返回固定 SQL 和参数

List<SqlNode> contents = new ArrayList<>();
contents.add(new StaticTextSqlNode("SELECT * FROM user WHERE 1=1 "));
if (condition) {
    contents.add(new IfSqlNode(new StaticTextSqlNode("AND id = #{id}"), "id != null"));
}
MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
DynamicSqlSource dynamicSqlSource = new DynamicSqlSource(configuration, mixedSqlNode);

ParameterMapping mapping = ParameterMapping.builder(configuration, "id", Integer.class)
    .javaType(Integer.class)
    .jdbcType(JdbcType.INTEGER)
    .build();

TypeHandler<Object> typeHandler = parameterMapping.getTypeHandler();
typeHandler.setParameter(ps, i + 1, value, parameterMapping.getJdbcType());

while (rs.next()) {
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
    // ... 通过 MetaObject 设置属性
    metaObject.setValue(resultMapping.getProperty(), value);
}

public class Cache {
    // 基础缓存实现
    PerpetualCache delegate;
    
    // 可选的装饰器链
    LruCache lru;
    FifoCache fifo;
    SynchronizedCache sync;
    
    // 装饰器包装
    cache = new SynchronizedCache(new LruCache(new PerpetualCache(id)));
}

@Intercepts({@Signature(type = Executor.class, method = "query", 
    args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
public class MyPlugin implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 前置逻辑
        Object result = invocation.proceed();  // 调用下一个
        // 后置逻辑
        return result;
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);  // 动态代理
    }
}

public void commit(boolean required) throws SQLException {
    if (transaction != null) {
        transaction.commit();
    }
}

public enum TransactionIsolationLevel {
    NONE(Connection.TRANSACTION_NONE),
    READ_COMMITTED(Connection.TRANSACTION_READ_COMMITTED),
    READ_UNCOMMITTED(Connection.TRANSACTION_READ_UNCOMMITTED),
    REPEATABLE_READ(Connection.TRANSACTION_REPEATABLE_READ),
    SERIALIZABLE(Connection.TRANSACTION_SERIALIZABLE);
}

// 使用示例
MetaObject metaObject = SystemMetaObject.forObject(user);
metaObject.setValue("name", "grok");
String name = (String) metaObject.getValue("address.street");

public class PropertyTokenizer implements Iterator<PropertyTokenizer> {
    private String name;      // user
    private String indexedName; // address[0] 
    private String index;     // 0
    private String children;  // street
}

registry.register(Integer.class, new IntegerTypeHandler());
registry.register(String.class, new StringTypeHandler());
// 自定义枚举处理
registry.register(MyEnum.class, new EnumTypeHandler<>(MyEnum.class));

// 基础类型
IntegerTypeHandler, LongTypeHandler, StringTypeHandler
// 日期时间  
DateTypeHandler, LocalDateTimeTypeHandler, InstantTypeHandler
// 大对象
BlobTypeHandler, ClobTypeHandler
// 数组
ArrayTypeHandler

public class JsonTypeHandler implements TypeHandler<Object> {
    @Override
    public void setParameter(PreparedStatement ps, int i, Object parameter, JdbcType jdbcType) {
        ps.setString(i, JSON.toJSONString(parameter));
    }

    @Override
    public Object getResult(ResultSet rs, String columnName) {
        return JSON.parseObject(rs.getString(columnName));
    }
}

public interface Log {
    boolean isDebugEnabled();
    void debug(String s);
    void debug(String s, Throwable e);
    // ... 其他级别
}

2023-01-01 10:00:00.001 [main] DEBUG c.example.mapper.UserMapper.selectById - ==>  Preparing: SELECT * FROM user WHERE id = ?
2023-01-01 10:00:00.002 [main] DEBUG c.example.mapper.UserMapper.selectById - ==> Parameters: 1(Integer)
2023-01-01 10:00:00.005 [main] DEBUG c.example.mapper.UserMapper.selectById - <==      Total: 1

// 1. SQL 解析缓存
MappedStatement ms = configuration.getMappedStatement(statement);

// 2. 参数处理优化
BoundSql boundSql = ms.getBoundSql(parameter);
CacheKey cacheKey = createCacheKey(ms, parameter, rowBounds, boundSql);

// 3. 缓存命中检查  
List<E> list = resultHandler == null ? (List<E>) localCache.getObject(cacheKey) : null;
if (list != null) {
    // 缓存命中，直接返回
    return list;
}

// 4. 数据库查询
list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
localCache.putObject(cacheKey, list);

public class Configuration {
    // 核心组件
    protected Environment environment;
    protected boolean safeRowBoundsEnabled;
    protected boolean safeResultHandlerEnabled = true;
    protected boolean mapUnderscoreToCamelCase;
    protected boolean aggressiveLazyLoading;
    protected boolean multipleResultSetsEnabled = true;
    protected boolean useGeneratedKeys;
    protected boolean useColumnLabel = true;
    protected boolean cacheEnabled = true;
    protected boolean callSettersOnNulls;
    protected boolean useActualParamName = true;
    
    // 注册中心
    protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry(this);
    protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
    protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();
    
    // 映射语句
    protected final Map<String, MappedStatement> mappedStatements = new StrictMap<>();
    protected final Map<String, Cache> caches = new StrictMap<>();
    protected final Map<String, ResultMap> resultMaps = new StrictMap<>();
    protected final Map<String, ParameterMap> parameterMaps = new StrictMap<>();
}

// 1. 解析 mybatis-config.xml
XMLConfigBuilder configBuilder = new XMLConfigBuilder(inputStream);
Configuration config = configBuilder.parse();

// 2. 解析 Mapper XML
XMLMapperBuilder mapperBuilder = new XMLMapperBuilder(inputStream, config, resource);
mapperBuilder.parse();

// 3. 构建 SqlSessionFactory
SqlSessionFactory factory = new DefaultSqlSessionFactoryBuilder().build(config);

@Select("SELECT * FROM user WHERE id = #{id}")
@Results({
    @Result(property = "id", column = "id"),
    @Result(property = "name", column = "user_name")
})
User selectById(@Param("id") Integer id);

// 1. 善用批量操作
SqlSession batchSession = factory.openSession(ExecutorType.BATCH);
for (User user : users) {
    batchSession.insert("insertUser", user);
}
batchSession.commit();

// 2. 合理使用缓存
@CacheNamespace(
    size = 512,
    flushInterval = 60000,
    eviction = LRU.class,
    readWrite = false
)

// 3. 自定义类型处理
@MappedTypes({MyEnum.class})
@MappedJdbcTypes({JdbcType.VARCHAR})
public class MyEnumTypeHandler implements TypeHandler<MyEnum> {
    // 实现类型转换逻辑
}

// 4. 插件扩展
@Intercepts(@Signature(type = StatementHandler.class, method = "prepare"))  
public class SqlPrintPlugin implements Interceptor {
    // 打印执行的 SQL
}

@Configuration
@MapperScan("com.example.mapper")
public class MyBatisConfig {
    
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) {
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        return factory.getObject();
    }
    
    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory factory) {
        return new SqlSessionTemplate(factory);
    }
}

@Intercepts(@Signature(type = Executor.class, method = "query"))
public class PageInterceptor implements Interceptor {
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object[] args = invocation.getArgs();
        MappedStatement ms = (MappedStatement) args[0];
        Object parameter = args[1];
        RowBounds rowBounds = (RowBounds) args[2];
        
        if (rowBounds != RowBounds.DEFAULT) {
            // 构造 COUNT SQL
            String countSql = "SELECT COUNT(*) FROM (" + originalSql + ") tmp_count";
            // 构造分页 SQL  
            String pageSql = originalSql + " LIMIT " + rowBounds.getOffset() + "," + rowBounds.getLimit();
            
            // 先查总数，再查分页数据
            // ...
        }
        
        return invocation.proceed();
    }
}