Java MyBatis是什么

Rubypyrrha

已于 2025-05-07 10:21:53 修改

阅读量755

点赞数 26

分类专栏： Java Spring 文章标签： java mybatis 数据库

于 2025-05-07 10:21:06 首次发布

本文链接：https://blog.csdn.net/Rubypyrrha/article/details/147754136

版权

Java 同时被 2 个专栏收录

17 篇文章

订阅专栏

Spring

9 篇文章

订阅专栏

MyBatis是什么？

MyBatis是一个简化了JDBC操作的持久层框架，它在Java对象与数据库之间架起了一座桥梁。通过MyBatis，开发者可以更方便地执行SQL语句、处理结果集，并将结果映射到Java对象中。

MyBatis的特点

半自动化的ORM：与全自动ORM框架（如Hibernate）相比，MyBatis要求开发者手动编写SQL语句，这提供了更高的灵活性和控制力。
高级映射支持：支持复杂的关系映射，例如一对一、一对多等关系类型，使得数据库表之间的关联能够自然地映射到Java对象模型中。
动态SQL：MyBatis允许根据不同的条件动态生成SQL语句，这对构建灵活的数据访问层非常有用。
延迟加载：可以在需要时才加载关联的对象，有助于提高性能。
缓存机制：提供一级缓存和二级缓存，帮助减少数据库访问次数，提升应用性能。

MyBatis是半自动的ORM框架？

MyBatis之所以被认为是半自动的ORM框架，主要是因为它要求开发者自己编写SQL语句。尽管如此，MyBatis还是极大地简化了数据访问层的开发工作。比如，它提供了输入输出映射的功能，让参数设置和结果集封装变得更加简单。此外，MyBatis还支持关联查询和动态SQL等功能，这些都大大提高了开发效率。

相比之下，像Hibernate这样的全自动ORM框架，虽然不需要手动编写SQL语句，但其学习曲线相对较陡，且在某些场景下可能不如MyBatis那样灵活和高效。

总的来说，MyBatis是一款非常适合需要高度定制化SQL的应用程序的框架，它结合了手动编写SQL的灵活性与ORM工具的便利性，适用于各种规模的项目。

缓存机制

MyBatis提供了两种级别的缓存机制，分别是一级缓存（Local Cache）和二级缓存（Second Level Cache）。这两种缓存机制的设计目的是为了提高查询效率，减少数据库访问次数。下面我将详细解释这两种缓存机制的工作原理及其特点。

一级缓存（Local Cache）

作用范围：一级缓存是SqlSession级别的缓存，默认开启，不能关闭。
工作原理：在同一个SqlSession中执行的多次相同查询会被缓存起来。如果在同一个SqlSession中再次执行相同的查询语句，MyBatis会直接从缓存中获取数据，而不会去查询数据库。
生命周期：一级缓存的有效期与SqlSession的生命周期一致，当SqlSession关闭或者commit、rollback时，一级缓存会被清空。

二级缓存（Second Level Cache）

作用范围：二级缓存是Mapper级别的缓存，可以跨SqlSession共享，默认情况下是关闭的，需要手动开启。
工作原理：通过配置<cache/>标签来启用某个Mapper的二级缓存。一旦启用，MyBatis会在多个SqlSession之间共享查询结果。这意味着，即使是在不同的SqlSession中，只要开启了二级缓存并且查询条件相同，MyBatis就会直接从缓存中读取数据而不是再去查询数据库。
生命周期：二级缓存的生命周期比一级缓存更长，它不受SqlSession关闭的影响，只有当应用或特定Mapper被重新加载时才会失效。

缓存使用注意事项

并发问题：虽然缓存能显著提高性能，但在高并发环境下可能会引发脏读等问题。因此，在设计应用时需要考虑到这一点，并采取适当的措施，比如合理设置缓存刷新策略等。
缓存同步：如果您的应用部署在集群环境中，不同节点之间的缓存数据同步也是一个需要考虑的问题。MyBatis本身并不提供跨节点的缓存同步机制，这可能需要依赖第三方解决方案来实现。
选择合适的缓存实现：MyBatis支持多种缓存实现（如Ehcache, Redis等），可以根据项目需求选择最合适的缓存实现方案。

通过合理利用MyBatis的一级和二级缓存，可以在很多场景下有效提升应用的性能表现。不过，需要注意的是，缓存并非适用于所有情况，特别是对于频繁更新的数据，过度依赖缓存可能会带来数据一致性问题。因此，在实际开发中，应该根据具体情况灵活运用缓存机制。

核心注解

