MyBatis框架基础教程.zip

最新推荐文章于 2024-09-26 13:53:35 发布

如水蜜

最新推荐文章于 2024-09-26 13:53:35 发布

阅读量1.2k

点赞数 27

本文链接：https://blog.csdn.net/weixin_31569663/article/details/141906503

版权

本文还有配套的精品资源，点击获取

简介：MyBatis是一个高效的Java持久层框架，它简化了JDBC操作，提供SQL定制、存储过程支持和对象映射功能。该教程面向初学者，涵盖了从配置、映射文件编写到事务管理的MyBatis核心概念。通过实践操作，学习者将掌握如何实现CRUD操作，参数与结果映射，以及如何与Spring框架集成。第一个mybatis.zip

1. MyBatis框架简介与优势

简介

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

优势

MyBatis 的优势在于其灵活性和可定制性，它允许开发者编写 SQL 语句，通过 XML 或注解的方式灵活映射各种复杂类型。MyBatis 通过接口和映射文件的方式将 SQL 执行和数据传递解耦，简化了数据库操作层的编码工作。与原始 JDBC 相比，MyBatis 提供的缓存机制以及灵活的 SQL 执行能力，使得其在处理大量数据时显得更加高效和方便。

2. SQL映射文件与Mapper接口

2.1 SQL映射文件的编写与调用

2.1.1 映射文件的基本结构

SQL映射文件是MyBatis中定义SQL语句和映射规则的核心组件。一个典型的映射文件包括以下基本结构：

<mapper> 根元素：包含命名空间（namespace）属性，用于唯一标识映射文件。
<select> 、 <insert> 、 <update> 、 <delete> 元素：对应不同类型的SQL语句。
<resultMap> 元素：定义了从数据库结果集到Java对象属性的映射规则。

<mapper namespace="com.example.mapper.UserMapper">
    <!-- 定义SQL语句 -->
    <select id="selectUser" resultType="com.example.domain.User">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <!-- 定义结果集映射规则 -->
    <resultMap id="userMap" type="com.example.domain.User">
        <id property="id" column="user_id" />
        <result property="username" column="user_name" />
        <!-- 其他属性映射 -->
    </resultMap>
</mapper>

2.1.2 核心SQL元素详解

在映射文件中，核心的SQL元素主要包括：

#{} 与 ${} ： #{} 是预编译语句，可以防止SQL注入，而 ${} 是直接字符串拼接，用于处理动态表名或列名等。
parameterType ：指定方法的参数类型。
resultType 或 resultMap ：指定结果集类型或引用已定义的映射规则。
databaseId ：针对不同数据库提供不同SQL语句。
keyProperty 、 order 、 resultMap ：用于 <insert> 和 <update> 操作中的主键返回和主键生成策略。

2.2 Mapper接口的定义与作用

2.2.1 接口绑定的技术原理

Mapper接口是MyBatis的一个核心概念，它提供了一种优雅的方式来编写SQL映射代码。接口绑定的原理是将接口的方法名和映射文件中的SQL语句ID进行绑定。通过动态代理机制，MyBatis在运行时生成接口的动态代理实例，并将方法调用转化为相应的SQL执行。

public interface UserMapper {
    User selectUser(int id);
}

2.2.2 接口映射的高级用法

MyBatis还支持一些高级映射用法，例如：

多个参数的传递：MyBatis允许使用 @Param 注解为参数命名，或直接按顺序传递参数。
动态SQL与接口方法的结合：可以将动态SQL片段与接口方法结合使用，实现复杂的查询逻辑。
结果集映射与类型处理器：自定义 TypeHandler 来处理Java类型和JDBC类型之间的转换。

@Select("SELECT * FROM users WHERE id = #{id} AND name = #{name}")
User selectUserByIdAndName(@Param("id") int id, @Param("name") String name);

通过这种方式，MyBatis将开发者从繁琐的JDBC操作中解放出来，使代码更加简洁且易于维护。接口映射提供了一种类型安全的方式来调用SQL语句，减少了运行时错误的可能性，并提高了开发效率。

以上内容涵盖MyBatis映射文件与Mapper接口的基础知识、核心技术和高级用法。下一章将探讨MyBatis的配置与动态SQL的编写与应用。

