MyBatis

合集 - 面试题(15)
1.Java集合2.JVM3.多线程4.IO5.web编程6.Spring7.面试真题8.SpringBoot9.Spring Cloud10.MySQL（数据库）11.Redis（缓存）12.分布式
13.MyBatis
14.Linux15.java基础
收起

MyBatis

1、MyBatis 是什么框架？

MyBatis 是一个持久层框架，它是 Java 编程语言中用于操作关系型数据库的一个工具。MyBatis 的主要作用是简化数据库访问的过程，提供了一种方便、灵活的方式来进行 SQL 操作。相比传统的 JDBC 编程方式，MyBatis 可以更加高效地管理数据库连接、执行 SQL 语句、处理结果集等。

MyBatis 主要有以下特点和优势：

  1. 简化 SQL 开发：MyBatis 使用 XML 或注解配置 SQL 语句，提供了一种直观、简洁的方式来定义和管理 SQL，降低了 SQL 开发的复杂度。

  2. 灵活性：MyBatis 支持动态 SQL、复杂查询、参数映射、结果集映射等功能，具有很高的灵活性，适用于各种复杂的数据库操作场景。

  3. 性能优化：MyBatis 提供了一系列的性能优化策略，如预编译 SQL、缓存机制、延迟加载等，可以有效提升数据库操作的性能。

  4. 与 Spring、Spring Boot 集成：MyBatis 可以与 Spring 框架无缝集成，通过 Spring 的 IoC 容器管理 MyBatis 的 Mapper、SqlSessionFactory 等对象，简化了配置和使用。

  5. 支持插件扩展：MyBatis 提供了插件机制，可以通过自定义插件来扩展框架的功能，满足不同项目的需求。

总体来说，MyBatis 是一个功能强大、灵活性高的持久层框架，在实际项目开发中广泛应用于数据库操作和数据访问的场景。

2、MyBatis 和 ORM 的区别？

MyBatis 和 ORM（Object-Relational Mapping，对象关系映射）是两种不同的持久化框架，它们有一些区别：

  1. 数据映射方式：

    • MyBatis：MyBatis 是一种半自动化的数据映射方式。开发者需要手动编写 SQL 语句，并通过 XML 文件或注解将 SQL 语句与 Java 对象进行映射。
    • ORM：ORM 框架则是完全自动化的数据映射方式。开发者不需要编写 SQL 语句，只需要定义好实体类和关系映射，ORM 框架会自动将 Java 对象和数据库表进行映射。

  2. 灵活性：

    • MyBatis：MyBatis 提供了较高的灵活性，开发者可以灵活地控制 SQL 语句的编写和执行过程，对 SQL 进行优化和定制。
    • ORM：ORM 框架对于 SQL 的执行过程相对较为封闭，开发者不能直接干预 SQL 的生成和优化过程，只能通过框架提供的接口进行操作。

  3. 性能优化：

    • MyBatis：MyBatis 提供了一些性能优化策略，如预编译 SQL、缓存机制等，开发者可以针对具体的场景进行性能优化。
    • ORM：ORM 框架通常会自动生成 SQL，有一定的性能损耗，但也提供了一些缓存和批量操作等功能来优化性能。

  4. 使用场景：

    • MyBatis：适合对 SQL 语句有较高控制需求的项目，例如需要复杂查询、性能优化、特定数据库特性的应用。
    • ORM：适合对数据库交互较为简单的项目，例如基本的 CRUD 操作、关联查询等。

总体来说，MyBatis 更加注重灵活性和对 SQL 的控制，适合需要精细调优和特定 SQL 特性的应用；而 ORM 框架则更加自动化，适合对数据库交互相对简单的应用。

3、MyBatis 为什么是半自动 ORM 映射？

MyBatis 被称为半自动 ORM（Object-Relational Mapping，对象关系映射）映射框架，这是因为它在数据映射方面相比全自动的 ORM 框架有一些区别和特点：

  1. 手动编写 SQL：MyBatis 要求开发者手动编写 SQL 语句，而不是像全自动的 ORM 框架那样完全由框架自动生成 SQL。这使得开发者对 SQL 语句有更高的控制权，可以针对具体场景进行 SQL 优化和定制化。

  2. XML 或注解配置：在 MyBatis 中，数据映射可以通过 XML 文件或者注解进行配置。XML 配置文件中定义了 SQL 语句和结果映射规则，而注解则可以直接在 Java 实体类上标注 SQL 相关的配置。

  3. SQL 和 Java 对象的映射：MyBatis 通过 XML 文件或者注解将 SQL 语句和 Java 对象进行映射，但是具体的 SQL 编写需要开发者自行完成。这种映射方式相对于全自动 ORM 框架更加灵活，可以针对不同的需求进行定制化。

  4. 灵活性和控制权：由于开发者需要手动编写 SQL，因此 MyBatis 提供了较高的灵活性和控制权。开发者可以根据实际情况优化 SQL、使用数据库特定的特性以及实现复杂的查询逻辑。