MyBatis 提供了多种注解来简化与数据库交互的代码编写，特别是在使用 MyBatis 作为持久层框架时。下面是一些核心的 MyBatis 注解及其简要说明：

@Select

用于定义查询语句。

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

@Insert

用于定义插入语句。

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

@Update

用于定义更新语句。

@Update("UPDATE users SET name=#{name}, email=#{email} WHERE id=#{id}")
void updateUser(User user);

@Delete

用于定义删除语句。

@Delete("DELETE FROM users WHERE id = #{id}")
void deleteUser(int id);

@Results & @Result

用来映射实体类属性到数据库列。@Results 定义结果集，@Result 映射特定字段。

@Results(id = "userResult", value = {
    @Result(property = "name", column = "user_name"),
    @Result(property = "email", column = "user_email")
})
@Select("SELECT * FROM users WHERE id = #{id}")
User getUserById(int id);

@One & @Many

这两个注解用于处理一对一和一对多的关系。它们通常与 @Results 和 @Result 结合使用。

@One 示例：

@Results({
    @Result(property = "address", column = "address_id", one = @One(select = "getAddress"))
})
User getUserWithAddress(int id);

@Many 示例：

@Results({
    @Result(property = "orders", column = "id", many = @Many(select = "listOrdersByUserId"))
})
User getUserWithOrders(int id);

@Mapper

标记接口为 MyBatis 的 Mapper 接口，使其能够被扫描并注册为 Spring Bean。
```
@Mapper
public interface UserMapper {
    // 方法声明
}
```

@Param

当需要在 SQL 语句中引用多个参数时使用此注解为参数命名。

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

这些注解大大简化了 MyBatis 的配置工作，使得开发者可以通过注解直接在 Mapper 接口中定义 SQL 语句，而无需额外的 XML 配置文件。不过，在某些复杂场景下，比如动态 SQL 或者复杂的映射关系，可能仍需结合 XML 来实现更灵活的控制。

核心标签

MyBatis 提供了一系列的标签来帮助开发者构建动态SQL语句。这些标签可以让你基于不同的条件和需求来灵活地构造查询、插入、更新或删除操作。下面是一些常用的MyBatis标签及其基本用法：

1. `<select>`

用于定义查询语句。

应用场景：从数据库中检索数据。

<select id="findUserById" parameterType="int" resultType="User">
    SELECT * FROM users WHERE id = #{id}
</select>

2. `<insert>`

用于定义插入语句。

应用场景：向数据库中添加新记录。

