Mybatis入门教程：轻松掌握Java持久化框架

概述

MyBatis 是一个优秀的持久层框架，支持定制化 SQL、存储过程以及高级映射，避免了手动设置参数和获取结果集的过程。MyBatis 可以与 Spring 框架无缝集成，提供简单 XML 或注解配置，将接口和 Java 对象映射到数据库记录。本文详细介绍了 MyBatis 的优势、应用场景、环境搭建以及核心概念和高级特性。

Mybatis简介

MyBatis 是一个优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程。MyBatis 可以使用简单的 XML 或注解进行配置和原始映射，将接口和 Java 的 POJO（Plain Old Java Objects，普通的 Java 对象）映射成数据库中的记录。

Mybatis是什么

MyBatis 是一个 Java 框架，主要用于将 Java 对象与数据库中的记录进行映射。MyBatis 可以与 Spring 框架无缝集成，从而实现在 Java 代码中直接使用 MyBatis 提供的 API 进行数据库操作。

Mybatis的优势与应用场景

• 简化数据库操作：MyBatis 可以直接使用 Java 代码和数据库中的记录进行映射，避免了手动设置参数和获取结果集的过程。
• 灵活性：MyBatis 提供了强大的映射功能，可以将任何对象映射到数据库中。
• 支持自定义 SQL 语句：MyBatis 允许用户编写自定义的 SQL 语句，从而更灵活地进行数据库操作。
• 支持存储过程：MyBatis 支持存储过程的调用，可以将存储过程的结果映射到 Java 对象。
• 支持动态 SQL：MyBatis 支持动态 SQL 的编写，可以根据运行时条件生成不同的 SQL 语句。
• 缓存机制：MyBatis 支持一级缓存和二级缓存，可以提高查询性能。
• 插件机制：MyBatis 提供了插件机制，可以在执行 SQL 语句前后进行插件的处理。
• 与 Spring 集成：MyBatis 可以与 Spring 框架无缝集成，从而实现在 Java 代码中直接使用 MyBatis 提供的 API 进行数据库操作。

我们可以将 MyBatis 用于各种应用场景，例如：

• 简单的 CRUD 应用：MyBatis 适用于需要进行基本增删改查操作的应用。
• 复杂的查询：对于需要执行复杂 SQL 查询的应用，MyBatis 提供了强大的映射功能。
• 分页功能：通过 MyBatis 的插件机制，可以方便地实现分页功能。
• 性能优化：利用缓存机制可以提高查询性能。

Mybatis环境搭建

Java开发环境搭建

在开始使用 MyBatis 之前，需要先搭建 Java 开发环境。以下是搭建 Java 开发环境的基本步骤：

1. 安装 JDK：下载并安装 JDK，这里以 JDK 11 为例。
2. 设置环境变量：设置 JAVA_HOME 环境变量指向 JDK 的安装路径，并将 JAVA_HOME/bin 添加到 PATH 环境变量中。
3. 验证安装：打开命令行工具，输入 java -version，如果显示 JDK 版本信息，则说明安装成功。

Mybatis的下载与配置

1. 下载并导入 MyBatis：可以从 MyBatis 官方网站下载 MyBatis 框架，也可以通过 Maven 或者 Gradle 等构建工具自动导入 MyBatis。
2. 创建数据库和表：在数据库中创建一个名为 mybatis_test 的数据库，并创建一个名为 user 的表，表结构如下：

CREATE DATABASE `mybatis_test`;
USE `mybatis_test`;

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

1. 创建 MyBatis 配置文件：创建 mybatis-config.xml 配置文件，配置数据库连接信息及 MyBatis 核心配置：

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_test"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

创建第一个Mybatis项目

1. 创建 Java 项目：使用 IDE（如 IntelliJ IDEA 或 Eclipse）创建一个新的 Java 项目。
2. 导入 MyBatis 依赖：在项目的 pom.xml 文件中添加 MyBatis 依赖：

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.22</version>
    </dependency>
</dependencies>

1. 创建 User 实体类：创建一个表示 user 表的实体类：

public class User {
    private int id;
    private String username;
    private String password;

    // 构造函数、getter 和 setter 方法
    public User() {}

