Mybatis框架：入门

MyBatis的发展可以追溯到2002年，最初由Clinton Begin创建并命名为iBatis。随着时间的推移，MyBatis逐渐成熟，于2010年正式由Apache Software Foundation托管，并更名为MyBatis。版本迭代中，MyBatis不断推出新功能和优化，保持着活跃的开发态势。

四、MyBatis的应用场景

MyBatis适用于各种规模的项目，从小型应用到大型企业级系统都能找到它的身影。它的灵活性使得开发者可以根据项目的需要选择合适的配置方式，同时在处理复杂SQL和数据库操作时仍然能够提供高度的控制力。

五、MyBatis的优缺点分析

优点：

灵活性和可控性： MyBatis提供了灵活的配置方式，开发者可以完全掌控SQL语句的编写和执行过程。
性能优化： MyBatis通过内置的缓存机制和参数映射，能够有效提升系统性能。
简化数据库操作： 相比传统的JDBC，MyBatis通过映射文件简化了数据库操作，减少了冗余代码。

缺点：

不适用于复杂关联查询： 在处理复杂关联查询时，MyBatis的配置可能相对繁琐。
维护成本：随着项目的增长和变更，大量的SQL和映射文件可能会带来一定的维护挑战。
性能瓶颈：在某些情况下，Mybatis的性能瓶颈可能会出现在数据库连接池上，导致系统性能下降。

六、MyBatis与Hibernate等ORM框架的对比

与Hibernate等ORM框架相比，MyBatis更注重SQL的可控性，使得开发者更容易优化和调整SQL语句。Hibernate则更加面向对象，通过对象关系映射实现数据库访问。选择MyBatis还是Hibernate取决于项目需求、团队经验和个人偏好。

七、为什么选择MyBatis？

在众多ORM框架中，为什么选择MyBatis成为了一个常见的问题。首先，MyBatis的简单易用让初学者能够迅速上手，同时其灵活性也能满足有经验的开发者的需求。MyBatis的优势在于对SQL的直观掌控，使得开发者能够更好地优化和调整SQL语句，适用于各种项目规模和复杂度。

二、Mybatis基础

MyBatis的安装与配置

MyBatis作为一款强大的持久层框架，在使用前需要经过安装和配置的步骤。以下是详细的安装与配置过程：

1. 下载和安装MyBatis

1.1 下载MyBatis

访问MyBatis官方网站，找到最新版本的MyBatis，并下载对应的压缩包。

1.2 解压文件

将下载的压缩包解压到你选择的目录，得到MyBatis的安装文件。

2. 配置MyBatis的数据源

2.1 引入数据库驱动

确保你的项目中引入了与你使用的数据库相对应的JDBC驱动，比如MySQL、Oracle等。

2.2 配置数据源信息

打开MyBatis的核心配置文件（通常是mybatis-config.xml），配置数据库连接信息，包括数据库URL、用户名和密码等。

<!-- 数据库连接配置 -->
<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/your_database"/>
            <property name="username" value="your_username"/>
            <property name="password" value="your_password"/>
        </dataSource>
    </environment>
</environments>

3. 配置MyBatis的核心配置文件

3.1 指定映射文件路径

在mybatis-config.xml中，配置MyBatis去哪里寻找映射文件。映射文件包含了SQL语句和实体类的映射关系。

<!-- 映射文件配置 -->
<mappers>
    <mapper resource="com/example/YourMapper.xml"/>
</mappers>

3.2 创建映射文件

创建与你的数据库表对应的映射文件，定义SQL语句和实体类的映射。

<!-- 示例映射文件 YourMapper.xml -->
<mapper namespace="com.example.YourMapper">
    <select id="selectById" resultType="YourEntity">
        SELECT * FROM your_table WHERE id = #{id}
    </select>
    <!-- 其他SQL语句映射 -->
</mapper>