综上所述，MyBatis 之所以被称为半自动 ORM 映射框架，是因为它在数据映射方面提供了一定程度的自动化，同时也允许开发者手动控制 SQL 的编写和执行过程，具有较高的灵活性和定制化能力。

4、MyBatis 框架的应用场景？

MyBatis 框架适用于各种规模的应用程序开发，特别是对于需要灵活控制 SQL 语句、数据库操作以及复杂查询的项目，MyBatis 提供了许多便利和特性：

  1. 定制化 SQL 操作：MyBatis 允许开发者手动编写 SQL 语句，可以灵活地定制和优化 SQL 查询，适用于需要高性能 SQL 操作的场景。

  2. 复杂查询需求：对于需要进行复杂查询、多表关联查询或者使用数据库特定特性的项目，MyBatis 提供了灵活的 XML 配置和注解方式，可以方便地实现这些复杂查询逻辑。

  3. 数据映射控制：MyBatis 允许开发者灵活地控制数据映射规则，可以将查询结果映射到 Java 对象的指定属性中，实现数据对象的定制化映射。

  4. 存储过程支持：MyBatis 支持调用存储过程进行数据库操作，可以方便地与存储过程进行交互和集成。

  5. 轻量级框架：相对于全自动 ORM 框架，MyBatis 是一个轻量级的框架，学习成本低，易于上手，同时提供了较高的灵活性和可控性。

  6. 与 Spring 等框架集成：MyBatis 可以与各种 Java 框架集成，如 Spring、Spring Boot 等，便于开发者在项目中统一管理和调用数据库操作。

综上所述，MyBatis 框架适用于需要灵活控制 SQL 操作、数据映射以及复杂查询的项目，特别是对于一些需要高性能 SQL 查询和数据库操作的应用场景。

5、MyBatis 有哪些优点？

MyBatis 框架有以下几个优点：

  1. 灵活性：MyBatis 允许开发者手动编写 SQL 语句，可以根据具体需求灵活控制 SQL 查询和数据库操作，适用于各种复杂的查询和特定的数据库操作需求。

  2. 性能优化：由于可以手动优化 SQL 查询语句，MyBatis 在性能优化方面具有优势，可以针对具体场景进行优化，提高数据库查询效率。

  3. 可读性：MyBatis 使用 XML 配置或者注解方式进行 SQL 映射，使得 SQL 语句和 Java 代码分离，提高了代码的可读性和可维护性。

  4. 数据映射控制：MyBatis 提供了灵活的数据映射控制方式，可以将查询结果映射到 Java 对象的指定属性中，实现数据对象的定制化映射。

  5. 与存储过程兼容：MyBatis 支持调用存储过程进行数据库操作，可以方便地与存储过程进行交互和集成。

  6. 轻量级框架：相对于全自动 ORM 框架，MyBatis 是一个轻量级的框架，学习成本低，易于上手，同时提供了较高的灵活性和可控性。

  7. 与 Spring 等框架集成：MyBatis 可以与各种 Java 框架集成，如 Spring、Spring Boot 等，便于开发者在项目中统一管理和调用数据库操作。

总体来说，MyBatis 具有灵活性高、性能优化、可读性好、数据映射控制强、与存储过程兼容以及轻量级等优点，适用于需要灵活控制 SQL 操作、数据映射以及复杂查询的项目。

6、MyBatis 有哪些缺点？

MyBatis 虽然有许多优点，但也存在一些缺点：

  1. 手动维护 SQL：虽然可以灵活控制 SQL，但也需要开发者手动编写和维护大量的 SQL 语句，增加了开发和维护成本。

  2. 学习曲线：相比于全自动 ORM 框架，MyBatis 需要开发者具备一定的 SQL 和 XML/注解配置知识，学习曲线相对较高。

  3. 代码冗余：由于需要手动编写 SQL 语句和映射配置，可能会导致代码冗余，尤其是对于简单的 CRUD 操作。

  4. 数据库移植性差：由于 SQL 语句是手动编写的，不同数据库的 SQL 语法和特性不同，可能需要针对不同数据库做适配。

  5. 不支持实体关系映射：相比于全自动 ORM 框架，MyBatis 不支持实体之间的关系映射，需要手动处理对象之间的关联关系。

  6. 不适合小型项目：对于简单的增删改查操作，使用 MyBatis 可能会显得过于繁琐，不够简洁高效。

  7. 缺乏自动化维护：相比于全自动 ORM 框架，MyBatis 缺乏自动化的数据库结构维护功能，需要开发者手动维护数据库表结构和映射配置。

综上所述，MyBatis 的缺点主要体现在需要手动编写 SQL 和配置映射信息、学习曲线较高、不支持实体关系映射以及对小型项目不够友好等方面。在选择使用 MyBatis 时，需要根据具体项目需求和团队技术水平权衡其优缺点。

7、MyBatis 和 Hibernate 的区别？