    public User(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

1. 创建 UserMapper 接口和 XML 映射文件：创建一个接口 UserMapper，并创建对应的 XML 映射文件 UserMapper.xml，定义 CRUD 操作：

public interface UserMapper {
    User selectUserById(int id);
    int insertUser(User user);
    int deleteUser(int id);
}

<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectUserById" resultType="com.example.model.User">
        SELECT * FROM user WHERE id = #{id}
    </select>

    <insert id="insertUser">
        INSERT INTO user (username, password) VALUES (#{username}, #{password})
    </insert>

    <delete id="deleteUser">
        DELETE FROM user WHERE id = #{id}
    </delete>
</mapper>

1. 编写测试代码：编写测试代码，测试 MyBatis 的 CRUD 操作：

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.session.TransactionIsolationLevel;

import java.io.InputStream;
import java.util.List;

public class MybatisTest {
    public static void main(String[] args) {
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

            SqlSession session = sqlSessionFactory.openSession();
            UserMapper userMapper = session.getMapper(UserMapper.class);

            // 查询用户
            User user = userMapper.selectUserById(1);
            System.out.println(user);

            // 插入用户
            User newUser = new User(1, "test", "password");
            int rowsInserted = userMapper.insertUser(newUser);
            System.out.println("Rows inserted: " + rowsInserted);

            // 删除用户
            int rowsDeleted = userMapper.deleteUser(1);
            System.out.println("Rows deleted: " + rowsDeleted);

            session.commit();
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Mybatis核心概念

SqlSession和SqlSessionFactory

SqlSessionFactory 是 MyBatis 中一个工厂类，用于创建 SqlSession 对象。SqlSession 是 MyBatis 中的会话对象，用于执行数据库操作。

1. SqlSessionFactory：SqlSessionFactory 用于创建 SqlSession 对象。可以通过 SqlSessionFactoryBuilder 从配置文件中创建 SqlSessionFactory 对象。

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);

1. SqlSession：SqlSession 是 MyBatis 中的会话对象，用于执行数据库操作。可以通过 SqlSessionFactory 创建 SqlSession 对象。

SqlSession session = factory.openSession();

Mapper接口和Mapper XML文件

Mapper 接口是 MyBatis 中定义操作的接口，而 Mapper XML 文件是用来定义 SQL 语句的配置文件。

1. Mapper 接口：Mapper 接口是 MyBatis 中定义操作的接口，接口中的方法用于调用 SQL 语句。

public interface UserMapper {
    User selectUserById(int id);
    int insertUser(User user);
    int deleteUser(int id);
}

1. Mapper XML 文件：Mapper XML 文件是用来定义 SQL 语句的配置文件，文件中的 id 属性用来指定 Mapper 接口中方法的名字。

<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectUserById" resultType="com.example.model.User">
        SELECT * FROM user WHERE id = #{id}
    </select>

    <insert id="insertUser">
        INSERT INTO user (username, password) VALUES (#{username}, #{password})
    </insert>

    <delete id="deleteUser">
        DELETE FROM user WHERE id = #{id}
    </delete>
</mapper>

{}和${}的区别

在 Mapper XML 文件中，可以使用 #{} 和 ${} 两种占位符来表示参数。

• #{}：表示预编译参数，MyBatis 会将参数值转换为 SQL 语句中的类型。
• ${}：表示直接替换参数，MyBatis 不会将参数值转换为 SQL 语句中的类型。

例如：

<select id="selectUserById" resultType="com.example.model.User">
    SELECT * FROM user WHERE id = #{id}
</select>

<select id="selectUserById" resultType="com.example.model.User">
    SELECT * FROM user WHERE id = ${id}
</select>

Mybatis数据操作

CRUD操作详解

CRUD 操作指的是数据库中的基本操作：创建（Create）、读取（Read）、更新（Update）、删除（Delete）。

1. 创建（Create）：创建用户。

<insert id="insertUser">
    INSERT INTO user (username, password) VALUES (#{username}, #{password})
</insert>

int rowsInserted = userMapper.insertUser(newUser);

1. 读取（Read）：读取用户信息。

<select id="selectUserById" resultType="com.example.model.User">
    SELECT * FROM user WHERE id = #{id}
</select>

User user = userMapper.selectUserById(1);

1. 更新（Update）：更新用户信息。

<update id="updateUser">
    UPDATE user SET username = #{username}, password = #{password} WHERE id = #{id}
</update>

User user = new User(1, "test", "newpassword");
int rowsUpdated = userMapper.updateUser(user);

1. 删除（Delete）：删除用户。

<delete id="deleteUser">
    DELETE FROM user WHERE id = #{id}
</delete>

int rowsDeleted = userMapper.deleteUser(1);

结果集映射

结果集映射是指将查询结果映射到 Java 对象的过程。可以使用 resultType 或 resultMap 来配置结果集映射。

1. resultType：直接指定 Java 类的全限定名。

<select id="selectUserById" resultType="com.example.model.User">
    SELECT * FROM user WHERE id = #{id}
</select>

1. resultMap：定义一个结果集映射。

<resultMap id="userResultMap" type="com.example.model.User">
    <id property="id" column="id" />
    <result property="username" column="username" />
    <result property="password" column="password" />
</resultMap>

<select id="selectUserById" resultMap="userResultMap">
    SELECT * FROM user WHERE id = #{id}
</select>

动态SQL的使用

动态 SQL 是指根据运行时条件生成不同的 SQL 语句。MyBatis 提供了多种动态 SQL 标签，如 <if>、<choose>、<when>、<otherwise>、<foreach> 等。

1. if：根据条件判断是否包含某个 SQL 语句片段。

<select id="selectUserByCondition" resultType="com.example.model.User">
    SELECT * FROM user
    <where>
        <if test="username != null">
            AND username = #{username}
        </if>
        <if test="password != null">
            AND password = #{password}
        </if>
    </where>
</select>

1. foreach：用来遍历集合或数组。

<select id="selectUsersByIds" resultType="com.example.model.User">
    SELECT * FROM user WHERE id IN
    <foreach item="item" index="index" collection="ids" open="(" separator="," close=")">
        #{item}
    </foreach>
</select>

Mybatis高级特性

一级和二级缓存

MyBatis 提供了一级缓存和二级缓存机制，可以提高查询性能。

1. 一级缓存：一级缓存是 SqlSession 级别的缓存，当同一个 SqlSession 执行相同的查询时，会从缓存中获取数据，避免再次执行 SQL 语句。

2. 二级缓存：二级缓存是 Mapper 级别的缓存，当不同的 SqlSession 执行相同的查询时，会从缓存中获取数据，避免再次执行 SQL 语句。二级缓存需要在 Mapper XML 文件中进行配置。

<cache />

分页插件的使用

MyBatis 提供了分页插件，可以实现数据库分页。

1. PageHelper：PageHelper 是一个分页插件，可以实现数据库分页。在 pom.xml 文件中添加 PageHelper 依赖：

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.2</version>
</dependency>

1. 配置 PageHelper：在 MyBatis 配置文件中配置 PageHelper。

<configuration>
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <property name="helperDialect" value="mysql"/>
            <property name="reasonable" value="true"/>
            <property name="params" value="count=countSql"/>
        </plugin>
    </plugins>
</configuration>

1. 使用 PageHelper：在查询之前调用 PageHelper.startPage 方法，设置分页参数。

import com.github.pagehelper.PageHelper;

PageHelper.startPage(pageNum, pageSize);
List<User> users = userMapper.selectUsers();

插件机制简介

MyBatis 提供了插件机制，可以在执行 SQL 语句前后进行插件的处理。插件机制通过 Intercepts 注解来定义插件。

1. 定义插件：定义一个插件类，实现 org.apache.ibatis.plugin.Interceptor 接口。

import org.apache.ibatis.plugin.*;

public class MyInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 在执行 SQL 语句之前
        System.out.println("Before SQL execution");

        // 执行 SQL 语句
        Object result = invocation.proceed();

        // 在执行 SQL 语句之后
        System.out.println("After SQL execution");

        return result;
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {}
}

1. 配置插件：在 MyBatis 配置文件中配置插件。

<configuration>
    <plugins>
        <plugin interceptor="com.example.plugin.MyInterceptor"/>
    </plugins>
</configuration>

实践案例

用户管理系统的实现

用户管理系统是一个简单的 CRUD 系统，包括用户信息的增删改查操作。以下是用户管理系统的实现步骤：

1. 创建数据库和表：在数据库中创建一个名为 mybatis_test 的数据库，并创建一个名为 user 的表，表结构如下：

CREATE DATABASE `mybatis_test`;
USE `mybatis_test`;

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

1. 创建 Java 项目：使用 IDE（如 IntelliJ IDEA 或 Eclipse）创建一个新的 Java 项目。
2. 导入 MyBatis 依赖：在项目的 pom.xml 文件中添加 MyBatis 依赖：

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.22</version>
    </dependency>
</dependencies>

1. 创建 User 实体类：创建一个表示 user 表的实体类：

public class User {
    private int id;
    private String username;
    private String password;

    // 构造函数、getter 和 setter 方法
    public User() {}

    public User(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

1. 创建 UserMapper 接口和 XML 映射文件：创建一个接口 UserMapper，并创建对应的 XML 映射文件 UserMapper.xml，定义 CRUD 操作：

public interface UserMapper {
    User selectUserById(int id);
    int insertUser(User user);
    int deleteUser(int id);
}

<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectUserById" resultType="com.example.model.User">
        SELECT * FROM user WHERE id = #{id}
    </select>

    <insert id="insertUser">
        INSERT INTO user (username, password) VALUES (#{username}, #{password})
    </insert>

    <delete id="deleteUser">
        DELETE FROM user WHERE id = #{id}
    </delete>
</mapper>

1. 编写测试代码：编写测试代码，测试 MyBatis 的 CRUD 操作：

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.session.TransactionIsolationLevel;

import java.io.InputStream;
import java.util.List;

public class MybatisTest {
    public static void main(String[] args) {
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

            SqlSession session = sqlSessionFactory.openSession();
            UserMapper userMapper = session.getMapper(UserMapper.class);

            // 查询用户
            User user = userMapper.selectUserById(1);
            System.out.println(user);

            // 插入用户
            User newUser = new User(1, "test", "password");
            int rowsInserted = userMapper.insertUser(newUser);
            System.out.println("Rows inserted: " + rowsInserted);

            // 删除用户
            int rowsDeleted = userMapper.deleteUser(1);
            System.out.println("Rows deleted: " + rowsDeleted);

            session.commit();
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

缓存机制实践

1. 缓存配置：在 Mapper XML 文件中启用二级缓存。

<cache />

1. 测试缓存：在测试代码中，先执行一次查询，然后在相同的 SqlSession 中再次执行相同的查询，检查是否从缓存中获取数据。

UserMapper userMapper = session.getMapper(UserMapper.class);
User user = userMapper.selectUserById(1);

// 再次执行相同的查询，现在应该从缓存中获取数据
User cachedUser = userMapper.selectUserById(1);

分页插件的实践

1. 导入分页插件依赖：在 pom.xml 文件中添加 PageHelper 依赖。

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.2</version>
</dependency>

1. 配置 PageHelper：在 MyBatis 配置文件中配置 PageHelper。

<configuration>
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <property name="helperDialect" value="mysql"/>
            <property name="reasonable" value="true"/>
            <property name="params" value="count=countSql"/>
        </plugin>
    </plugins>
</configuration>

1. 使用分页插件：在查询之前调用 PageHelper.startPage 方法，设置分页参数。

import com.github.pagehelper.PageHelper;

PageHelper.startPage(pageNum, pageSize);
List<User> users = userMapper.selectUsers();

插件机制实践

1. 定义插件：创建一个插件类，实现 org.apache.ibatis.plugin.Interceptor 接口。

import org.apache.ibatis.plugin.*;

public class MyInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("Before SQL execution");

        Object result = invocation.proceed();

        System.out.println("After SQL execution");

        return result;
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {}
}

1. 配置插件：在 MyBatis 配置文件中配置插件。

<configuration>
    <plugins>
        <plugin interceptor="com.example.plugin.MyInterceptor"/>
    </plugins>
</configuration>

常见问题及解决方法

在使用 MyBatis 时，可能会遇到一些常见问题，以下是一些常见问题及解决方法：

1. MyBatis XML 文件找不到：确保 MyBatis XML 文件路径正确，且在 pom.xml 文件中正确引入了依赖。

2. Mapper 接口找不到：确保 Mapper 接口路径正确，且在 mybatis-config.xml 文件中正确配置了 Mapper 接口。

3. SQL 语句执行失败：检查 SQL 语句是否正确，确保 SQL 语句中的参数正确。

4. 缓存问题：确保缓存配置正确，且在 mybatis-config.xml 文件中正确配置了缓存。

5. 分页插件问题：确保分页插件配置正确，且在 pom.xml 文件中正确引入了依赖。

6. 插件机制问题：确保插件机制配置正确，且在 mybatis-config.xml 文件中正确配置了插件。