3. MyBatis配置与动态SQL

3.1 MyBatis全局配置文件设置

3.1.1 配置文件的必备元素

MyBatis 的全局配置文件通常命名为 mybatis-config.xml ，它位于应用的类路径中。配置文件中定义了 MyBatis 的运行环境、事务管理器、数据源等关键属性，是整个框架运行的基础。

配置文件包含一些必备的元素，如 <environments> 、 <mappers> 等：

<environments> 定义了 MyBatis 所需的运行环境，一般至少包含一个 <environment> 子节点。
<transactionManager> 指定事务管理器的类型，可以是 JDBC 或者 MANAGED。
<dataSource> 指定数据源类型，可以是 UNPOOLED、POOLED 或 JNDI。
<mappers> 用于指定映射文件或 Mapper 接口的路径。

下面展示了一个简单的 MyBatis 配置文件：

<configuration>
  <properties resource="db.properties"/>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="mappers/UserMapper.xml"/>
    <mapper resource="mappers/OrderMapper.xml"/>
  </mappers>
</configuration>

3.1.2 环境配置与优化策略

环境配置是指定 MyBatis 如何与数据库交互的过程。合理配置环境能够有效提升应用性能。

事务管理器 ：可以选择 JDBC 原生事务管理或者交给容器管理。
数据源 ：MyBatis 支持不同的数据源实现。POOLED 数据源可以利用池化机制缓存数据库连接，减少频繁的创建和销毁连接带来的性能损耗。UNPOOLED 数据源每次请求都创建新的连接，适用于连接使用不频繁的场景。

配置文件中的优化策略：

使用缓存来减少对数据库的直接访问，例如 MyBatis 内置的一级缓存和二级缓存。
配置合适的日志输出，便于问题追踪和性能调优，如使用 Log4j。
利用 <settings> 元素调整 MyBatis 的行为，比如开启延迟加载可以提高性能。
针对批量操作，合理配置批量操作的大小和事务大小。

3.2 动态SQL的编写与应用

3.2.1 SQL片段与include的使用

动态 SQL 是 MyBatis 的强大功能之一，允许在 SQL 中加入条件、循环、分支等逻辑，从而实现更加灵活的 SQL 编写。MyBatis 通过在 XML 映射文件中定义 SQL 片段来实现这一功能。

使用 <sql> 标签可以定义 SQL 片段，而 <include> 标签则用于引入这些片段。这种方式提高了 SQL 的可重用性和清晰度。

例如：

<sql id="Base_Column_List">
  id, name, email
</sql>

<select id="selectUsers" resultType="User">
  SELECT 
    <include refid="Base_Column_List"/>
  FROM users
  <where>
    <if test="name != null">
      name = #{name}
    </if>
    <if test="email != null">
      AND email = #{email}
    </if>
  </where>
</select>

上面的 <sql> 标签定义了一个基本的列列表，而 <select> 语句则通过 <include> 标签引用了这个列表。这种方式使得 SQL 代码更加模块化。

3.2.2 动态SQL的构造技巧

构造动态 SQL 通常需要使用一系列的标签，如 <if> , <choose> , <when> , <otherwise> , <foreach> 等，来实现逻辑判断和循环处理。