通过按照以上步骤进行MyBatis的安装与配置，你将能够搭建一个基本的MyBatis环境，并为后续的数据库操作做好准备。确保配置文件的正确性，以及数据库连接信息的准确性，这样你就能顺利开始使用MyBatis进行数据库持久化操作。

三、MyBatis注解编程

在MyBatis中，注解编程是一种更为简洁和直观的方式，用于替代XML配置文件。以下是关于MyBatis注解编程的基本概念、使用示例和高级用法的详细介绍：

1. 注解编程的基本概念

什么是注解？

注解是一种用于为程序元素（类、方法、字段等）添加元数据（metadata）的标记。在MyBatis中，注解用于替代XML配置文件，通过在Java代码中添加注解，开发者可以更直观地定义SQL语句和映射关系。

MyBatis常用注解

@Select：用于声明查询语句。
@Insert：用于声明插入语句。
@Update：用于声明更新语句。
@Delete：用于声明删除语句。
@Results：用于声明结果集的映射关系。
@Result：用于声明单个字段与属性的映射关系。
@Param：用于指定方法参数的名称。

2. 注解编程的使用示例

声明查询语句

@Select("SELECT * FROM users WHERE id = #{id}")
User getUserById(@Param("id") int id);

声明插入语句

@Insert("INSERT INTO users(name, age) VALUES(#{name}, #{age})")
void insertUser(User user);

结果集映射

@Results({
    @Result(property = "id", column = "user_id"),
    @Result(property = "name", column = "user_name"),
    @Result(property = "age", column = "user_age")
})
@Select("SELECT * FROM users")
List<User> getAllUsers();

3. 注解编程的高级用法

动态SQL

通过@UpdateProvider、@InsertProvider、@SelectProvider等注解结合Provider类，可以实现动态生成SQL语句。

高级映射

使用@ResultMap注解可以引用在XML中定义的<resultMap>，实现更复杂的结果集映射。

参数处理

@Param注解，可以明确指定方法参数的名称，避免出现歧义，尤其在多参数的情况下更为方便。

缓存配置

通过@CacheNamespace注解可以配置缓存，包括缓存的类型、刷新间隔等。

MyBatis注解编程是一种简洁而灵活的方式，使得开发者可以直接在Java代码中定义SQL语句和映射关系，减少了对XML配置文件的依赖。在使用注解编程时，需要注意保持代码的清晰性和可维护性，避免注解过多导致代码难以阅读。根据项目需求和开发者的个人偏好，可以选择使用XML配置或注解编程，或者两者结合使用。

四、MyBatis XML编程

在MyBatis中，XML配置是一种传统且强大的方式，用于定义SQL语句和映射关系。以下是关于MyBatis XML编程的基本结构、声明式SQL编写、动态SQL编写、结果映射以及类型转换的详细介绍：

1. XML配置文件的基本结构

MyBatis的配置文件通常是mybatis-config.xml，其基本结构如下：

<!-- mybatis-config.xml -->
<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/your_database"/>
                <property name="username" value="your_username"/>
                <property name="password" value="your_password"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 映射文件配置 -->
    <mappers>
        <mapper resource="com/example/YourMapper.xml"/>
    </mappers>
</configuration>

2. 声明式SQL编写

在YourMapper.xml中，可以使用<select>、<insert>、<update>和<delete>等元素声明SQL语句：