MyBatis 和 Hibernate 是两种不同的持久化框架，它们在设计理念、工作方式和适用场景等方面有一些明显的区别：

  1. 工作方式：

    • MyBatis：MyBatis 是一种基于 SQL 的持久化框架，开发者需要手动编写 SQL 语句和映射配置文件（或注解），通过 SQL 进行数据库操作。
    • Hibernate：Hibernate 是一种全自动 ORM（对象关系映射）框架，可以自动生成 SQL 语句，并通过对象和数据库表之间的映射关系进行数据库操作。

  2. 映射配置：

    • MyBatis：MyBatis 使用 XML 文件或注解来配置对象和数据库表之间的映射关系，开发者可以灵活控制 SQL 的编写和执行。
    • Hibernate：Hibernate 通过 Java 注解或 XML 文件来配置对象和数据库表之间的映射关系，支持更多的 ORM 特性，如实体关系映射（One-to-One、One-to-Many、Many-to-Many 等）。

  3. SQL 控制：

    • MyBatis：开发者可以手动编写 SQL 语句，可以更灵活地控制 SQL 的编写和执行，适合对 SQL 语句有较高要求的开发者。
    • Hibernate：Hibernate 是全自动 ORM 框架，可以自动生成 SQL 语句，开发者无需编写 SQL，适合对 SQL 要求不高，希望通过对象来操作数据库的开发者。

  4. 学习曲线：

    • MyBatis：相比于 Hibernate，MyBatis 的学习曲线相对较低，因为开发者可以直接操作 SQL，不需要掌握复杂的 ORM 映射关系。
    • Hibernate：Hibernate 的学习曲线较高，需要掌握复杂的 ORM 映射关系和持久化操作。

  5. 适用场景：

    • MyBatis：适合对 SQL 有较高要求、需要灵活控制 SQL 执行、对 ORM 映射关系要求不高的项目。
    • Hibernate：适合对 SQL 要求不高、希望通过对象操作数据库、需要复杂的 ORM 映射关系的项目。

总的来说，MyBatis 更适合对 SQL 有较高要求、需要灵活控制 SQL 执行的项目，而 Hibernate 更适合对 SQL 要求不高、希望通过对象操作数据库的项目。选择使用哪种框架需要根据具体项目需求和开发团队的技术水平来决定。

8、MyBatis 和 JPA 的区别？

MyBatis 和 JPA（Java Persistence API）是两种不同的持久化框架，它们在设计理念、工作方式和适用场景等方面有一些明显的区别：

  1. 工作方式：

    • MyBatis：MyBatis 是一种基于 SQL 的持久化框架，开发者需要手动编写 SQL 语句和映射配置文件（或注解），通过 SQL 进行数据库操作。
    • JPA：JPA 是 Java EE 的一部分，它是一种基于 ORM 的持久化框架，开发者不需要直接编写 SQL，而是通过对象和数据库表之间的映射关系来进行数据库操作。

  2. 映射配置：

    • MyBatis：MyBatis 使用 XML 文件或注解来配置对象和数据库表之间的映射关系，开发者可以灵活控制 SQL 的编写和执行。
    • JPA：JPA 通过 Java 注解或 XML 文件来配置对象和数据库表之间的映射关系，提供了更高级的 ORM 特性，如实体关系映射（One-to-One、One-to-Many、Many-to-Many 等）。

  3. SQL 控制：

    • MyBatis：开发者可以手动编写 SQL 语句，可以更灵活地控制 SQL 的编写和执行，适合对 SQL 语句有较高要求的开发者。
    • JPA：JPA 是全自动 ORM 框架，可以自动生成 SQL 语句，开发者无需编写 SQL，适合对 SQL 要求不高，希望通过对象来操作数据库的开发者。

  4. 学习曲线：

    • MyBatis：相比于 JPA，MyBatis 的学习曲线相对较低，因为开发者可以直接操作 SQL，不需要掌握复杂的 ORM 映射关系。
    • JPA：JPA 的学习曲线较高，需要掌握复杂的 ORM 映射关系和持久化操作。

  5. 适用场景：

    • MyBatis：适合对 SQL 有较高要求、需要灵活控制 SQL 执行、对 ORM 映射关系要求不高的项目。
    • JPA：适合对 SQL 要求不高、希望通过对象操作数据库、需要复杂的 ORM 映射关系的项目。

总的来说，MyBatis 更适合对 SQL 有较高要求、需要灵活控制 SQL 执行的项目，而 JPA 更适合对 SQL 要求不高、希望通过对象操作数据库的项目。选择使用哪种框架需要根据具体项目需求和开发团队的技术水平来决定。

9、MyBatis 有哪几种 SQL 编写形式？

MyBatis 提供了多种 SQL 编写形式，主要包括以下几种：

  1. XML 形式：使用 XML 文件编写 SQL 语句和映射配置。XML 形式的优点是结构清晰，易于维护，可以灵活控制 SQL 的编写和执行。

示例：

<!-- SQL 配置文件 -->
<select id="selectUserById" resultType="User">
    SELECT * FROM users WHERE id = #{id}
</select>
  1. 注解形式：使用注解直接在 Java 接口或方法上编写 SQL 语句。注解形式的优点是简洁，不需要额外的 XML 配置文件，便于快速开发和维护。

示例：

