#MyBatis 持久层框架

// 第一步：读取配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
// 第二步：构建 Configuration
XMLConfigBuilder parser = new XMLConfigBuilder(inputStream);
Configuration config = parser.parse();
// 第三步：创建 SqlSessionFactory
SqlSessionFactory factory = new DefaultSqlSessionFactory(config);

// CachingExecutor 装饰了 BaseExecutor
public class CachingExecutor implements Executor {
    private final Executor delegate;
    private final TransactionalCacheManager tcm = new TransactionalCacheManager();

    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds,
                            ResultHandler resultHandler, CacheKey key, BoundSql boundSql) {
        // 一级缓存查询
        if (ms.isFlushCacheRequired()) {
            flushStatements();
        }
        // 二级缓存查询
        Cache cache = ms.getCache();
        if (cache != null) {
            if (FlushCachePolicy.TRUE.equals(cache.getFlushInterval())) {
                flushStatements();
            }
            if (BoundSql.NONE.equals(resultHandler)) {
                List<E> cached = cache.getObject(key);
                if (cached != null) {
                    return cached;
                }
            }
        }
        // 委托给 BaseExecutor
        List<E> list = delegate.query(ms, parameter, rowBounds, resultHandler, key, boundSql);
        // 放入二级缓存
        if (cache != null) {
            cache.putObject(key, list);
        }
        return list;
    }
}

// BaseExecutor 的一级缓存
public abstract class BaseExecutor implements Executor {
    // 一级缓存：PerpetualCache，自定义 HashMap
    protected final PerpetualCache localCache = new PerpetualCache("LocalCache");

    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds,
                            ResultHandler resultHandler, CacheKey key, BoundSql boundSql) {
        // 1. 查一级缓存
        List<E> cached = localCache.getObject(key);
        if (cached != null) {
            return cached;
        }
        // 2. 缓存没命中，查询数据库
        List<E> list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
        // 3. 结果放入一级缓存
        localCache.putObject(key, list);
        return list;
    }

    // 缓存失效的情况：
    // 1. SqlSession 关闭或提交
    // 2. 执行 update/delete/insert
    // 3. 调用 clearCache()
    // 4. 查询条件不同（CacheKey 不同）
}

SqlSession sqlSession = sqlSessionFactory.openSession();
try {
    User user1 = sqlSession.selectOne("selectById", 1L);  // 查数据库
    User user2 = sqlSession.selectOne("selectById", 1L);  // 走缓存
    // 结果一样，第二次不查数据库

    User user3 = sqlSession.selectOne("selectById", 1L);  // clearCache 后查数据库
    sqlSession.clearCache();

    sqlSession.commit();  // 提交后缓存失效

    sqlSession.update("updateUser", user);  // 更新后缓存失效
} finally {
    sqlSession.close();
}

// MyBatis 四大对象都可能被插件拦截
// Executor (update, query, flushStatements, close)
// StatementHandler (prepare, parameterize, batch, update)
// ParameterHandler (getParameterObject, setParameters)
// ResultSetHandler (handleResultSets, handleOutputParameters)

// 插件使用动态代理拦截
public class MyPlugin implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 获取被拦截的方法
        Method method = invocation.getMethod();
        Object[] args = invocation.getArgs();

        // 拦截前处理
        System.out.println("SQL 执行前...");

        // 执行目标方法
        Object result = invocation.proceed();

        // 拦截后处理
        System.out.println("SQL 执行后...");

        return result;
    }

    @Override
    public Object plugin(Object target) {
        // 为目标对象创建代理
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        // 读取配置参数
    }
}

@Intercepts({
    @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})
})
public class PaginationInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler sh = (StatementHandler) invocation.getTarget();
        // 反射获取 SQL
        MetaObject metaObject = SystemMetaObject.forObject(sh);
        String originalSql = (String) metaObject.getValue("delegate.boundSql.sql");

        // 获取分页参数
        PageHelper page = PageHelper.start();
        if (page != null) {
            // 改写 SQL
            String pageSql = buildPageSql(originalSql, page);
            metaObject.setValue("delegate.boundSql.sql", pageSql);
        }

        return invocation.proceed();
    }

    private String buildPageSql(String sql, PageHelper page) {
        // MySQL 分页
        return sql + " LIMIT " + page.getOffset() + "," + page.getLimit();
    }
}

// 嵌套查询的 N+1 问题
List<Order> orders = orderMapper.selectAll();
// SQL 1: SELECT * FROM orders
// 如果有 10 个订单，每个订单查用户
// SQL 2-11: SELECT * FROM user WHERE id = ?
// 总共执行 1 + 10 = 11 条 SQL！

// 嵌套结果一次搞定
List<Order> orders = orderMapper.selectAllWithUser();
// SQL: SELECT o.*, u.* FROM orders o LEFT JOIN user u ON o.user_id = u.id
// 只执行 1 条 SQL

// MyBatis 用 javassist 或 cglib 生成代理对象
// 调用 getUser() 时触发懒加载
public class UserProxy extends User {
    private Loader delegate;  // 懒加载加载器
    private User user;  // 实际对象

    public User getUser() {
        if (user == null) {
            // 触发懒加载
            user = delegate.loadUser(userId);
        }
        return user;
    }
}