<!-- YourMapper.xml -->
<mapper namespace="com.example.YourMapper">
    <!-- 声明查询语句 -->
    <select id="getUserById" resultType="User">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <!-- 声明插入语句 -->
    <insert id="insertUser">
        INSERT INTO users(name, age) VALUES(#{name}, #{age})
    </insert>
    
    <!-- 其他SQL语句声明 -->
</mapper>

3. 动态SQL编写

MyBatis提供了强大的动态SQL功能，可以根据条件来动态构建SQL语句。例如：

<!-- YourMapper.xml -->
<mapper namespace="com.example.YourMapper">
    <!-- 动态查询语句 -->
    <select id="getUsers" resultType="User">
        SELECT * FROM users
        <where>
            <if test="name != null">
                AND name = #{name}
            </if>
            <if test="age != null">
                AND age = #{age}
            </if>
        </where>
    </select>

    <!-- 其他动态SQL语句声明 -->
</mapper>

4. 结果映射

使用<resultMap>元素可以定义复杂的结果映射关系，将数据库字段映射到Java对象的属性：

<!-- YourMapper.xml -->
<mapper namespace="com.example.YourMapper">
    <resultMap id="userResultMap" type="User">
        <id property="id" column="user_id"/>
        <result property="name" column="user_name"/>
        <result property="age" column="user_age"/>
    </resultMap>

    <!-- 使用结果映射 -->
    <select id="getUserById" resultMap="userResultMap">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <!-- 其他使用结果映射的SQL语句声明 -->
</mapper>

5. 类型转换

MyBatis支持通过<typeHandlers>元素配置类型转换器，用于将数据库字段的数据类型转换为Java对象的数据类型：

<!-- mybatis-config.xml -->
<configuration>
    <!-- 类型转换器配置 -->
    <typeHandlers>
        <typeHandler handler="com.example.MyTypeHandler"/>
    </typeHandlers>

    <!-- 其他配置 -->
</configuration>

以上是MyBatis XML编程的基本结构、声明式SQL编写、动态SQL编写、结果映射以及类型转换的基本介绍。XML配置方式在复杂的场景下更为灵活，可以更精细地控制SQL语句和映射关系。

三、Mybatis高级特性

1. 核心组件详解

1.1 SqlSessionFactory和SqlSession

1.1.1 创建SqlSessionFactory实例

SqlSessionFactory是MyBatis的核心接口，用于创建SqlSession实例。通常，我们通过SqlSessionFactoryBuilder来构建SqlSessionFactory：

// 导入必要的类
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

// 读取配置文件并创建SqlSessionFactory
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

1.1.2 使用SqlSession执行CRUD操作

SqlSession是MyBatis的一个会话对象，用于执行数据库操作。常见的操作包括查询、插入、更新、删除等：

在MyBatis中，可以使用SqlSession对象执行CRUD（Create, Read, Update, Delete）操作。以下是一些基本的CRUD操作示例：

// 获取SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();

try {
    // 创建User对象
    User newUser = new User("John Doe", 25);

    // 插入数据
    sqlSession.insert("com.example.YourMapper.insertUser", newUser);

    // 提交事务
    sqlSession.commit();
} finally {
    // 关闭SqlSession
    sqlSession.close();
}

// 获取SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();

try {
    // 查询数据
    User user = sqlSession.selectOne("com.example.YourMapper.getUserById", 1);

    // 处理查询结果
    if (user != null) {
        System.out.println("User ID: " + user.getId());
        System.out.println("User Name: " + user.getName());
        System.out.println("User Age: " + user.getAge());
    }
} finally {
    // 关闭SqlSession
    sqlSession.close();
}

// 获取SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();

try {
    // 创建User对象
    User updatedUser = new User(1, "Updated Name", 30);

    // 更新数据
    sqlSession.update("com.example.YourMapper.updateUser", updatedUser);

    // 提交事务
    sqlSession.commit();
} finally {
    // 关闭SqlSession
    sqlSession.close();
}

// 获取SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();

try {
    // 删除数据
    sqlSession.delete("com.example.YourMapper.deleteUser", 1);

    // 提交事务
    sqlSession.commit();
} finally {
    // 关闭SqlSession
    sqlSession.close();
}

在以上示例中，需要替换com.example.YourMapper为你实际的Mapper接口路径。这里的insertUser、getUserById、updateUser、deleteUser是对应于Mapper接口中的方法。

注意：上述操作在实际应用中应该放在事务中，以保证操作的一致性。可以使用sqlSession.commit()提交事务，也可以通过sqlSession.rollback()回滚事务。最后，记得关闭SqlSession，以释放资源。

1.2 映射器（Mapper）

1.2.1 XML映射文件编写规则

映射器是定义数据库操作的接口，它可以通过XML文件或注解方式编写。XML映射文件通常包括查询、插入、更新、删除等操作的定义：

<!-- YourMapper.xml -->
<mapper namespace="com.example.YourMapper">
    <!-- 查询操作 -->
    <select id="getUserById" resultType="User">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <!-- 插入操作 -->
    <insert id="insertUser">
        INSERT INTO users(name, age) VALUES(#{name}, #{age})
    </insert>
    
    <!-- 其他操作的声明 -->
</mapper>

1.2.2 注解方式定义接口及方法映射

除了XML文件，映射器也可以通过注解方式定义：

// YourMapper.java
public interface YourMapper {
    // 查询操作
    @Select("SELECT * FROM users WHERE id = #{id}")
    User getUserById(int id);

    // 插入操作
    @Insert("INSERT INTO users(name, age) VALUES(#{name}, #{age})")
    void insertUser(User user);

    // 其他操作的声明
}

1.3 POJO对象与结果映射

1.3.1 resultMap标签使用详解

resultMap标签用于定义结果集映射关系，将数据库字段映射到Java对象的属性。例如：

<!-- YourMapper.xml -->
<mapper namespace="com.example.YourMapper">
    <resultMap id="userResultMap" type="User">
        <id property="id" column="user_id"/>
        <result property="name" column="user_name"/>
        <result property="age" column="user_age"/>
    </resultMap>

    <!-- 使用结果映射 -->
    <select id="getUserById" resultMap="userResultMap">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <!-- 其他使用结果映射的SQL语句声明 -->
</mapper>

1.3.2 简单类型与复杂类型的映射处理

MyBatis可以处理简单类型（如基本数据类型、字符串等）和复杂类型（如自定义对象、集合等）的映射。在resultMap中，使用<id>和<result>元素定义映射关系，确保数据库字段和Java对象属性的对应关系。

以上是MyBatis核心组件（SqlSessionFactory和SqlSession）、映射器（Mapper）以及POJO对象与结果映射的详细介绍。通过这些核心组件，你可以进行灵活而强大的数据库操作。

2. MyBatis高级特性

2.1 缓存机制

MyBatis提供了一级缓存和二级缓存两级缓存机制：

2.1.1 一级缓存

一级缓存是SqlSession级别的缓存，它默认开启。在同一个SqlSession中，执行相同的查询，第一次查询的结果会被缓存，后续再执行相同的查询直接从缓存中获取，而不再去数据库查询。

SqlSession sqlSession = sqlSessionFactory.openSession();
try {
    User user1 = sqlSession.selectOne("com.example.YourMapper.getUserById", 1);
    // 第一次查询，从数据库获取数据，并缓存到一级缓存中

    User user2 = sqlSession.selectOne("com.example.YourMapper.getUserById", 1);
    // 第二次查询，直接从一级缓存中获取数据，不再去数据库查询
} finally {
    sqlSession.close();
}

2.1.2 二级缓存

二级缓存是Mapper级别的缓存，多个SqlSession共享同一个Mapper的二级缓存。需要在映射文件中配置开启：

<!-- YourMapper.xml -->
<mapper namespace="com.example.YourMapper" useCache="true">
    <!-- 配置二级缓存 -->
</mapper>

2.2 插件机制

MyBatis的插件机制允许在SQL执行过程中的某一点上插入自定义逻辑。插件需要实现Interceptor接口，并在配置文件中指定插件：

// 自定义插件示例
public class MyPlugin implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 在方法执行前的逻辑
        Object result = invocation.proceed();
        // 在方法执行后的逻辑
        return result;
    }
}

