在互联网大厂后端开发领域，MyBatis 作为一款主流的持久层框架，凭借其灵活的配置与强大的数据处理能力，广泛应用于各类项目之中。然而，随着业务场景日趋复杂、系统规模不断扩张，开发过程中常面临 SQL 执行监控困难、Java 与数据库类型适配复杂等技术挑战。这些问题不仅增加系统开发与维护成本，还可能影响项目交付进度。实际上，MyBatis 框架提供了丰富的扩展机制，深入掌握这些扩展点，能够有效突破技术瓶颈，显著提升开发效率与系统性能。

MyBatis 是一款优秀的持久层框架，在互联网大厂的众多项目中被广泛应用。它以简洁的配置和强大的功能，帮助我们快速实现数据库操作。但随着项目规模的不断扩大，业务需求日益复杂，基础的 MyBatis 功能可能无法满足所有场景。这时候，那些扩展点就显得尤为重要了，它们能让 MyBatis 的能力得到进一步提升，更好地适配各种复杂的业务逻辑。

插件（Interceptor）：SQL 执行的 “守护者”

第一个超实用的扩展点就是插件（Interceptor）。在实际项目开发中，我们常常需要在 SQL 语句执行前后做一些自定义操作，比如记录每次执行的 SQL 语句，方便后续进行性能分析和调试 。而 MyBatis 的插件机制就为我们提供了这样的能力。

开发人员只需要实现
org.apache.ibatis.plugin.Interceptor接口，就能创建自己的插件。该接口包含intercept、plugin和setProperties三个方法。intercept方法是核心，用于拦截目标方法并执行自定义逻辑；plugin方法用于生成代理对象；setProperties方法用于设置插件的属性。

下面是一个简单的插件示例，用于记录 SQL 执行耗时：

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import java.util.Properties;

@Intercepts({
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
public class SqlCostInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = invocation.proceed();
        long end = System.currentTimeMillis();
        System.out.println("SQL执行耗时：" + (end - start) + "ms");
        return result;
    }
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
    @Override
    public void setProperties(Properties properties) {
        // 设置插件属性
    }
}

在插件中，我们可以对 SQL 语句进行拦截，添加一些额外的逻辑。通过上述代码，在 SQL 执行前记录开始时间，执行结束后记录结束时间，就能计算出整个 SQL 的执行耗时，这样就能快速定位到执行缓慢的 SQL 语句，进行针对性优化。

拦截器：SQL 流程的 “精细调控者”

拦截器和插件类似，但能更精细地控制语句执行流程。通过实现
org.apache.ibatis.plugin.Invocation接口创建拦截器，它提供了更多方法来检查和修改 SQL 语句。

在一些复杂的分页场景中，不同的数据库类型（像 MySQL 和 Oracle）分页语法不一样 。以 MySQL 和 Oracle 的分页为例，MySQL 使用LIMIT关键字，而 Oracle 使用ROWNUM。我们就可以编写一个拦截器，根据数据库类型和查询条件，自动生成合适的分页 SQL。

例如，以下是一个简单的分页拦截器思路代码：

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import java.util.Properties;