// Java 接口
@Select("SELECT * FROM users WHERE id = #{id}")
User selectUserById(Long id);
  1. 混合形式：结合 XML 和注解的形式编写 SQL。可以在 XML 文件中定义通用的 SQL 语句和映射配置，同时在 Java 接口或方法上使用注解指定特定的 SQL。

示例：

<!-- SQL 配置文件 -->
<select id="selectUserById" resultType="User">
    SELECT * FROM users WHERE id = #{id}
</select>

// Java 接口
@Select("SELECT * FROM users WHERE id = #{id}")
User selectUserById(Long id);
  1. 动态 SQL：MyBatis 提供了一系列动态 SQL 标签，如 <if>、<choose>、<foreach> 等，用于根据条件动态生成 SQL 语句，实现更灵活的 SQL 控制。

示例：

<!-- 动态 SQL -->
<select id="selectUserByCondition" 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 编写形式可以根据具体项目需求和开发者的习惯选择使用，使得 MyBatis 在 SQL 控制方面更加灵活和方便。

10、MyBatis 支持哪些传参数的方法？

MyBatis 支持多种方式传递参数，常用的包括：

  1. 基本类型参数：如整数、字符串等基本数据类型，直接在 SQL 中使用 #{} 占位符引用即可。

示例：

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

User selectUserById(@Param("id") Long id);
  1. POJO 对象参数：可以将 Java 对象作为参数传递，MyBatis 会根据对象的属性名自动映射到 SQL 中。

示例：

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

void insertUser(User user);
  1. Map 参数：可以使用 Map 作为参数传递，其中 Map 的 key 对应 SQL 中的参数名。

示例：

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

void insertUser(Map<String, Object> paramMap);
  1. @Param 注解：在方法参数中使用 @Param 注解指定参数名，可以在 SQL 中引用该参数。

示例：

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

void updateUser(@Param("id") Long id, @Param("name") String name, @Param("age") Integer age);
  1. 多个参数：可以直接在方法中传递多个参数，MyBatis 会自动封装为 Map 或使用 @Param 注解指定参数名。

示例：

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

void updateUser(Long id, String name, Integer age);

这些传参数的方法可以根据具体情况和个人偏好选择使用，使得 MyBatis 在数据操作时更加灵活和方便。

11、MyBatis 的 $ 和 # 传参的区别？

MyBatis 中的 $ 和 # 传参方式有一些区别：

  1. $ 传参：使用 $ 符号表示传递参数，实际上是将参数值直接拼接到 SQL 语句中，相当于字符串替换，不会进行预编译处理。这种方式在动态拼接 SQL 时非常有用，比如拼接 WHERE 子句的条件。

示例：

<select id="selectUserById" resultType="User">
    SELECT * FROM users WHERE id = ${id}
</select>

User selectUserById(@Param("id") Long id);
  1. # 传参：使用 # 符号表示传递参数，实际上是使用预编译参数占位符 ?，MyBatis 会将参数值传递给 PreparedStatement 进行预编译处理，安全性更高，可以有效防止 SQL 注入攻击。

示例：

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

User selectUserById(@Param("id") Long id);

总的来说，$ 传参方式适用于静态 SQL 语句或者动态拼接 SQL 片段时，而 # 传参方式更安全，适用于大多数的参数传递情况。选择使用哪种方式取决于具体的业务需求和安全性考虑。

12、MyBatis 可以映射到枚举类吗？

是的，MyBatis 可以映射到枚举类。在 MyBatis 中，可以使用 TypeHandler 来处理 Java 中的枚举类型，将枚举类型映射到数据库中的相应字段。

首先，你需要创建一个实现了 org.apache.ibatis.type.TypeHandler 接口的枚举类型处理器，然后在 MyBatis 的配置文件中注册这个处理器。

示例代码如下：

import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MyEnumTypeHandler extends BaseTypeHandler<MyEnum> {

    @Override
    public void setNonNullParameter(PreparedStatement preparedStatement, int i, MyEnum myEnum, JdbcType jdbcType) throws SQLException {
        preparedStatement.setString(i, myEnum.getValue());
    }

    @Override
    public MyEnum getNullableResult(ResultSet resultSet, String s) throws SQLException {
        return MyEnum.getByValue(resultSet.getString(s));
    }

    @Override
    public MyEnum getNullableResult(ResultSet resultSet, int i) throws SQLException {
        return MyEnum.getByValue(resultSet.getString(i));
    }

    @Override
    public MyEnum getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
        return MyEnum.getByValue(callableStatement.getString(i));
    }
}

然后在 MyBatis 的 XML 配置文件中注册这个处理器：

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

接下来，在你的实体类中使用这个枚举类型，并在对应的字段上加上 @EnumTypeHandler 注解，指定使用的枚举处理器：

public class User {
    private Long id;
    private MyEnum status;

    // Getters and setters
}

<resultMap id="userResultMap" type="User">
    <id property="id" column="id"/>
    <result property="status" column="status" javaType="com.example.MyEnum" jdbcType="VARCHAR" typeHandler="com.example.MyEnumTypeHandler"/>
</resultMap>

这样，MyBatis 就能够将数据库中存储的枚举值映射到对应的枚举类型，并且在进行查询时能够正确地将数据库中的值转换为枚举类型。

