Understanding MyBatis Core Concepts

MyBatis operates as a first-class persistence framework that simplifies database interaction by coupling SQL statements with Java objects. It abstracts the complexities of manual JDBC coding, including resource management and result set extraction. By utilizing XML descriptors or annotations, developers map primitive types, Map interfaces, and POJOs (Plain Old Java Objects) directly to database records.

The framework offers several distinct advantages:

• Flexible SQL Mapping: SQL is decoupled from the application code, defined in XML files or annotations, allowing for precise database tuning.
• Dynamic SQL Capabilities: Logic can be embedded within SQL definitions to generate queries dynamically based on variable states.
• Result Mapping: Complex result sets are automatically mapped to object graphs, supporting one-to-one and one-to-many relationships.
• Transaction Management: It integrates seamlessly with transaction managers, supporting both programmatic and declarative transaction control.
• Extensibility: A plugin architecture allows for intercepting method calls to implement features like auditing or pagination.

Configuring MyBatis for a Project

To integrate MyBatis, the necessary dependencies must be included in the build configuration. For a Maven project, add the starter dependency:

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.25</version>
</dependency>

Configuration is typically handled via an XML file, often named mybatis-config.xml. This file defines environment variables such as the connection pool and transaction manager.

<configuration>
    <environments default="dev">
        <environment id="dev">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/store_db"/>
                <property name="username" value="admin"/>
                <property name="password" value="secret"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mappers/ProductMapper.xml"/>
    </mappers>
</configuration>

The interaction layer consists of a Mapper interface and an associated XML file. The interface defines the contract:

public interface ProductMapper {
    Product findItem(long itemId);
}

The corresponding XML file contains the SQL implementation:

<mapper namespace="com.example.mapper.ProductMapper">
    <select id="findItem" resultType="com.example.model.Product">
        SELECT id, name, price FROM inventory WHERE id = #{itemId}
    </select>
</mapper>

Execution is handled by the SqlSessionFactory which generates sessions to manage the database connection:

InputStream configStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(configStream);

try (SqlSession session = factory.openSession()) {
    ProductMapper mapper = session.getMapper(ProductMapper.class);
    Product item = mapper.findItem(5001);
    System.out.println("Item: " + item.getName());
}

Enhancing Productivity with MyBatis-Plus

MyBatis-Plus (MP) functions as an enhancement suite for MyBatis, designed to significantly reduce boilerplate code. It injects standard CRUD (Create, Read, Update, Delete) operations automatically without altering the core framework's behavior. This allows developers to focus on business logic rather than repetitive SQL statements.

Key capabilities include:

• Zero Intrusion: Integration is seamless and does not impact existing code structure.
• Built-in CRUD: Common operations are available immediately via a generic BaseMapper.
• Conditional Constructors: Complex queries can be built using Java code instead of raw SQL strings.
• Lambda Support: Type-safe queries prevent typos in database column names.
• Code Generation: Automates the creation of Entity, Mapper, Service, and Controller classes.
• Pagination: Physical pagination is supported out of the box for various databases.

Implementing MyBatis-Plus

Start by adding the MyBatis-Plus starter to your Maven configuration:

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.3</version>
</dependency>

Configure the data source in application.yml:

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/app_db?useSSL=false
    username: root
    password: password123

Define the entity class corresponding to the database table. MP can infer table names, but explicit mapping is supported via annotations.

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("system_users")
public class User {
    private Long userId;
    private String username;
    private String email;
}

Create the Mapper interface by extending BaseMapper. This immediately inherits methods like insert, deleteById, and selectList.

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
    // Custom SQL methods can be defined here if necessary
}

Ensure the Mapper interfaces are scanned by the Spring container. This can be achieved by adding the @MapperScan annotation to the main application class.

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.repository")
public class ApplicationEntry {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationEntry.class, args);
    }
}

Finally, utilize the Mapper in the service layer to perform database operations. For example, retrieving all records can be done with a single line of code.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public List<User> fetchAllUsers() {
        return userMapper.selectList(null);
    }
}