Understanding MyBatis Architecture: Layers, Core Components, and Execution Flow

MyBatis is a widely used Java ORM framework in many leading internet companies, and mastering its principles is essential for developers aiming to work at top-tier firms.

MyBatis Architecture Design

The framework is divided into three functional layers:

API Interface Layer

Data Processing Layer

Base Support Layer

Interface Layer

The interface layer provides the APIs that interact with the database. When a request arrives, it forwards the call to the data processing layer. Mapper interfaces are generated via dynamic proxies, linking method signatures to SQL statements defined in XML files.

Data Processing Layer

This core layer handles SQL lookup, parsing, execution, and result mapping. It performs two main tasks: constructing dynamic SQL from input parameters and executing the SQL while converting the result set into Java collections.

1. Dynamic SQL Construction

MyBatis uses OGNL to build flexible SQL statements at runtime. Parameter mapping converts Java types to JDBC types during the query phase and vice‑versa when processing result sets.

2. SQL Execution and Result Set Wrapping

After generating the dynamic SQL, MyBatis executes it and maps the returned rows to List<E>. It supports one‑to‑many and many‑to‑one relationships through nested queries or nested result mappings.

Base Support Layer

This foundational layer supplies essential services such as connection management, transaction handling, configuration loading, and caching.

1. Caching Mechanism

MyBatis provides first‑level (session) and second‑level (mapper) caches to reduce database load, complementing external caches like Redis or Memcached.

2. Reflection Utilities

Encapsulates Java reflection with metadata caching to improve performance when accessing classes and methods.

3. Type Conversion

Handles aliasing and conversion between JDBC types and Java types for both input parameters and result sets.

4. Logging

Integrates with various logging frameworks to output detailed execution information.

5. Resource Loading

Wraps class loaders to load configuration files and other resources.

6. Parsers

Provides XPath parsing for XML configuration files and placeholder handling for dynamic SQL.

7. Transaction Management

Offers a simple transaction API; in practice, most projects delegate transaction control to Spring.

8. Binding

Links Mapper interfaces with XML mappings, generating dynamic proxy instances so developers need not implement the interfaces manually.

Data Source

MyBatis includes a built‑in connection pool implementation located in the datasource package, which manages a pool of physical database connections to improve performance.

MyBatis Core Execution Process

The overall execution consists of six major steps:

MyBatis configuration file (config.xml) – defines global settings and environments.

SqlSessionFactory – built from the configuration to create SqlSession instances.

SqlSession – provides CRUD operations.

Executor – the low‑level component that actually runs SQL; MyBatis supplies a default executor and a caching executor.

MappedStatement – encapsulates a single SQL statement’s metadata, including input and output parameter mappings.

Binding – connects the Mapper interface method to the corresponding MappedStatement, enabling dynamic proxy execution.

Understanding this layered architecture and execution flow equips developers with the knowledge needed to read MyBatis source code and apply the framework effectively in enterprise projects.