13、MyBatis 怎么封装动态 SQL？

MyBatis 提供了强大的动态 SQL 功能，可以根据条件动态生成 SQL 语句，实现灵活的数据库操作。以下是使用 MyBatis 封装动态 SQL 的一些常见方法：

  1. if 标签： 通过 <if> 标签判断条件是否成立，根据条件生成不同的 SQL 片段。示例：
<select id="getUserById" parameterType="int" resultType="User">
    SELECT * FROM user
    WHERE id = #{id}
    <if test="name != null">
        AND name = #{name}
    </if>
</select>
  1. choose、when、otherwise 标签： 类似于 Java 中的 switch-case-default 结构，根据不同条件选择执行不同的 SQL 片段。示例：
<select id="getUserById" parameterType="int" resultType="User">
    SELECT * FROM user
    <choose>
        <when test="name != null">
            WHERE name = #{name}
        </when>
        <when test="age != null">
            WHERE age = #{age}
        </when>
        <otherwise>
            WHERE id = #{id}
        </otherwise>
    </choose>
</select>
  1. where 标签： 可以自动处理 SQL 语句中的 WHERE 条件，去除不必要的 AND 或 OR 关键字。示例：
<select id="getUserByCondition" parameterType="User" resultType="User">
    SELECT * FROM user
    <where>
        <if test="id != null">
            AND id = #{id}
        </if>
        <if test="name != null">
            AND name = #{name}
        </if>
        <if test="age != null">
            AND age = #{age}
        </if>
    </where>
</select>
  1. trim、set 标签： trim 标签可以对 SQL 语句进行修剪，去除不必要的字符；set 标签用于更新操作，可以动态生成 SET 子句。示例：
<update id="updateUser" parameterType="User">
    UPDATE user
    <set>
        <if test="name != null">
            name = #{name},
        </if>
        <if test="age != null">
            age = #{age},
        </if>
    </set>
    WHERE id = #{id}
</update>

这些是 MyBatis 中常用的动态 SQL 封装方式，可以根据具体需求选择合适的方法来动态生成 SQL 语句。

14、Mybatis trim 标签有什么用？

MyBatis 中的 <trim> 标签主要用于修剪（trim）SQL 语句中不必要的字符，例如去除多余的空格、逗号等，可以使生成的 SQL 语句更加规范和准确。常见的用法包括：

  1. 去除多余的 AND 或 OR 关键字： 在动态拼接 SQL 语句时，有可能会出现不需要的 AND 或 OR 关键字，可以通过 <trim> 标签去除这些关键字。示例：
<select id="getUserByCondition" parameterType="User" resultType="User">
    SELECT * FROM user
    <where>
        <if test="id != null">
            AND id = #{id}
        </if>
        <if test="name != null">
            AND name = #{name}
        </if>
        <if test="age != null">
            AND age = #{age}
        </if>
    </where>
</select>

在上述示例中，如果所有条件都不满足，会生成类似 SELECT * FROM user WHERE 的 SQL 语句，其中的 WHERE 后面没有实际条件，可以通过 <trim> 标签去除不必要的 WHERE 关键字。

  1. 修剪开头或结尾的字符： <trim> 标签还可以修剪 SQL 语句开头或结尾的字符，例如修剪开头的逗号或 AND 关键字。示例：
<insert id="insertUser" parameterType="User">
    INSERT INTO user
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="name != null">
            name,
        </if>
        <if test="age != null">
            age,
        </if>
    </trim>
    VALUES
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="name != null">
            #{name},
        </if>
        <if test="age != null">
            #{age},
        </if>
    </trim>
</insert>

在上述示例中，<trim> 标签被用于修剪 INSERT INTO 和 VALUES 语句中的开头和结尾的括号和逗号，确保生成的 SQL 语句是正确的。

总之，<trim> 标签是 MyBatis 中用于修剪 SQL 语句的非常有用的标签，可以使生成的 SQL 语句更加规范和准确。

15、MyBatis 怎么实现分页？

MyBatis 实现分页通常可以通过以下步骤完成：

  1. 编写 SQL 查询语句： 首先，在 Mapper XML 文件中编写查询语句，并使用 LIMIT 关键字限制返回的结果数量，通常结合 OFFSET 或者 ROW_NUMBER() 实现分页。示例：
<select id="getUserList" parameterType="map" resultType="User">
    SELECT * FROM user
    LIMIT #{start}, #{pageSize}
</select>
  1. 传入分页参数： 在调用查询方法时，需要传入分页所需的参数，例如起始位置 start 和每页显示数量 pageSize。可以将这些参数封装到一个 Map 中传入方法。示例：
Map<String, Integer> params = new HashMap<>();
params.put("start", start);
params.put("pageSize", pageSize);
List<User> userList = userDao.getUserList(params);
  1. 实现分页逻辑： 在 Mapper XML 文件中接收传入的分页参数，并使用这些参数拼接 SQL 语句实现分页逻辑。示例：
<select id="getUserList" parameterType="map" resultType="User">
    SELECT * FROM user
    LIMIT #{start}, #{pageSize}