<select id="selectUsersByCondition" resultType="User">
  SELECT * FROM users
  <where>
    <if test="name != null and name != ''">
      AND name LIKE CONCAT('%', #{name}, '%')
    </if>
    <if test="email != null and email != ''">
      AND email LIKE CONCAT('%', #{email}, '%')
    </if>
    <if test="id != null">
      AND id = #{id}
    </if>
  </where>
</select>

在上面的例子中， <where> 标签会在内部至少有一个条件成立时才会生成 WHERE 关键字。利用 <if> 标签可以实现条件查询。

对于批量操作，使用 <foreach> 标签可以实现对集合或者数组的遍历：

<update id="updateUsersBatch">
  UPDATE users
  <set>
    name = CASE
      <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
        WHEN id = #{item.id} THEN #{item.name}
      </foreach>
    </set>
  </set>
  WHERE id IN
  <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
    #{item.id}
  </foreach>
</update>

这段代码会对列表中的每个用户对象进行更新。当批量更新时，它会生成一个动态的 IN 子句，包含所有用户 ID。

通过动态 SQL，MyBatis 能够应对各种复杂的数据库查询和更新需求，极大地提高了开发的灵活性和效率。然而，动态 SQL 的编写需要仔细设计，以避免安全风险（如 SQL 注入）并确保查询效率。

4. 事务管理与参数传递

4.1 事务管理的两种方式

4.1.1 声明式事务管理

在使用MyBatis进行数据持久化操作时，事务管理是保证数据一致性和完整性的关键。MyBatis支持两种事务管理方式：声明式和编程式。

声明式事务管理提供了一种方式，允许开发者通过配置而非硬编码的方式管理事务。这种方式的优点在于其与业务代码解耦，使得事务管理更加清晰和易于管理。通常情况下，我们会在Spring框架中通过AOP（面向切面编程）实现声明式事务管理。

为了在Spring中实现声明式事务管理，首先需要在配置文件中开启事务管理器，并配置事务管理器的属性，例如：

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

<tx:annotation-driven transaction-manager="transactionManager" />

接下来，我们可以使用 @Transactional 注解在服务层方法上声明事务边界。该注解告诉Spring框架，方法需要被事务管理。以下是一个例子：

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void addUser(User user) {
        // 添加用户操作...
    }

    // 其他业务方法...
}

在上述代码中， addUser 方法会运行在一个事务中。如果方法内部出现异常，则整个事务将回滚；如果执行成功，则提交事务。

4.1.2 编程式事务管理

另一种管理MyBatis事务的方式是编程式事务管理，这种方式涉及到更多底层代码的编写。在编程式事务管理中，开发者必须在代码中显式地管理事务的开启、提交和回滚。

在MyBatis中使用原生JDBC时，可以手动控制事务：

Connection connection = dataSource.getConnection();
try {
    connection.setAutoCommit(false); // 关闭自动提交

    // 执行数据库操作...
    userMapper.addUser(user);

    ***mit(); // 提交事务
} catch (Exception e) {
    connection.rollback(); // 回滚事务
} finally {
    connection.close(); // 关闭连接
}

使用Spring时，则可以利用其提供的 PlatformTransactionManager 来管理事务：

@Autowired
private TransactionTemplate transactionTemplate;

public void addUserWithTransaction(User user) {
    transactionTemplate.execute(new TransactionCallbackWithoutResult() {
        protected void doInTransactionWithoutResult(TransactionStatus status) {
            // 添加用户操作...
        }
    });
}

这种方式的优点在于它提供了更大的灵活性，但是缺点是它会使业务代码更加复杂。

4.2 参数对象的传递方式

4.2.1 参数的内置处理机制

MyBatis在处理SQL语句的参数时，拥有一个非常灵活的机制。它不仅支持单个参数的传递，还支持多参数、参数映射和参数对象的传递。

当传递单个参数时，MyBatis会默认将该参数传入到SQL语句中。然而，当需要传递多个参数时，MyBatis提供了一系列的内置规则来处理这些参数。

例如，可以使用 @Param 注解在方法参数前指定一个参数名：

public User findUserByIdAndName(@Param("id") int id, @Param("name") String name);

在SQL映射文件中，可以通过 ${id} 和 ${name} 引用这些参数：

<select id="findUserByIdAndName" resultType="User">
    SELECT * FROM users WHERE id = ${id} AND name = #{name}
</select>

这里， ${id} 是参数的直接值传递，而 #{name} 则会被预处理以避免SQL注入。

4.2.2 自定义参数解析

除了内置的参数处理机制，MyBatis也允许开发者自定义参数解析的逻辑。例如，可以通过实现 TypeHandler 接口来自定义参数的封装和解析过程。

以下是一个简单的 TypeHandler 实现示例，用于处理时间类型的参数：

public class CustomDateTypeHandler extends BaseTypeHandler<Date> {
    @Override
    public void setParameter(PreparedStatement ps, int i, Date parameter, JdbcType jdbcType) throws SQLException {
        if (parameter != null) {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            ps.setString(i, sdf.format(parameter));
        } else {
            ps.setNull(i, Types.VARCHAR);
        }
    }

    // 其他重载方法...
}

使用此 TypeHandler 需要在MyBatis配置文件中注册：

<typeHandlers>
    <typeHandler handler="com.example.CustomDateTypeHandler"/>
</typeHandlers>

这样，在SQL映射文件中使用日期类型的参数时，就会应用我们自定义的处理逻辑。

5. MyBatis核心机制解析

MyBatis作为一个优秀的持久层框架，其核心机制的设计决定了其性能和灵活性。本章节我们将深入分析MyBatis的核心机制，包括ResultMap与自动映射机制、以及MyBatis的缓存机制。

5.1 ResultMap与自动映射机制

ResultMap是MyBatis中一个重要的概念，它允许开发者自定义SQL查询结果到Java对象的映射关系。理解ResultMap的工作原理能够帮助我们更好地控制数据的转换过程，解决一些复杂的查询映射问题。

5.1.1 ResultMap的工作原理

ResultMap的创建基于XML配置或注解的方式，它们定义了SQL查询结果列和Java对象属性之间的映射关系。ResultMap主要由以下几个部分组成：

id：ResultMap的唯一标识符。
type：ResultMap映射的Java类型。
constructor：当使用带参构造器创建对象时，可以在这里指定如何通过列值创建对象实例。
id和result元素：分别用于映射主键列和非主键列到Java对象的属性。
association：用于映射关联对象。
collection：用于映射关联集合。
discriminator：类似于Java中的switch语句，根据列值的不同选择不同的映射规则。

在ResultMap中可以非常灵活地控制属性的映射，包括属性名称不匹配、别名处理、类型转换、嵌套结果映射等。

接下来，我们将通过一个具体的例子来展示ResultMap的定义和使用：

<resultMap id="userResultMap" type="User">
    <id property="id" column="user_id" jdbcType="INTEGER"/>
    <result property="username" column="user_name" jdbcType="VARCHAR"/>
    <result property="password" column="hashed_password" jdbcType="VARCHAR"/>
    <collection property="posts" ofType="Post" column="user_id" select="selectPostsForUser"/>
</resultMap>

在这个例子中，我们定义了一个ResultMap userResultMap ，它映射了 User 对象和查询结果。其中 id 和 result 元素定义了基本属性的映射规则，而 collection 元素定义了关联集合的映射规则。

public class User {
    private int id;
    private String username;
    private String password;
    private List<Post> posts;
    // getters and setters
}

5.1.2 自定义结果集映射

在实际应用中，可能会遇到数据表结构与Java对象结构不一致的情况，这时候就需要通过自定义ResultMap来解决。自定义ResultMap提供了非常强大的数据映射能力，可以帮助我们精确控制查询结果到对象属性的映射过程。

例如，假设 User 和 UserPreferences 是两个不同的类，它们代表用户的个人信息和偏好设置，但它们的数据是存储在同一个数据表中，我们可以这样定义ResultMap：

<resultMap id="userWithPreferencesMap" type="User">
    <id property="id" column="id"/>
    <result property="name" column="name"/>
    <result property="email" column="email"/>
    <association property="userPreferences" javaType="UserPreferences">
        <result property="theme" column="theme"/>
        <result property="language" column="language"/>
    </association>
</resultMap>

在上述的ResultMap中，我们通过 association 元素映射了 User 和 UserPreferences 之间的关联关系，通过这种方式，即使数据库中的数据是存储在同一个表中，我们也能把它们清晰地映射到两个不同的Java对象中。

5.2 MyBatis缓存机制理解

MyBatis支持一级缓存（本地缓存）和二级缓存（全局缓存），其中一级缓存是每个SQLSession自己私有的，而二级缓存则是可以多个SQLSession共享的。缓存的使用能够显著提升数据操作的性能，尤其是在读操作远远多于写操作的应用中。

5.2.1 缓存级别与作用域

一级缓存的作用域限定在单个SQLSession内部。当一个SQLSession被创建时，它会同时创建此会话的一级缓存，SQLSession的所有查询都会先尝试从缓存中获取数据。只有当缓存中没有数据时，才会从数据库中进行数据读取操作，并将查询结果存入一级缓存。当SQLSession关闭或者调用清空方法时，一级缓存将被清空。

二级缓存的作用域则是更宽泛的，它能够跨多个SQLSession共享数据。为了启用二级缓存，需要在MyBatis配置文件中进行设置，同时被缓存的映射器(Mapper)的SQL操作需要被标记为可缓存的。二级缓存是通过映射器(Mapper)来实现的，因此它能跨多个SQLSession共享。每个数据库映射的映射器(Mapper)可以被配置为使用二级缓存。

5.2.2 缓存策略与性能优化

MyBatis的缓存策略是可配置的，开发者可以根据实际情况定制缓存行为，以达到最优的性能表现。缓存策略包括：

flushInterval ：定义自动刷新缓存的时间间隔（以毫秒为单位）。
size ：设置缓存中可以容纳的数据项的数量。
readWrite ：指定缓存是否支持并发读写。
eviction ：定义缓存的回收策略。

举个例子，在MyBatis的全局配置文件 mybatis-config.xml 中，我们可以设置二级缓存的全局属性：

<configuration>
    <settings>
        <setting name="cacheEnabled" value="true"/>
        <setting name="localCacheScope" value="SESSION"/>
        <setting name="cacheEvictionPolicy" value="LRU"/>
    </settings>
    ...
</configuration>

在这个配置中， cacheEnabled 设置为 true 表示二级缓存开启， localCacheScope 设置为 SESSION 表示启用一级缓存。 cacheEvictionPolicy 设置为 LRU 表示使用最近最少使用（Least Recently Used）策略清除缓存。

<cache eviction="LRU" flushInterval="60000" size="512" readWrite="true"/>

在映射器(Mapper)配置文件中，我们还可以对每个缓存单独配置：

<cache ... />

合理配置缓存能够有效减少数据库的读取次数，提升系统的性能，但同时也要注意缓存的一致性问题和潜在的内存占用问题。在使用缓存时，需要根据数据更新频率和读写操作比例来合理选择缓存策略，以及定期评估缓存的性能影响，确保系统的稳定性和可靠性。

在实际开发中，如果需要进一步自定义缓存策略，可以通过实现 org.apache.ibatis.cache.Cache 接口来创建自己的缓存实现，并通过 cache 标签在MyBatis的配置文件中进行配置。

以上，我们对MyBatis的核心机制进行了解析，包括ResultMap与自动映射机制和缓存机制，深入探讨了它们的工作原理和应用方法。通过掌握这些高级特性，开发者能够更好地利用MyBatis框架优化数据操作性能，实现更加高效的数据持久层处理。

6. MyBatis整合与拓展应用

6.1 MyBatis与Spring框架整合

MyBatis与Spring的整合可以让开发者以更加优雅的方式管理数据库事务和实现依赖注入，从而简化了数据访问层的代码编写。整合的关键在于配置和理解两者如何协同工作。

6.1.1 集成配置要点

在Spring中整合MyBatis需要几个关键步骤：

引入Spring和MyBatis的依赖，通常使用Maven或Gradle等构建工具来管理这些依赖。
配置数据源（DataSource），这可以是内置的数据源，也可以是外部配置的例如DBCP、C3P0或HikariCP等。
配置MyBatis的SqlSessionFactoryBean，用于生产SqlSession。
将SqlSessionFactoryBean作为一个bean配置在Spring的applicationContext.xml中。
如果需要使用Mapper接口，需要配置MapperScannerConfigurer来扫描指定包下的Mapper接口。

示例配置如下：

<!-- 数据源配置 -->
<bean id="dataSource" class="***mons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydatabase"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
</bean>

<!-- SqlSessionFactory配置 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="typeAliasesPackage" value="com.example.model"/>
</bean>

<!-- Mapper接口扫描配置 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.mapper"/>
</bean>

6.1.2 Spring事务管理与MyBatis的协同

在Spring框架中，可以使用声明式事务管理来控制MyBatis操作的事务。通过配置@Transactional注解或在XML文件中定义事务属性来实现。

// 在Service层使用@Transactional控制事务
@Transactional
public void updateProduct(Product product) {
    productMapper.updateProduct(product);
}

6.2 自定义插件与TypeHandler

MyBatis的扩展性极强，可以通过自定义插件和TypeHandler来满足特定需求。

6.2.1 自定义插件的开发流程

自定义插件可以通过实现 Interceptor 接口来开发。插件可以拦截的方法有Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed), ParameterHandler (getParameterObject, setParameters), ResultSetHandler (handleResultSets, handleOutputParameters), andStatementHandler (prepare, parameterize, batch, update, query)。

