• 使用MyBatis框架进行关系型数据库操作

    如果您觉得本博客的内容对您有所帮助或启发，请关注我的博客，以便第一时间获取最新技术文章和教程。同时，也欢迎您在评论区留言，分享想法和建议。谢谢支持！​

    I.MyBatis 简介

    MyBatis 是一款开源的 ORM（Object-Relational Mapping，对象关系映射）框架，它可以帮助 Java 开发人员快速地进行数据库操作。MyBatis 的主要特点是将 Java 对象映射到数据库表中，可以通过 XML 或者注解的方式进行 SQL 语句的编写。MyBatis 的核心思想是将 SQL 语句与 Java 代码解耦，使得开发人员可以更加专注于业务逻辑的实现。

    MyBatis 的概念

    1. 映射文件（Mapper XML）：MyBatis 的核心配置文件，其中包含了 SQL 语句的编写和 Java 对象的映射规则。
    2. SqlSessionFactory：MyBatis 的会话工厂，用于创建 SqlSession 对象，每个 SqlSessionFactory 对象都对应一个数据库。
    3. SqlSession：MyBatis 的会话对象，可以完成对数据库的增删改查操作。
    4. 映射接口（Mapper Interface）：定义了操作数据库的方法，通常与 Mapper XML 文件中的 SQL 语句相对应。

    MyBatis 的优点

    1. 灵活性：MyBatis 可以通过 XML 或者注解的方式进行 SQL 语句的编写，可以灵活地适应各种开发场景。
    2. 易于学习：MyBatis 的学习曲线较平缓，可以快速掌握基本用法。
    3. 高性能：MyBatis 采用了预编译的 SQL 语句和二级缓存机制，可以提高数据库访问的效率。
    4. 易于集成：MyBatis 可以与各种主流的 Web 框架进行集成，如 Spring、Spring Boot、Struts2 等。
    5. 易于调试：MyBatis 提供了完善的日志记录机制，可以方便地进行错误排查和性能优化。

    II. MyBatis 的配置

    MyBatis 的配置主要包括数据库连接配置和 MyBatis 的核心配置文件。

    数据库连接配置

    在 MyBatis 中，需要配置数据库连接信息，包括数据库的驱动名称、连接地址、用户名、密码等信息。可以在 MyBatis 的配置文件中通过 properties 元素来配置这些信息，例如：

    1. <properties>
    2.     <property name="jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
    3.     <property name="jdbc.url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8"/>
    4.     <property name="jdbc.username" value="root"/>
    5.     <property name="jdbc.password" value="123456"/>
    6. </properties>

    其中，name 属性表示属性名称，value 属性表示属性值。

    MyBatis 的核心配置文件

    MyBatis 的核心配置文件是指包含了 MyBatis 的基本配置信息和 SQL 映射文件（Mapper XML）路径的文件。MyBatis 的核心配置文件采用 XML 格式，通常命名为 mybatis-config.xml。

    MyBatis 的核心配置文件中包含了以下内容：

    • properties：用于配置数据库连接信息等属性。
    • settings：用于配置 MyBatis 的全局设置，例如缓存开关、懒加载等。
    • typeAliases：用于配置 Java 对象与数据库表之间的映射关系。
    • environments：用于配置 MyBatis 的环境信息，例如数据源的配置。
    • mappers：用于配置 SQL 映射文件的路径和映射器接口。

    以下是一个典型的 MyBatis 核心配置文件的示例：

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    3. <configuration>
    4.     <properties>
    5.         <property name="jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
    6.         <property name="jdbc.url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8"/>
    7.         <property name="jdbc.username" value="root"/>
    8.         <property name="jdbc.password" value="123456"/>
    9.     </properties>
    10.  
    11.     <environments default="development">
    12.         <environment id="development">
    13.             <transactionManager type="JDBC"/>
    14.             <dataSource type="POOLED">
    15.                 <property name="driver" value="${jdbc.driver}"/>
    16.                 <property name="url" value="${jdbc.url}"/>
    17.                 <property name="username" value="${jdbc.username}"/>
    18.                 <property name="password" value="${jdbc.password}"/>
    19.             </dataSource>
    20.         </environment>
    21.     </environments>
    22.  
    23.     <mappers>
    24.         <mapper resource="com/example/mapper/UserMapper.xml"/>
    25.     </mappers>
    26. </configuration>

    其中，environments 元素用于配置 MyBatis 的环境信息，可以配置多个环境，每个环境都对应一个数据源。mappers 元素用于配置 SQL 映射文件的路径和映射器接口，可以通过 resource 或者 class 属性来指定映射文件的位置或者映射器接口的类路径。

    III. MyBatis 的使用

    MyBatis 的基本操作

    MyBatis 的基本操作主要包括增删改查四种操作。可以通过 MyBatis 的 SQL 映射文件（Mapper XML）或者注解方式来实现这些操作。以下是一个 MyBatis 的基本操作示例：

    1. // 使用 MyBatis 的 SQL 映射文件实现查询操作
    2. public List getUserList() {
    3.     SqlSession sqlSession = MyBatisUtil.getSqlSession();
    4.     List userList = sqlSession.selectList("com.example.mapper.UserMapper.getUserList");
    5.     sqlSession.close();
    6.     return userList;
    7. }
    8.  
    9. // 使用 MyBatis 的注解方式实现查询操作
    10. @Select("SELECT * FROM user")
    11. public List getUserList();
    12.  
    13. // 使用 MyBatis 的注解方式实现插入操作
    14. @Insert("INSERT INTO user(id, name, age) VALUES(#{id}, #{name}, #{age})")
    15. public int addUser(User user);
    16.  
    17. // 使用 MyBatis 的注解方式实现更新操作
    18. @Update("UPDATE user SET name=#{name}, age=#{age} WHERE id=#{id}")
    19. public int updateUser(User user);
    20.  
    21. // 使用 MyBatis 的注解方式实现删除操作
    22. @Delete("DELETE FROM user WHERE id=#{id}")
    23. public int deleteUser(int id);

    SQL 语句的编写

    MyBatis 支持多种 SQL 语句编写方式，包括使用 MyBatis 的 SQL 映射文件、注解方式和 XML 配置方式等。SQL 语句可以使用参数占位符（#{}）来表示参数，也可以使用动态 SQL 来实现复杂的 SQL 语句编写。以下是一个使用 MyBatis 的 SQL 映射文件编写 SQL 语句的示例：

    1. <!-- 查询所有用户 -->
    2. <select id="getUserList" resultType="com.example.model.User">
    3.     SELECT * FROM user
    4. </select>
    5.  
    6. <!-- 插入用户 -->
    7. <insert id="addUser" parameterType="com.example.model.User">
    8.     INSERT INTO user(id, name, age) VALUES(#{id}, #{name}, #{age})
    9. </insert>
    10.  
    11. <!-- 更新用户 -->
    12. <update id="updateUser" parameterType="com.example.model.User">
    13.     UPDATE user SET name=#{name}, age=#{age} WHERE id=#{id}
    14. </update>
    15.  
    16. <!-- 删除用户 -->
    17. <delete id="deleteUser" parameterType="int">
    18.     DELETE FROM user WHERE id=#{id}
    19. </delete>

    MyBatis 的注解方式

    MyBatis 支持使用注解来实现 SQL 语句的编写和映射器接口的定义。使用注解方式可以减少编写 XML 配置文件的工作量，并且使代码更加简洁和易于维护。以下是一个使用 MyBatis 注解方式实现 SQL 语句编写的示例：

    1. @Mapper
    2. public interface UserMapper {
    3.  
    4.     // 查询所有用户
    5.     @Select("SELECT * FROM user")
    6.     List getUserList();
    7.  
    8.     // 插入用户
    9.     @Insert("INSERT INTO user(id, name, age) VALUES(#{id}, #{name}, #{age})")
    10.     int addUser(User user);
    11.     
    12.     @Update("UPDATE user SET name=#{name}, age=#{age} WHERE id=#{id}")
    13.     int updateUser(User user);
    14.  
    15.     // 删除用户
    16.     @Delete("DELETE FROM user WHERE id=#{id}")
    17.     int deleteUser(int id);
    18. }

    总的来说，MyBatis 的使用相对来说比较简单，可以通过 SQL 映射文件、注解方式或者 XML 配置方式来实现 SQL 语句的编写和执行。在使用 MyBatis 进行开发时，可以根据具体的业务需求来选择最适合的方式进行开发。

    IV. MyBatis 的高级应用

    MyBatis 的动态 SQL

    动态 SQL 是指根据条件动态生成 SQL 语句的技术。MyBatis 提供了强大的动态 SQL 功能，可以通过使用 if、choose、when、otherwise、foreach 等元素来实现动态 SQL 语句的编写。

    if 元素可以根据条件动态生成 SQL 片段，语法如下：

    1. <select id="getUserList" resultType="User">
    2.   SELECT * FROM user WHERE
    3.   <if test="name != null">
    4.     name = #{name}
    5.   </if>
    6.   <if test="age != null">
    7.     AND age = #{age}
    8.   </if>
    9. </select>

    在上面的示例中，如果传入的参数 name 不为空，则会生成 WHERE name = #{name} 的 SQL 片段，如果传入的参数 age 不为空，则会生成 AND age = #{age} 的 SQL 片段。

    choose、when、otherwise 元素可以根据条件选择不同的 SQL 片段，语法如下：

    1. <select id="getUserList" resultType="User">
    2.   SELECT * FROM user
    3.   <where>
    4.     <choose>
    5.       <when test="name != null">
    6.         name = #{name}
    7.       </when>
    8.       <when test="age != null">
    9.         age = #{age}
    10.       </when>
    11.       <otherwise>
    12.         status = 1
    13.       </otherwise>
    14.     </choose>
    15.   </where>
    16. </select>

    在上面的示例中，如果传入的参数 name 不为空，则会生成 name = #{name} 的 SQL 片段，如果传入的参数 age 不为空，则会生成 age = #{age} 的 SQL 片段，如果都为空，则会生成 status = 1 的 SQL 片段。

    foreach 元素可以遍历集合、数组等类型的参数，并将每个元素作为 SQL 片段的一部分，语法如下：

    1. <update id="updateUsers" parameterType="Map">
    2.   update user
    3.   <set>
    4.     <foreach collection="users" item="user" separator=",">
    5.       name = #{user.name}, age = #{user.age}
    6.     </foreach>
    7.   </set>
    8.   where id in
    9.   <foreach collection="ids" item="id" open="(" close=")" separator=",">
    10.     #{id}
    11.   </foreach>
    12. </update>

    在上面的示例中，参数 Map 中包含了 users 和 ids 两个键值对，其中 users 是一个 User 对象的集合，ids 是一个 Integer 数组。foreach 元素遍历 users 集合，将每个 User 对象的 name 和 age 属性作为 SET 子句的一部分；然后遍历 ids 数组，将每个元素作为 IN 子句的一部分。最终生成的 SQL 语句类似于：

    update user set name = 'Alice', age = 20 where id in (1, 2, 3)

    MyBatis 的多表关联

    在实际的开发中，经常需要使用多表关联来查询数据。MyBatis 提供了多种实现多表关联的方式，包括嵌套查询、联合查询和存储过程等。以下是一个使用 MyBatis 嵌套查询的示例：

    1. <!-- 根据用户 id 查询用户信息和订单信息 -->
    2. <select id="getUserAndOrdersById" resultMap="userAndOrdersResultMap">
    3.     SELECT * FROM user
    4.     WHERE id = #{id}
    5. </select>
    6.  
    7. <resultMap id="userAndOrdersResultMap" type="com.example.model.User">
    8.     <id property="id" column="id"/>
    9.     <result property="name" column="name"/>
    10.     <result property="age" column="age"/>
    11.     <collection property="orders" ofType="com.example.model.Order">
    12.         <id property="id" column="order_id"/>
    13.         <result property="name" column="order_name"/>
    14.         <result property="price" column="order_price"/>
    15.     </collection>
    16. </resultMap>

    MyBatis 的缓存机制

    MyBatis 提供了多种缓存机制来提高查询效率，包括一级缓存和二级缓存。一级缓存是指 MyBatis 的内置缓存机制，它是基于 SqlSession 实例的缓存机制，只在同一个 SqlSession 实例中有效。二级缓存是指 MyBatis 的全局缓存机制，它是基于 Mapper 映射器的缓存机制，可在多个 SqlSession 实例之间共享。以下是一个启用 MyBatis 二级缓存的示例：

    2. <settings>
    3.     <setting name="cacheEnabled" value="true"/>
    4. settings>
    5.  
    7. <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

    MyBatis 的批处理：

    MyBatis 提供了批处理功能，可以在一次数据库连接中执行多个 SQL 语句，从而提高数据库的操作效率。以下是一个使用 MyBatis 批处理的示例：

    1. // 批量插入用户
    2. public int insertUsers(List<User> userList) {
    3.     try (SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
    4.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    5.         int count = 0;
    6.         for (User user : userList) {
    7.             userMapper.insertUser(user);
    8.             count++;
    9.             if (count % 1000 == 0) {
    10.                 sqlSession.flushStatements();
    11.             }
    12.         }
    13.         sqlSession.flushStatements();
    14.         return count;
    15.     }
    16. }

    MyBatis 的插件机制

    MyBatis 的插件机制可以通过自定义插件来扩展 MyBatis 的功能，比如实现 SQL 语句拦截、参数处理、结果处理等。以下是一个使用 MyBatis 插件机制的示例：

    1. // 自定义 MyBatis 插件
    2. @Intercepts({
    3.         @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
    4. })
    5. public class CustomPlugin implements Interceptor {
    6.     @Override
    7.     public Object intercept(Invocation invocation) throws Throwable {
    8.         // 实现拦截逻辑
    9.         return invocation.proceed();
    10.     }
    11. }
    12.  
    13. // 注册自定义 MyBatis 插件
    14. @MapperScan("com.example.mapper")
    15. @Configuration
    16. public class MyBatisConfig {
    17.     @Bean
    18.     public CustomPlugin customPlugin() {
    19.         return new CustomPlugin();
    20.     }
    21. }

    V. MyBatis 与 SpringBoot 的整合

    SpringBoot 整合 MyBatis 的基本配置

    在 Spring Boot 中使用 MyBatis，需要添加以下依赖：

    1. <dependency>
    2.     <groupId>org.mybatis.spring.boot</groupId>
    3.     <artifactId>mybatis-spring-boot-starter</artifactId>
    4.     <version>${mybatis.version}</version>
    5. </dependency>

    其中 ${mybatis.version} 是 MyBatis 的版本号。

    在 application.properties 文件中配置 MyBatis 的基本信息：

    1. # 数据库驱动类
    2. spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
    3. # 数据库连接地址
    4. spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=Asia/Shanghai
    5. # 数据库用户名
    6. spring.datasource.username=root
    7. # 数据库密码
    8. spring.datasource.password=123456
    9.  
    10. # MyBatis 的配置文件路径
    11. mybatis.config-location=classpath:mybatis-config.xml
    12. # MyBatis 的 Mapper 文件路径
    13. mybatis.mapper-locations=classpath:mapper/*.xml

    上述配置文件中，配置了数据库的连接信息，以及 MyBatis 的配置文件和 Mapper 文件的路径。

    SpringBoot 整合 MyBatis 的高级配置

    在 SpringBoot 中，可以通过配置文件对 MyBatis 进行更高级的配置。

    首先，在 application.properties 文件中添加 MyBatis 相关配置：

    1. # 数据库配置
    2. spring.datasource.url=jdbc:mysql://localhost:3306/test
    3. spring.datasource.username=root
    4. spring.datasource.password=root
    5.  
    6. # MyBatis 配置
    7. mybatis.config-location=classpath:mybatis-config.xml
    8. mybatis.mapper-locations=classpath:mapper/*.xml
    9. mybatis.type-aliases-package=com.example.demo.entity

    其中，mybatis.config-location 指定了 MyBatis 的核心配置文件，mybatis.mapper-locations 指定了 Mapper 文件所在的目录，mybatis.type-aliases-package 指定了实体类所在的包。

    然后，创建 mybatis-config.xml 配置文件，可以在其中配置插件、拦截器、类型别名等：

    1. <configuration>
    2.     
    3.     <typeAliases>
    4.         <package name="com.example.demo.entity"/>
    5.     typeAliases>
    6.     
    7.     
    8.     <plugins>
    9.         <plugin interceptor="com.example.demo.interceptor.MyInterceptor">
    10.             <property name="property1" value="value1"/>
    11.             <property name="property2" value="value2"/>
    12.         plugin>
    13.     plugins>
    14.     
    15.     
    16.     <objectFactory type="org.mybatis.spring.factory.SpringObjectFactory"/>
    17.     
    18.     
    19. configuration>

    在上面的例子中，配置了一个自定义的插件 MyInterceptor，并设置了两个属性。

    最后，可以在 MyInterceptor 中实现自定义的拦截逻辑：

    1. public class MyInterceptor implements Interceptor {
    2.     private String property1;
    3.     private String property2;
    4.  
    5.     @Override
    6.     public Object intercept(Invocation invocation) throws Throwable {
    7.         // 拦截逻辑
    8.     }
    9.  
    10.     @Override
    11.     public Object plugin(Object target) {
    12.         return Plugin.wrap(target, this);
    13.     }
    14.  
    15.     @Override
    16.     public void setProperties(Properties properties) {
    17.         // 属性设置
    18.     }
    19. }

    以上就是 SpringBoot 整合 MyBatis 的高级配置的示例。

    VI. MyBatis 的错误排查

    常见错误排查方法

    1. 查看错误信息：MyBatis 会将异常信息输出到控制台，可以查看异常信息中的提示信息。
    2. 检查 SQL 语句：如果 SQL 语句有语法错误或逻辑错误，会导致 SQL 执行异常，可以检查 SQL 语句是否正确。
    3. 检查 Mapper 文件：如果 Mapper 文件找不到或配置错误，会导致 MyBatis 执行异常，可以检查 Mapper 文件是否存在，以及是否配置正确。
    4. 检查配置文件：如果配置文件有误，也会导致 MyBatis 执行异常，可以检查配置文件是否存在，以及是否配置正确。

    MyBatis 的日志记录

    为了更好地排查 MyBatis 的错误，可以开启 MyBatis 的日志记录功能。MyBatis 提供了四种日志记录的实现：

    1. SLF4J：可以使用 SLF4J 日志记录框架来记录 MyBatis 的日志。
    2. Log4j：可以使用 Log4j 日志记录框架来记录 MyBatis 的日志。
    3. Log4j2：可以使用 Log4j2 日志记录框架来记录 MyBatis 的日志。
    4. JDK Logging：可以使用 JDK Logging 日志记录框架来记录 MyBatis 的日志。
    SLF4J

    最常用的是 SLF4J 日志记录框架。可以在 pom.xml 文件中添加如下依赖：

    1. <dependency>
    2.     <groupId>org.slf4j</groupId>
    3.     <artifactId>slf4j-api</artifactId>
    4.     <version>2.0.0-alpha1</version>
    5. </dependency>
    6. <dependency>
    7.     <groupId>org.slf4j</groupId>
    8.     <artifactId>slf4j-simple</artifactId>
    9.     <version>2.0.0-alpha1</version>
    10.     <scope>test</scope>
    11. </dependency>

    然后，在 application.properties 文件中添加日志记录相关的配置：

    1. # 日志记录配置
    2. logging.level.org.apache.ibatis=debug
    3. logging.level.java.sql.Connection=debug

    其中，logging.level.org.apache.ibatis=debug 表示将 MyBatis 的日志记录级别设置为 debug，logging.level.java.sql.Connection=debug 表示将 JDBC 连接的日志记录级别设置为 debug。

    开启日志记录后，可以更清晰地查看 MyBatis 的执行过程和 SQL 语句的执行情况，更方便排查错误。

    Log4j

    除了 SLF4J 日志记录框架之外，还可以使用 Log4j 和 Log4j2 日志记录框架来记录 MyBatis 的日志。在使用 Log4j 或 Log4j2 时，需要在 pom.xml 文件中添加相应的依赖：

    1. <dependency>
    2.     <groupId>org.apache.logging.log4j</groupId>
    3.     <artifactId>log4j-slf4j-impl</artifactId>
    4.     <version>2.14.1</version>
    5. </dependency>
    6. <dependency>
    7.     <groupId>org.apache.logging.log4j</groupId>
    8.     <artifactId>log4j-core</artifactId>
    9.     <version>2.14.1</version>
    10. </dependency>

    Log4j2：

    1. <dependency>
    2.     <groupId>org.apache.logging.log4j</groupId>
    3.     <artifactId>log4j-slf4j18-impl</artifactId>
    4.     <version>2.14.1</version>
    5. </dependency>
    6. <dependency>
    7.     <groupId>org.apache.logging.log4j</groupId>
    8.     <artifactId>log4j-core</artifactId>
    9.     <version>2.14.1</version>
    10. </dependency>

    然后，在 application.properties 文件中添加日志记录相关的配置：

    Log4j：

    1. # 日志记录配置
    2. log4j.rootLogger=debug,stdout
    3. log4j.logger.org.apache.ibatis=debug
    4. log4j.logger.java.sql.Connection=debug
    5.  
    6. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    7. log4j.appender.stdout.Target=System.out
    8. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    9. log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

    Log4j2：

    1. # 日志记录配置
    2. logger.MyBatis.name=org.apache.ibatis
    3. logger.MyBatis.level=debug
    4. logger.jdbc.name=java.sql.Connection
    5. logger.jdbc.level=debug
    6.  
    7. appender.stdout.type=Console
    8. appender.stdout.name=STDOUT
    9. appender.stdout.layout.type=PatternLayout
    10. appender.stdout.layout.pattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
    11.  
    12. rootLogger.level=info
    13. rootLogger.appenderRef.stdout.ref=STDOUT
    14. rootLogger.loggerRef.MyBatis.ref=MyBatis
    15. rootLogger.loggerRef.jdbc.ref=jdbc

    在这些配置中，都配置了日志记录的级别以及输出格式等相关信息。配置完成后，就可以使用 Log4j 或 Log4j2 来记录 MyBatis 的日志信息。

    VII. 实例演示

    通过 MyBatis 操作关系型数据库

    1、创建一个 Java 项目并添加 MyBatis 依赖。

    在 ​​pom.xml​​ 文件中添加 MyBatis 的依赖：

    1. <dependencies>
    2.     <!-- MyBatis -->
    3.     <dependency>
    4.         <groupId>org.mybatis</groupId>
    5.         <artifactId>mybatis</artifactId>
    6.         <version>3.5.7</version>
    7.     </dependency>
    8.     
    9.     <!-- 数据库连接池 -->
    10.     <dependency>
    11.         <groupId>com.alibaba</groupId>
    12.         <artifactId>druid</artifactId>
    13.         <version>1.2.6</version>
    14.     </dependency>
    15.  
    16.     <!-- MySQL 驱动 -->
    17.     <dependency>
    18.         <groupId>mysql</groupId>
    19.         <artifactId>mysql-connector-java</artifactId>
    20.         <version>8.0.27</version>
    21.     </dependency>
    22. </dependencies>

    其中，​​mybatis​​​ 是 MyBatis 的核心依赖，​​druid​​​ 是数据库连接池，​​mysql-connector-java​​ 是 MySQL 驱动。

    2、配置数据库连接，配置 MyBatis 的核心配置文件。

    首先是数据库连接的配置，在 ​​application.properties​​​ 或 ​​application.yml​​ 文件中添加以下配置：

    1. spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
    2. spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    3. spring.datasource.username=root
    4. spring.datasource.password=root

    其中，​​driverClassName​​​ 是数据库驱动类名，​​url​​​ 是数据库连接地址，​​username​​​ 是数据库用户名，​​password​​​ 是数据库密码。这里的示例是连接本地的 MySQL 数据库，端口号是 3306，数据库名是 ​​mydatabase​​。

    接下来是 MyBatis 的核心配置文件，在 ​​resources​​​ 目录下创建一个 ​​mybatis-config.xml​​ 文件，并添加以下内容：

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    3.  
    4. <configuration>
    5.     <!-- 配置数据源 -->
    6.     <environments default="development">
    7.         <environment id="development">
    8.             <transactionManager type="JDBC"/>
    9.             <dataSource type="POOLED">
    10.                 <property name="driver" value="${spring.datasource.driverClassName}" />
    11.                 <property name="url" value="${spring.datasource.url}" />
    12.                 <property name="username" value="${spring.datasource.username}" />
    13.                 <property name="password" value="${spring.datasource.password}" />
    14.             </dataSource>
    15.         </environment>
    16.     </environments>
    17.     
    18.     <!-- 配置 MyBatis 插件 -->
    19.     <plugins>
    20.         <plugin interceptor="com.github.pagehelper.PageInterceptor">
    21.             <property name="helperDialect" value="mysql"/>
    22.             <property name="reasonable" value="true"/>
    23.             <property name="supportMethodsArguments" value="true"/>
    24.             <property name="params" value="count=countSql"/>
    25.         </plugin>
    26.     </plugins>
    27. </configuration>

    其中，​​environments​​​ 标签用来配置数据源，这里使用了 Spring Boot 的自带数据源，同时也配置了 MyBatis 插件 ​​pagehelper​​，用于实现分页查询。此外，还可以配置多个数据源，用于不同环境的切换。

    3、创建实体类，对应数据库中的表结构。

    创建一个实体类，例如命名为 ​​User​​，该类中的字段应该和数据库表中的字段一一对应，示例如下：

    1. public class User {
    2.     private int id;
    3.     private String name;
    4.     private int age;
    5.     private String email;
    6.     private String phone;
    7.  
    8.     // getter 和 setter 方法
    9. }

    其中，​​id​​​ 字段对应表中的主键，需要有对应的 ​​getter​​​ 和 ​​setter​​​ 方法。​​name​​​ 和 ​​age​​​ 分别对应表中的 ​​name​​​ 和 ​​age​​ 字段。需要注意的是，这里的字段命名需要和数据库表中的字段命名保持一致。

    4、创建 Mapper 接口，定义对应的增删改查方法。

    创建一个 Mapper 接口，例如命名为 ​​UserMapper​​，该接口中定义了对应的增删改查方法，示例如下：

    1. public interface UserMapper {
    2.     User getUserById(int id);
    3.  
    4.     List getAllUsers();
    5.  
    6.     int addUser(User user);
    7.  
    8.     int updateUser(User user);
    9.  
    10.     int deleteUser(int id);
    11. }

    其中，​​getUserById​​​ 方法根据传入的 ​​id​​​ 参数获取一条用户记录，返回一个 ​​User​​​ 对象。​​getAllUsers​​​ 方法返回所有用户记录的列表，返回值类型为 ​​List​​​。​​addUser​​​ 方法向表中插入一条用户记录，传入一个 ​​User​​​ 对象作为参数，返回插入记录的数量。​​updateUser​​​ 方法更新一条用户记录，传入一个 ​​User​​​ 对象作为参数，返回更新记录的数量。​​deleteUser​​​ 方法删除一条用户记录，传入 ​​id​​ 参数作为删除条件，返回删除记录的数量。

    需要注意的是，这里的方法命名和参数命名需要和 Mapper 文件中的 SQL 语句保持一致，便于后续的映射关系配置。

    5、编写 Mapper 对应的映射文件，对应 SQL 语句的编写。

    下面是一个 ​​UserMapper​​ 接口对应的映射文件示例：

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    3.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    4. <mapper namespace="com.example.mapper.UserMapper">
    5.  
    6.     <resultMap id="userResultMap" type="com.example.entity.User">
    7.         <id column="id" property="id"/>
    8.         <result column="name" property="name"/>
    9.         <result column="age" property="age"/>
    10.         <result column="email" property="email"/>
    11.         <result column="phone" property="phone"/>
    12.     </resultMap>
    13.  
    14.     <select id="getUserById" resultMap="userResultMap">
    15.         SELECT * FROM users WHERE id = #{id}
    16.     </select>
    17.  
    18.     <select id="getAllUsers" resultMap="userResultMap">
    19.         SELECT * FROM users
    20.     </select>
    21.  
    22.     <insert id="addUser" parameterType="com.example.entity.User">
    23.         INSERT INTO users (name, age, email, phone)
    24.         VALUES (#{name}, #{age}, #{email}, #{phone})
    25.     </insert>
    26.  
    27.     <update id="updateUser" parameterType="com.example.entity.User">
    28.         UPDATE users
    29.         SET name = #{name}, age = #{age}, email = #{email}, phone = #{phone}
    30.         WHERE id = #{id}
    31.     </update>
    32.  
    33.     <delete id="deleteUser">
    34.         DELETE FROM users WHERE id = #{id}
    35.     </delete>
    36.  
    37. </mapper>

    在映射文件中，首先指定了命名空间 ​​namespace​​​，这里需要和 ​​UserMapper​​ 接口的全名保持一致。

    接着定义了一个 ​​resultMap​​​ 元素，用来将查询结果映射成 ​​User​​​ 对象。​​resultMap​​​ 的 ​​id​​​ 属性为 ​​userResultMap​​​，​​type​​​ 属性指定映射的目标类型为 ​​com.example.entity.User​​​。在 ​​resultMap​​​ 中，通过 ​​id​​​ 元素将表中的 ​​id​​​ 字段映射到 ​​User​​​ 对象的 ​​id​​​ 属性，通过 ​​result​​ 元素将其他字段映射到对应的属性上。

    随后，分别定义了 ​​select​​​、​​insert​​​、​​update​​​ 和 ​​delete​​​ 元素，分别对应 ​​UserMapper​​​ 接口中的对应方法。这里通过 SQL 语句实现了增删改查的功能。其中 ​​parameterType​​​ 属性指定了方法参数的类型，​​resultMap​​ 属性指定了查询结果的映射关系。

    6、在代码中调用 Mapper 接口中的方法，实现对数据库的操作。

    下面是一个示例代码，用于演示如何在代码中调用 Mapper 接口中的方法，实现对数据库的操作：

    1. public class MyBatisDemo {
    2.     public static void main(String[] args) {
    3.         // 创建 MyBatis 的 SqlSessionFactory 对象
    4.         SqlSessionFactory sqlSessionFactory = null;
    5.         try {
    6.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
    7.         } catch (IOException e) {
    8.             e.printStackTrace();
    9.         }
    10.  
    11.         // 创建 MyBatis 的 SqlSession 对象
    12.         SqlSession sqlSession = sqlSessionFactory.openSession();
    13.  
    14.         try {
    15.             // 获取 Mapper 接口的代理对象
    16.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    17.  
    18.             // 插入用户
    19.             User user = new User();
    20.             user.setId(1L);
    21.             user.setName("张三");
    22.             userMapper.insertUser(user);
    23.  
    24.             // 查询用户
    25.             User queryUser = userMapper.getUserById(1L);
    26.             System.out.println("查询用户结果：" + queryUser);
    27.  
    28.             // 更新用户
    29.             queryUser.setName("李四");
    30.             userMapper.updateUser(queryUser);
    31.  
    32.             // 删除用户
    33.             userMapper.deleteUser(1L);
    34.  
    35.             // 提交事务
    36.             sqlSession.commit();
    37.         } catch (Exception e) {
    38.             // 出现异常时回滚事务
    39.             sqlSession.rollback();
    40.             e.printStackTrace();
    41.         } finally {
    42.             // 关闭 SqlSession 对象
    43.             sqlSession.close();
    44.         }
    45.     }
    46. }

    在上述代码中，首先创建了 MyBatis 的 SqlSessionFactory 对象，然后通过 SqlSessionFactory 对象创建了 SqlSession 对象。接着获取了 Mapper 接口的代理对象，并通过代理对象调用了增删改查等方法。最后提交事务并关闭 SqlSession 对象。

    通过 MyBatis 进行事务操作

    1、配置数据源和事务管理器

    在 MyBatis 中，需要配置一个事务管理器来进行事务控制。通常情况下，我们可以使用 Spring 框架提供的事务管理器来进行配置。在 SpringBoot 中，可以直接使用 ​​spring-boot-starter-jdbc​​​ 或 ​​spring-boot-starter-data-jpa​​ 等 starter 来快速集成数据库和事务管理器。

    2、配置事务代理

    在 MyBatis 中，事务代理是用于拦截 Mapper 接口方法并开启事务的类。可以通过在 ​​SqlSession​​​ 中设置 ​​ExecutorType​​ 来指定事务代理的类型。例如：

    SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH, false);
    3、配置事务注解

    可以使用 MyBatis 提供的 ​​@Transactional​​​ 注解来实现事务控制。在 Mapper 接口方法上加上 ​​@Transactional​​ 注解，即可将该方法划分为一个事务单元。在事务单元中，如果发生了异常，则整个事务将会被回滚。

    1. @Transactional
    2. int updatePerson(Person person);
    4、编写事务处理代码

    编写事务处理代码，例如：

    1. @Transactional
    2. public void updatePerson(Person person) {
    3.     try {
    4.         // 更新操作1
    5.         personMapper.updatePerson1(person);
    6.         // 更新操作2
    7.         personMapper.updatePerson2(person);
    8.         // 更新操作3
    9.         personMapper.updatePerson3(person);
    10.         // 手动抛出异常，模拟事务回滚
    11.         throw new RuntimeException("模拟事务回滚");
    12.     } catch (Exception e) {
    13.         log.error("updatePerson error", e);
    14.         throw new RuntimeException("updatePerson error", e);
    15.     }
    16. }

    在上述代码中，通过 ​​@Transactional​​​ 注解将 ​​updatePerson​​ 方法划分为一个事务单元。在事务单元中，执行了三个更新操作，同时手动抛出了一个异常。如果执行过程中发生了异常，整个事务将被回滚，即三个更新操作都会被撤销。

    以上是使用 MyBatis 进行事务操作的基本步骤，需要注意的是，在进行事务操作时，一定要遵循 ACID 原则，保证事务的正确性和完整性。

    MyBatis 是一个强大的 ORM 框架，可以帮助开发者快速地进行数据库操作。通过本文的介绍，读者可以掌握 MyBatis 的基本原理、使用方法以及高级应用技巧，同时还能了解到 MyBatis 与 SpringBoot 的整合以及常见错误排查方法。通过实例演示，读者还可以深入了解 MyBatis 的实际应用。​

    如果您觉得本博客的内容对您有所帮助或启发，请关注我的博客，以便第一时间获取最新技术文章和教程。同时，也欢迎您在评论区留言，分享想法和建议。谢谢支持！

  • 相关阅读:
    笑看k8s基础存储卷妙用
    可替代角雷达，这款纯固态补盲激光雷达什么来头？
    ubuntu安装配置svn
    关于PsGetProcessImageFileName获取结果不全的问题
    进程与线程
    JDK -- Stream使用
    P - Balanced Stone Heaps
    像素间的关系
    Docker网络模型
    难以理解：摄像头APP，我测试好好的，发给别人就用不了
  • 原文地址：https://blog.csdn.net/bairo007/article/details/133376405