// 在配置文件中配置插件
<plugins>
    <plugin interceptor="com.example.MyPlugin"/>
</plugins>

2.3 动态代理与反射技术

// 定义Mapper接口
public interface YourMapper {
    User getUserById(int id);
}

// Mapper接口的代理对象
YourMapper mapper = sqlSession.getMapper(YourMapper.class);
User user = mapper.getUserById(1);

MyBatis使用动态代理来实现Mapper接口的代理对象，通过代理对象调用方法时，实际执行的是MyBatis内部封装的SQL语句。动态代理的实现借助了Java的反射技术，使得Mapper接口的实现类不需要开发者手动编写。

2.4 数据库连接池的配置与使用

MyBatis本身并不提供数据库连接池，而是依赖于外部的连接池。常见的连接池有Druid、 HikariCP、C3P0等。连接池的配置需要在mybatis-config.xml中进行：

<!-- 数据库连接池的配置 -->
<dataSource type="POOLED">
    <property name="driver" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/your_database"/>
    <property name="username" value="your_username"/>
    <property name="password" value="your_password"/>
</dataSource>

选择合适的数据库连接池可以提高系统性能和资源利用率。

以上是MyBatis高级特性的简要介绍，包括缓存机制、插件机制、动态代理与反射技术以及数据库连接池的配置与使用。这些特性使得MyBatis在灵活性和性能方面都有很好的表现。