</select>

在上述示例中，#{start} 和 #{pageSize} 分别对应传入的分页起始位置和每页显示数量，MyBatis 会自动将这些参数替换到 SQL 语句中，实现分页查询功能。

16、MyBatis 流式查询有什么用？

MyBatis 中的流式查询（Streaming ResultSet）功能主要用于处理大量数据查询时的性能优化和内存控制。当查询结果集非常大时，一次性将所有结果加载到内存中可能会导致内存占用过高或者性能下降的问题。流式查询可以将查询结果分批次处理，降低内存压力，提升查询性能。

流式查询的原理是通过数据库的游标（cursor）来逐行获取数据，而不是一次性将所有数据加载到内存中。这样可以减少内存占用，并且在需要处理大量数据时可以更高效地进行操作。

在 MyBatis 中实现流式查询可以通过配置 <select> 标签的 fetchSize 属性来设置每次从数据库获取的记录数量，以及在查询方法中使用 ResultSetHandler 的方式来处理查询结果流。流式查询适合处理大量数据，提高系统的性能和资源利用率。

17、MyBatis 模糊查询 like 语句该怎么写？

在 MyBatis 中进行模糊查询可以使用 SQL 的 LIKE 语句结合 % 和 _ 通配符来实现。通配符 % 表示零个或多个字符，而通配符 _ 则表示一个字符。

以下是一个示例的 MyBatis XML 配置，展示了如何使用 LIKE 语句进行模糊查询：

