Understanding MyBatis Plugins: Use Cases, Mechanism, and Development Guide

Background

Most developers know MyBatis plugins but often only at a superficial level; this article reviews typical use cases, internal implementation, and related design patterns using MyBatis 3.4.7‑SNAPSHOT as an example.

Typical Use Cases

Pagination – intercept StatementHandler.prepare to replace the original SQL with a paginated version.

Uniform assignment of common fields – intercept Executor.update to set creator, creation time, modifier, and modification time.

Performance monitoring – intercept Executor methods (e.g., query, update) to log execution time.

Other extensions – any stage of SQL execution (parameter handling, result set processing, etc.) can be intercepted.

MyBatis Plugin Overview

What is a MyBatis Plugin

It is essentially an interceptor that applies the proxy pattern to intercept method calls at the DAO layer.

Supported Interceptable Methods

Executor (update, query, commit, rollback, …)

ParameterHandler (getParameterObject, setParameters)

ResultSetHandler (handleResultSets, handleOutputParameters)

StatementHandler (prepare, parameterize, batch, update, query)

Implementation Mechanism

Loading Plugin Configuration

MyBatis reads plugin definitions from XML, creates Interceptor objects, calls setProperties to configure them, and adds them to Configuration.interceptorChain.

Proxy Object Generation

Dynamic proxies are created via Proxy.newProxyInstance; each interceptor wraps the target, forming a chain where the outermost proxy delegates to the next.

Execution of Intercept Logic

When a proxied method is invoked, Plugin.invoke checks whether the method matches the interceptor’s signature, runs the interceptor’s intercept method, and finally calls invocation.proceed() to continue the chain.

Development Example

A pagination plugin demonstrates the three required methods: intercept (modify SQL), plugin (create proxy), and setProperties (configure properties).

Conclusion

MyBatis plugins intercept methods of Executor, ParameterHandler, ResultSetHandler, and StatementHandler using JDK dynamic proxies, embodying AOP concepts and design patterns such as Proxy and Chain of Responsibility; developers should avoid excessive nesting of plugins to prevent performance degradation.