3. MyBatis事务管理

3.1 JDBC事务与MyBatis事务的概念与区别

3.1.1 JDBC事务

JDBC事务是指一系列SQL语句组成的操作序列，要么全部执行成功，要么全部执行失败，保持数据库的一致性。JDBC事务通常通过Connection对象的commit和rollback方法进行提交和回滚。

// JDBC事务示例
Connection connection = dataSource.getConnection();
try {
    connection.setAutoCommit(false); // 开启事务

    // 执行一系列SQL操作

    connection.commit(); // 提交事务
} catch (Exception e) {
    connection.rollback(); // 回滚事务
} finally {
    connection.close();
}

3.1.2 MyBatis事务

MyBatis事务是建立在JDBC事务之上的，MyBatis的事务管理是对JDBC事务的封装。MyBatis事务通常由SqlSessionFactory创建的SqlSession对象管理。

3.2 在MyBatis中如何手动控制事务

在MyBatis中，可以通过SqlSession对象的commit和rollback方法手动控制事务。默认情况下，MyBatis的SqlSession是自动提交事务的，如果需要手动控制，可以通过以下方式：

SqlSession sqlSession = sqlSessionFactory.openSession(false); // 手动提交事务
try {
    // 执行一系列MyBatis操作

    sqlSession.commit(); // 提交事务
} catch (Exception e) {
    sqlSession.rollback(); // 回滚事务
} finally {
    sqlSession.close();
}

3.3 Spring整合MyBatis后如何进行事务管理

在Spring中，可以通过DataSourceTransactionManager或JtaTransactionManager等事务管理器来整合MyBatis和Spring的事务管理。以下是一个简单的Spring整合MyBatis并进行事务管理的示例：

3.3.1 配置数据源和SqlSessionFactory