@Intercepts({
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
public class PaginationInterceptor 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];
        ResultHandler resultHandler = (ResultHandler) args[3];
        Executor executor = (Executor) invocation.getTarget();
        BoundSql boundSql = ms.getBoundSql(parameter);
        String sql = boundSql.getSql();
        // 根据数据库类型添加分页逻辑
        String dialect = "mysql"; // 假设默认是mysql，实际可从配置获取
        if ("mysql".equals(dialect)) {
            sql = sql + " LIMIT " + rowBounds.getOffset() + ", " + rowBounds.getLimit();
        } else if ("oracle".equals(dialect)) {
            sql = "SELECT * FROM ( SELECT t.*, ROWNUM rnum FROM (" + sql + ") t WHERE ROWNUM <= " + (rowBounds.getOffset() + rowBounds.getLimit()) + " ) WHERE rnum > " + rowBounds.getOffset();
        }
        BoundSql newBoundSql = new BoundSql(ms.getConfiguration(), sql, boundSql.getParameterMappings(), boundSql.getParameterObject());
        MappedStatement newMs = copyFromMappedStatement(ms, new BoundSqlSqlSource(newBoundSql));
        args[0] = newMs;
        return executor.query((MappedStatement) args[0], parameter, RowBounds.DEFAULT, resultHandler);
    }
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
    @Override
    public void setProperties(Properties properties) {
        // 设置插件属性
    }
    private MappedStatement copyFromMappedStatement(MappedStatement ms, SqlSource newSqlSource) {
        MappedStatement.Builder builder = new MappedStatement.Builder(ms.getConfiguration(), ms.getId(), newSqlSource, ms.getSqlCommandType());
        builder.resource(ms.getResource());
        builder.fetchSize(ms.getFetchSize());
        builder.statementType(ms.getStatementType());
        builder.keyGenerator(ms.getKeyGenerator());
        builder.timeout(ms.getTimeout());
        builder.parameterMap(ms.getParameterMap());
        builder.resultMaps(ms.getResultMaps());
        builder.resultSetType(ms.getResultSetType());
        builder.cache(ms.getCache());
        builder.flushCacheRequired(ms.isFlushCacheRequired());
        builder.useCache(ms.isUseCache());
        return builder.build();
    }
    public static class BoundSqlSqlSource implements SqlSource {
        private BoundSql boundSql;
        public BoundSqlSqlSource(BoundSql boundSql) {
            this.boundSql = boundSql;
        }
        @Override
        public BoundSql getBoundSql(Object parameterObject) {
            return boundSql;
        }
    }
}

通过这样的拦截器，就能大大提高开发效率，再也不用手动去调整分页逻辑，避免了因为语法不同而导致的错误。

自定义类型处理器（TypeHandler）：数据类型转换的 “桥梁”

自定义类型处理器（TypeHandler）也是个 “神器”。在实际开发中，数据库中的数据类型和 Java 中的数据类型不匹配的情况太常见了。比如，数据库中有个字段存储的是 JSON 格式的数据，但在 Java 中没有直接对应的类型。

开发人员通过实现
org.apache.ibatis.type.TypeHandler接口，重写setValue和getResult方法，就能轻松实现数据在 Java 类型和数据库列类型之间的转换 。setValue方法用于将 Java 对象转换为数据库可接受的类型，getResult方法用于将从数据库读取的数据转换为 Java 对象。

下面是一个处理 JSON 数据的自定义类型处理器示例：

import com.google.gson.Gson;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JsonTypeHandler<T> extends BaseTypeHandler<T> {
    private Class<T> type;
    private final Gson gson = new Gson();
    public JsonTypeHandler(Class<T> type) {
        if (type == null) {
            throw new IllegalArgumentException("Type argument cannot be null");
        }
        this.type = type;
    }
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
        ps.setString(i, gson.toJson(parameter));
    }
    @Override
    public T getNullableResult(ResultSet rs, String columnName) throws SQLException {
        String json = rs.getString(columnName);
        return json == null? null : gson.fromJson(json, type);
    }
    @Override
    public T getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        String json = rs.getString(columnIndex);
        return json == null? null : gson.fromJson(json, type);
    }
    @Override
    public T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        String json = cs.getString(columnIndex);
        return json == null? null : gson.fromJson(json, type);
    }
}

通过上述自定义类型处理器，你可以把 JSON 数据在写入数据库时转换成字符串，从数据库读取时再转回 Java 对象，让数据处理变得丝滑流畅。

总结

了解了这些 MyBatis 框架的扩展点，相信大家对它的强大之处有了更深的认识。这些扩展点就像是隐藏在 MyBatis 中的 “超能力”，合理运用它们，能让我们在后端开发中事半功倍。各位互联网大厂的后端开发小伙伴们，赶紧把这些扩展点用起来，在项目中实践一下，说不定能解决不少困扰你许久的问题。要是你在使用过程中有什么新发现、新技巧，欢迎在评论区分享，咱们一起交流学习，共同进步！