<select id="selectUsersByName" parameterType="string" resultType="User">
    SELECT * FROM users WHERE name LIKE CONCAT('%', #{name}, '%')
</select>

在这个示例中，假设 users 表包含一个 name 列，我们通过 LIKE CONCAT('%', #{name}, '%') 来实现对 name 列进行模糊查询。${name} 是查询参数，在实际使用时会被动态替换为具体的查询值。

这样的配置可以让 MyBatis 在执行查询时将 % 放在查询值的两侧，从而实现模糊匹配。

18、MyBatis 配置文件中的 SQL id 是否能重复？

在 MyBatis 配置文件中，SQL id 是唯一的，不允许重复。每个 SQL 语句或者 SQL 片段在 MyBatis 中都必须有一个唯一的 id 来标识，以便在后续的 Mapper 接口或者 XML 文件中引用。如果出现了重复的 SQL id，MyBatis 在解析配置文件时会报错。因此，确保每个 SQL id 的唯一性是很重要的。

19、MyBatis 如何防止 SQL 注入？

要防止 SQL 注入，可以采取以下几种方式：

  1. 使用参数化查询： 在 SQL 语句中使用占位符，然后将参数值作为参数传递给 SQL 语句，而不是直接拼接参数到 SQL 语句中。这样可以避免恶意用户输入特殊字符来构造恶意 SQL 语句的情况。

    <!-- 示例：使用参数化查询 -->
<select id="getUserById" parameterType="int" resultType="User">
    SELECT * FROM users WHERE id = #{id}
</select>

  2. 使用 MyBatis 的动态 SQL： MyBatis 提供了动态 SQL 的功能，可以根据条件来动态生成 SQL 语句，这样可以避免直接拼接 SQL 字符串。

    <!-- 示例：使用动态 SQL -->
<select id="getUserByCondition" parameterType="map" resultType="User">
    SELECT * FROM users
    <where>
        <if test="username != null"> AND username = #{username}</if>
        <if test="password != null"> AND password = #{password}</if>
    </where>
</select>

  3. 限制参数的长度和格式： 在输入参数的验证阶段，限制参数的长度和格式，只允许符合预期的参数通过，这样可以有效防止恶意注入攻击。

  4. 使用安全的编码库： 在处理用户输入数据时，使用安全的编码库进行转义处理，确保用户输入的特殊字符被转义为安全的字符。

通过以上措施可以有效地防止 SQL 注入攻击。

20、MyBatis 如何获取自动生成的主键id？

在 MyBatis 中获取自动生成的主键 ID 可以通过以下几种方式实现：

  1. 使用 <selectKey> 标签： 在插入数据的 SQL 语句中，通过 <selectKey> 标签来获取自动生成的主键 ID。可以设置 order 属性来指定插入数据的时机，常用的值为 BEFORE 或 AFTER。示例如下：

    <insert id="insertUser" parameterType="User" useGeneratedKeys="true" keyProperty="id">
    INSERT INTO users (username, password) VALUES (#{username}, #{password})
    <selectKey keyProperty="id" resultType="int" order="AFTER">
        SELECT LAST_INSERT_ID()
    </selectKey>
</insert>

    上述示例中，keyProperty="id" 指定了要将生成的主键 ID 赋值给 User 对象的 id 属性。

  2. 在插入后获取主键 ID： 在执行完插入操作后，通过 MyBatis 的 API 获取自动生成的主键 ID。示例如下：

    // Java 代码示例
sqlSession.insert("insertUser", user);
int userId = user.getId(); // 获取自动生成的主键 ID

    这种方式适用于在插入后需要立即获取主键 ID 的情况。

两种方式都可以实现获取自动生成的主键 ID，具体选择哪种方式取决于业务需求和个人偏好。

21、MyBatis 使用了哪些设计模式？

MyBatis 使用了以下设计模式：

  1. 工厂模式（Factory Pattern）： MyBatis 使用工厂模式创建 SqlSessionFactory，SqlSessionFactory 是 MyBatis 中的重要工厂类，负责创建 SqlSession 对象。

  2. 建造者模式（Builder Pattern）： 在配置 SqlSessionFactory 时，MyBatis 使用了建造者模式。通过使用建造者模式，可以方便地创建复杂的对象，如 SqlSessionFactoryBuilder。

  3. 适配器模式（Adapter Pattern）： MyBatis 中的 Executor 接口以及其实现类，如 SimpleExecutor 和 CachingExecutor，使用了适配器模式。通过适配器模式，可以使不同类型的 Executor 实现可以统一使用 Executor 接口进行调用。

  4. 装饰者模式（Decorator Pattern）： 在 MyBatis 中，Plugin 是一个装饰者模式的典型例子。Plugin 用于对 Executor、StatementHandler、ParameterHandler、ResultSetHandler 等对象进行装饰，增强其功能。

  5. 单例模式（Singleton Pattern）： MyBatis 中的 Configuration、SqlSessionFactoryBuilder 等类采用了单例模式，确保在应用中只有一个实例存在。

  6. 模板方法模式（Template Method Pattern）： MyBatis 中的 BaseExecutor 类是一个抽象类，定义了模板方法 pattern()，子类可以通过实现这个模板方法来完成具体的操作。

  7. 观察者模式（Observer Pattern）： MyBatis 中的 EventListener 接口及其实现类，如 DefaultVetoableEventListener，使用了观察者模式。事件监听器可以监听特定的事件，并在事件发生时执行相应的操作。

这些设计模式使得 MyBatis 在实现上更加灵活、可扩展，并且提高了代码的可维护性和可读性。

22、MyBatis 中的缓存机制有啥用？

MyBatis 中的缓存机制主要有以下作用：

  1. 减少数据库访问次数： 缓存可以将查询结果缓存在内存中，当下次需要相同数据时，可以直接从缓存中获取，减少了对数据库的访问次数，提高了系统性能和响应速度。

  2. 降低系统负载： 缓存可以减轻数据库的压力，特别是在高并发场景下，通过缓存可以减少数据库的并发访问，降低系统负载，提高系统的稳定性和可用性。

  3. 提升响应速度： 缓存可以大大减少数据的读取和处理时间，从而提升了系统的响应速度，提高了用户体验。

  4. 减少网络开销： 缓存可以减少因网络传输数据而产生的开销，特别是对于数据量较大的查询结果，通过缓存可以避免频繁地网络传输。

  5. 提高并发能力： 缓存可以减少对数据库的直接访问，降低了数据库的并发压力，从而提高了系统的并发能力。

总的来说，MyBatis 中的缓存机制可以有效地提高系统的性能、稳定性和并发能力，是优化数据库访问的重要手段之一。

23、MyBatis 一级缓存和二级缓存的区别？

MyBatis 中的一级缓存（Local Cache）和二级缓存（Global Cache）的区别如下：

  1. 作用范围：

    • 一级缓存： 一级缓存是针对 SqlSession 级别的缓存，即在同一个 SqlSession 中，多次执行相同的 SQL 语句，第一次查询的结果会被缓存到内存中，后续查询可以直接从缓存中获取，只在当前 SqlSession 中有效。
    • 二级缓存： 二级缓存是全局的缓存，可以跨多个 SqlSession 共享数据。当开启了二级缓存后，多个 SqlSession 可以共享相同的缓存数据，提高了数据的共享性和复用性。

  2. 生命周期：

    • 一级缓存： 一级缓存的生命周期是和 SqlSession 绑定的，当 SqlSession 关闭时，一级缓存也就失效了。
    • 二级缓存： 二级缓存的生命周期是和整个应用程序绑定的，当应用程序关闭时，二级缓存才会被销毁。

  3. 并发访问：

    • 一级缓存： 一级缓存是线程私有的，同一个 SqlSession 内部的多个查询会共享一级缓存，但是不同的 SqlSession 之间的缓存是相互隔离的，不会产生并发访问的问题。
    • 二级缓存： 二级缓存是全局共享的，多个 SqlSession 可以同时访问二级缓存中的数据，需要考虑并发访问时的线程安全性问题。

  4. 使用方式：

    • 一级缓存： 一级缓存是 MyBatis 默认开启的，无需额外配置，可以通过手动清空缓存或者提交事务来刷新缓存。
    • 二级缓存： 二级缓存需要手动配置开启，在 Mapper 文件中添加 <cache> 标签，并且需要对需要缓存的实体类进行序列化。

  5. 适用场景：

    • 一级缓存： 适用于单个 SqlSession 中频繁查询的场景，可以减少对数据库的重复查询，提高性能。
    • 二级缓存： 适用于多个 SqlSession 共享数据的场景，比如多个查询之间有关联，需要共享相同的查询结果。

总的来说，一级缓存是 SqlSession 级别的缓存，适用于短期的、局部的缓存需求；而二级缓存是全局的缓存，适用于多个 SqlSession 共享数据的场景。在实际应用中，可以根据具体业务需求来选择合适的缓存策略。

24、MyBatis-Plus 是什么框架？

MyBatis-Plus 是 MyBatis 的增强工具库，提供了许多便捷的功能和增强特性，使得在使用 MyBatis 进行数据库操作时更加方便和高效。它的主要功能包括但不限于：

  1. 通用 CRUD 操作： 提供了通用的增删改查方法，无需手写 SQL，简化了数据库操作。

  2. 代码生成器： 可以根据数据库表自动生成 Entity、Mapper、Service、Controller 等代码，提高开发效率。

  3. 条件构造器： 提供了方便的条件构造器 API，可以灵活构建复杂的查询条件，支持链式调用。

  4. 分页插件： 支持分页查询功能，可以轻松实现分页查询，并且支持多种分页插件，如基于 MySQL 的分页插件、Elasticsearch 的分页插件等。

  5. 乐观锁插件： 提供了乐观锁的实现，可以避免多个线程同时修改同一条数据时产生的并发问题。

  6. 多租户支持： 支持多租户的数据隔离，可以根据不同的租户 ID 对数据进行分割和管理。

  7. 逻辑删除插件： 支持逻辑删除功能，可以在删除数据时标记为删除状态而不是真实删除，便于数据恢复和审计。

  8. 性能分析插件： 提供了性能分析功能，可以查看 SQL 执行时间、参数等信息，方便优化 SQL 查询。

  9. 自动填充插件： 支持实体类中字段的自动填充，如创建时间、更新时间等字段的自动填充。

  10. 枚举处理插件： 支持枚举类型字段的处理，可以将数据库中存储的枚举值转换为 Java 中的枚举类型。

总的来说，MyBatis-Plus 是 MyBatis 的一个增强工具库，通过提供丰富的功能和增强特性，简化了 MyBatis 的使用，提高了开发效率和代码质量。

25.如何使用Redis替换MyBtais的二级缓存？

要使用 Redis 替换 MyBatis 的二级缓存，你需要进行以下步骤：

  1. 引入 Redis 相关依赖： 首先，在项目中引入 Redis 相关的依赖，如 Jedis 或 Lettuce 等 Redis 客户端库，以便在 Java 代码中连接和操作 Redis。

  2. 配置 Redis 连接： 在项目的配置文件（如 application.properties 或 application.yml）中配置 Redis 连接信息，包括 Redis 的主机地址、端口号、密码等信息。

  3. 配置 MyBatis 的 Redis 缓存： 在 MyBatis 的配置文件（如 mybatis-config.xml）中配置 Redis 作为二级缓存。示例配置如下：

<configuration>
    <settings>
        <setting name="cacheEnabled" value="true"/>
        <setting name="localCacheScope" value="STATEMENT"/>
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>
    <typeAliases>
        <!-- 类型别名配置 -->
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!-- 数据源配置 -->
            </dataSource>
            <!-- 配置 Redis 缓存 -->
            <cache type="org.mybatis.caches.redis.RedisCache"/>
        </environment>
    </environments>
    <mappers>
        <!-- Mapper 文件配置 -->
    </mappers>
</configuration>

  1. 在实体类中添加序列化标识： 如果实体类中的对象需要被缓存到 Redis 中，则需要在实体类中添加序列化标识（Serializable 接口），以便可以被序列化和反序列化。

  2. 使用 RedisTemplate 或 Jedis 连接 Redis： 在 Java 代码中，通过 RedisTemplate 或 Jedis 等 Redis 客户端库连接 Redis，并进行缓存的读取和写入操作。

  3. 配置 RedisTemplate： 如果使用 RedisTemplate，需要在 Spring Boot 的配置类中配置 RedisTemplate，设置 Redis 的连接工厂、序列化器等信息。

  4. 在 DAO 层中配置缓存： 在 MyBatis 的 Mapper 接口中，可以通过 @CacheNamespace 注解或在 Mapper XML 文件中配置缓存，指定需要缓存的查询结果。

通过以上步骤，你就可以将 Redis 作为 MyBatis 的二级缓存，实现缓存数据的存储和读取。需要注意的是，配置 Redis 缓存时，要确保 Redis 的连接信息和序列化配置正确，并且在代码中正确使用 RedisTemplate 或 Jedis 进行缓存操作。


__EOF__

本文作者：‘陌路邑人’
本文链接：https://www.cnblogs.com/MLYR/p/18256297.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！
posted @   陌路邑人  阅读(60)  评论(0)  编辑  收藏  举报
相关博文：
· Redis（缓存）
· MySQL（数据库）
· MyBatis
· 彻底搞定MyBatis
· 面渣逆袭：二十二图、八千字、二十问，彻底搞定MyBatis！
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET10 - 预览版1新功能体验（一）
历史上的今天：
2023-06-19 POI导出Execl
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