自定义插件开发步骤如下：

创建一个类实现 Interceptor 接口。
使用 @Intercepts 注解指定拦截哪些方法。
实现 intercept 方法，在其中编写拦截逻辑。
在MyBatis配置中注册该插件。

示例代码：

@Intercepts({@Signature(method = "prepare", type = StatementHandler.class, args = {Connection.class})})
public class MyFirstPlugin implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        return invocation.proceed();
    }
    @Override
    public void setProperties(Properties properties) {
    }
}

然后在MyBatis的配置文件中注册插件：

<plugins>
    <plugin interceptor="com.example.MyFirstPlugin"/>
</plugins>

6.2.2 TypeHandler的作用与实现

TypeHandler负责Java类型和数据库中JDBC类型之间的映射和转换。MyBatis自带了许多TypeHandler，但在一些复杂场景下，可能需要自定义TypeHandler。

实现TypeHandler需要继承 BaseTypeHandler<T> 并重写四个方法： setParameter , setParameter , getResult , getResult 。

示例代码：

@MappedJdbcTypes(JdbcType.VARCHAR)
@MappedTypes(String.class)
public class CustomStringTypeHandler extends BaseTypeHandler<String> {
    @Override
    public void setParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
        ps.setString(i, parameter);
    }

    @Override
    public String getResult(ResultSet rs, String columnName) throws SQLException {
        return rs.getString(columnName);
    }
}