<!-- Spring配置文件 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <!-- 配置数据源信息 -->
</bean>

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mapperLocations" value="classpath*:com/example/mappers/*.xml"/>
</bean>

3.3.2 配置事务管理器

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

3.3.3 配置事务通知

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

3.3.4 配置AOP代理

<aop:config>
    <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.example.YourMapper.*(..))"/>
</aop:config>

通过以上配置，Spring会在MyBatis的Mapper方法上织入事务管理逻辑，使得MyBatis的操作处于一个事务中。在实际项目中，可以根据具体需求进行更灵活的配置。

以上是关于MyBatis事务管理的简要介绍，包括JDBC事务与MyBatis事务的区别、如何手动控制MyBatis事务以及Spring整合MyBatis后如何进行事务管理。事务管理是数据库操作中非常重要的一部分，能够确保数据的一致性和完整性。

4. MyBatis缓存机制

4.1 MyBatis的一级缓存原理与实践

4.1.1 一级缓存原理

MyBatis的一级缓存是SqlSession级别的缓存，它默认开启。在同一个SqlSession中，执行相同的查询，第一次查询的结果会被缓存，后续再执行相同的查询直接从缓存中获取，而不再去数据库查询。

一级缓存的作用域是SqlSession，当SqlSession关闭时，一级缓存也会被清空。

4.1.2 一级缓存实践

SqlSession sqlSession = sqlSessionFactory.openSession();
try {
    User user1 = sqlSession.selectOne("com.example.YourMapper.getUserById", 1);
    // 第一次查询，从数据库获取数据，并缓存到一级缓存中

    User user2 = sqlSession.selectOne("com.example.YourMapper.getUserById", 1);
    // 第二次查询，直接从一级缓存中获取数据，不再去数据库查询
} finally {
    sqlSession.close();
}

4.2 MyBatis的二级缓存配置与使用注意事项

4.2.1 二级缓存原理

MyBatis的二级缓存是Mapper级别的缓存，多个SqlSession共享同一个Mapper的二级缓存。要启用二级缓存，需要在映射文件中配置：

<!-- YourMapper.xml -->
<mapper namespace="com.example.YourMapper" useCache="true">
    <!-- 配置二级缓存 -->
</mapper>

4.2.2 二级缓存使用注意事项

对象需要实现Serializable接口，以便能够被序列化，从而存储到缓存中。
不同SqlSession之间共享缓存，需要注意缓存的有效性。
在进行增删改操作时，会清空相应的Mapper的二级缓存。

SqlSession sqlSession1 = sqlSessionFactory.openSession();
SqlSession sqlSession2 = sqlSessionFactory.openSession();

try {
    // sqlSession1查询，数据存入二级缓存
    User user1 = sqlSession1.selectOne("com.example.YourMapper.getUserById", 1);

    // sqlSession2查询，直接从二级缓存中获取数据
    User user2 = sqlSession2.selectOne("com.example.YourMapper.getUserById", 1);
} finally {
    sqlSession1.close();
    sqlSession2.close();
}

以上是MyBatis缓存机制的简要介绍，包括一级缓存的原理与实践，以及二级缓存的配置与使用注意事项。缓存是提高系统性能和减轻数据库压力的重要手段，但在使用缓存时需要注意缓存的生命周期和清空时机，确保数据的一致性。

在Spring Boot项目中，集成MyBatis是相对简单的，Spring Boot提供了一些自动配置和简化配置的特性，使得整合变得更加便捷。以下是在Spring Boot下快速集成MyBatis的基本步骤：

5. Mybatis与Spring集成

5.1 添加依赖

首先，确保在pom.xml文件中添加MyBatis和Spring Boot相关的依赖：

<!-- MyBatis依赖 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>

<!-- 数据库驱动依赖（以MySQL为例） -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.23</version>
</dependency>

<!-- Spring Boot依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

5.2 配置数据源

在application.properties或application.yml中配置数据源信息：

spring.datasource.url=jdbc:mysql://localhost:3306/your_database
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

5.3 编写Mapper接口和映射文件

创建Mapper接口和对应的映射文件，例如：

// YourMapper.java
public interface YourMapper {
    User getUserById(int id);
}
<!-- YourMapper.xml -->
<mapper namespace="com.example.YourMapper">
    <select id="getUserById" resultType="User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

5.4 配置扫描

在Spring Boot应用的主类上添加@MapperScan注解，配置Mapper接口的扫描路径：

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

5.5 使用Mapper接口

在需要使用Mapper的地方，注入Mapper接口并调用方法即可：

@Service
public class YourService {
    @Autowired
    private YourMapper yourMapper;

    public User getUserById(int id) {
        return yourMapper.getUserById(id);
    }
}

以上步骤完成后，Spring Boot应用就成功集成了MyBatis。Spring Boot会根据依赖和配置自动进行MyBatis的初始化和配置，使得整合变得简洁而方便。