<insert id="insertUser" parameterType="User">
    INSERT INTO users (name, age) VALUES (#{name}, #{age})
</insert>

3. `<update>`

用于定义更新语句。

应用场景：更新数据库中的现有记录。

<update id="updateUser" parameterType="User">
    UPDATE users SET name=#{name}, age=#{age} WHERE id=#{id}
</update>

4. `<delete>`

用于定义删除语句。

应用场景：从数据库中删除记录。

<delete id="deleteUser" parameterType="int">
    DELETE FROM users WHERE id=#{id}
</delete>

5. `<resultMap>`

用于自定义结果映射，特别是当数据库列名与Java对象属性不匹配时。

应用场景：处理复杂的映射关系。

<resultMap id="userResultMap" type="User">
    <id property="id" column="user_id"/>
    <result property="username" column="uname"/>
</resultMap>

6. `<sql>`

用于提取可复用的SQL片段。

应用场景：减少重复代码。

<sql id="userColumns">id, username, password</sql>
<select id="selectUsers" resultMap="userResultMap">
    SELECT <include refid="userColumns"/> FROM users
</select>

7. `<if>`

用于动态SQL构建，根据条件判断是否包含某些SQL片段。

应用场景：实现灵活的查询条件。

<select id="findActiveUsers" parameterType="map" resultType="User">
    SELECT * FROM users
    WHERE active = true
    <if test="minAge != null">
        AND age > #{minAge}
    </if>
</select>

8. `<where>`

用于动态生成 SQL 的 WHERE 子句，可以自动处理 AND 或 OR 开头的问题。

应用场景：当需要根据条件动态添加 WHERE 子句时。

<select id="findUsers" parameterType="map" resultType="User">
    SELECT * FROM users
    <where>
        <if test="name != null">AND name = #{name}</if>
        <if test="age != null">AND age = #{age}</if>
    </where>
</select>

9. `<set>`

用于动态更新语句中的 SET 部分。

应用场景：当需要根据条件动态设置列值时。

<update id="updateUser" parameterType="User">
    UPDATE users
    <set>
        <if test="name != null">username=#{name},</if>
        <if test="age != null">age=#{age},</if>
    </set>
    WHERE id=#{id}
</update>

10. `<foreach>`

用于迭代集合对象，通常用于 IN 条件或者批量插入。

应用场景：当需要对集合进行循环操作时。

<select id="selectUsersByIds" parameterType="list" resultType="User">
    SELECT * FROM users
    WHERE id IN
    <foreach item="item" index="index" collection="list"
             open="(" separator="," close=")">
        #{item}
    </foreach>
</select>

11. `<choose>, <when>, <otherwise>`

这些标签类似于 Java 中的 switch-case-default 结构，用于在多个选项中选择一个执行。

应用场景：实现多条件分支选择。

<select id="findUsersByCondition" parameterType="map" resultType="User">
    SELECT * FROM users
    <where>
        <choose>
            <when test="name != null">name = #{name}</when>
            <when test="email != null">email = #{email}</when>
            <otherwise>status = 'ACTIVE'</otherwise>
        </choose>
    </where>
</select>

12. `<bind>`

用于创建一个变量并绑定到 OGNL 表达式的结果上，方便后续使用。

应用场景：当需要对参数进行预处理时。

<select id="selectUsersByName" parameterType="map" resultType="User">
    <bind name="pattern" value="'%' + name + '%'" />
    SELECT * FROM users WHERE username LIKE #{pattern}
</select>

13. `<cache>`

MyBatis提供了强大的缓存支持，通过在映射文件中配置<cache>标签，可以开启二级缓存（SqlSession之间共享的缓存）。这有助于减少数据库访问次数，提高应用性能。

应用场景：当你希望减少对相同数据的重复查询时。

<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>

eviction：指定缓存回收策略，可选值有LRU, FIFO, SOFT, WEAK等。
flushInterval：刷新间隔时间，单位为毫秒。
size：引用数目限制。
readOnly：是否只读。

简单示例：

下面我将通过一个简单的示例来展示如何在SSM（Spring + Spring MVC + MyBatis）框架中使用MyBatis进行数据库操作。我们将创建一个用户管理模块，包括查询、添加和更新用户的操作。

1. 环境准备

首先，确保你已经配置好了一个基本的SSM项目结构，并且依赖了必要的库，如spring-webmvc, mybatis-spring, mysql-connector-java等。

2. 数据库设计

假设我们有一个名为users的表，结构如下：

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    password VARCHAR(50),
    email VARCHAR(100)
);

3. 实体类与Mapper接口

User.java

public class User {
    private Integer id;
    private String username;
    private String password;
    private String email;

    // Getters and Setters...
}

UserMapper.java

import org.apache.ibatis.annotations.*;

@Mapper
public interface UserMapper {

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

    @Insert("INSERT INTO users(username, password, email) VALUES(#{username}, #{password}, #{email})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    int insert(User user);

    @Update("UPDATE users SET username=#{username}, password=#{password}, email=#{email} WHERE id=#{id}")
    int update(User user);

    @Delete("DELETE FROM users WHERE id =#{id}")
    void deleteById(@Param("id") Integer id);

    @Select("<script>" +
            "SELECT * FROM users" +
            "<where>" +
            "<if test='username != null'> AND username LIKE CONCAT('%', #{username}, '%')</if>" +
            "<if test='email != null'> AND email LIKE CONCAT('%', #{email}, '%')</if>" +
            "</where>" +
            "</script>")
    List<User> findUsersByCondition(@Param("username") String username, @Param("email") String email);
}

4. 动态SQL的应用

在上面的findUsersByCondition方法中，我们使用了MyBatis的动态SQL特性，通过<if>标签根据传入参数是否为空来构建查询条件，实现了灵活的查询功能。

5. 配置文件

需要在applicationContext.xml中配置MyBatis的SqlSessionFactory和扫描Mapper接口。

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

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.mapper"/>
</bean>

6. 测试用例

可以通过编写单元测试或直接在Controller中调用UserMapper的方法来验证功能。

@Autowired
private UserMapper userMapper;

@Test
public void testCRUD() {
    User newUser = new User();
    newUser.setUsername("test");
    newUser.setPassword("123456");
    newUser.setEmail("test@example.com");
    userMapper.insert(newUser);

    User foundUser = userMapper.findById(newUser.getId());
    System.out.println(foundUser);

    foundUser.setEmail("new_email@example.com");
    userMapper.update(foundUser);

    List<User> users = userMapper.findUsersByCondition("test", null);
    System.out.println(users);
}

这个例子展示了如何在SSM框架中集成MyBatis并利用其注解和动态SQL功能实现数据持久化操作。