在MyBatis的配置文件中注册自定义TypeHandler：

<typeHandlers>
    <typeHandler handler="com.example.CustomStringTypeHandler"/>
</typeHandlers>

6.3 CRUD操作实现

CRUD操作是MyBatis中数据持久化操作的基础，开发者可通过Mapper接口和注解或XML配置文件来实现。

6.3.1 基础CRUD操作解析

基础的CRUD操作通常在Mapper接口中定义，MyBatis通过动态代理生成实现类，然后通过SqlSession调用这些方法。

一个简单的Mapper接口和对应的MyBatis XML映射文件可能如下所示：

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

<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectUserById" resultType="com.example.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
    <insert id="insertUser">
        INSERT INTO users(name, age) VALUES(#{name}, #{age})
    </insert>
    <update id="updateUser">
        UPDATE users SET name=#{name}, age=#{age} WHERE id=#{id}
    </update>
    <delete id="deleteUser">
        DELETE FROM users WHERE id=#{id}
    </delete>
</mapper>

6.3.2 高级CRUD操作技巧

高级CRUD操作包括分页查询、批量操作、动态SQL等。通过在Mapper接口中添加方法声明，然后在XML文件中定义相应的SQL语句。

例如，实现一个分页查询：

public interface UserMapper {
    List<User> selectUserByPage(int pageNum, int pageSize);
}

<select id="selectUserByPage" resultType="com.example.model.User">
    SELECT * FROM users LIMIT #{start}, #{pageSize}
</select>

这里， ${start} 和 ${pageSize} 是通过计算得到的，分页查询需要在调用时传递正确的参数值：

int pageNum = 1;
int pageSize = 10;
int start = (pageNum - 1) * pageSize;
List<User> users = userMapper.selectUserByPage(start, pageSize);

在高级操作中，MyBatis的动态SQL功能尤为强大，它允许根据不同的条件动态生成不同的SQL片段，从而实现复杂的查询逻辑。

本文还有配套的精品资源，点击获取

简介：MyBatis是一个高效的Java持久层框架，它简化了JDBC操作，提供SQL定制、存储过程支持和对象映射功能。该教程面向初学者，涵盖了从配置、映射文件编写到事务管理的MyBatis核心概念。通过实践操作，学习者将掌握如何实现CRUD操作，参数与结果映射，以及如何与Spring框架集成。

本文还有配套的精品资源，点击获取

如水蜜

关注

27
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