MyBatis 面试题（七）

1. MyBatis 什么时候必须指定jdbcType 和javaType?

MyBatis 是一个优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。在 MyBatis 中，jdbcType 和 javaType 是两个重要的属性，用于指定数据库字段与 Java 对象属性之间的类型映射。

jdbcType

jdbcType 是用来指定 SQL 语句中占位符对应的 JDBC 类型。这个属性主要在以下情况中需要指定：

1. 数据库字段类型与 Java 类型不匹配：当数据库字段的类型与 MyBatis 默认的 JDBC 类型不匹配时，需要显式指定 jdbcType。例如，数据库中的字段是 TINYINT，但你想要将其作为 Java 的 Boolean 类型来处理。
2. 特殊类型处理：对于某些特殊的 JDBC 类型，如 NULL、CURSOR 等，可能需要显式指定 jdbcType。
3. 防止潜在的类型转换问题：在某些情况下，如果不显式指定 jdbcType，可能会遇到潜在的类型转换问题。通过显式指定，可以确保类型的一致性。

javaType

javaType 用于指定 Java 对象的属性类型。这个属性主要在以下情况中需要指定：

1. 复杂类型映射：当使用 MyBatis 的高级映射功能（如 <resultMap>）时，可能需要显式指定 javaType，以确保正确的类型映射。
2. 自定义类型处理器：如果你为某个类型创建了自定义的类型处理器（TypeHandler），并希望 MyBatis 在处理该类型时使用这个处理器，那么需要指定 javaType。
3. 处理泛型：当处理 Java 泛型时，可能需要显式指定 javaType，以确保正确的类型信息被传递。

总结

在大多数情况下，MyBatis 能够根据数据库字段和 Java 对象的属性自动推断出正确的类型映射，因此不需要显式指定 jdbcType 和 javaType。但在某些特殊情况下，为了确保类型的一致性和正确性，可能需要显式指定这两个属性。

2. MyBatis 什么时候必须指定jdbcType 和javaType?

在 MyBatis 中，jdbcType 和 javaType 主要用于解决 JDBC 类型和 Java 类型之间的映射问题。在大多数情况下，MyBatis 能够自动推断这些类型，但有些时候，我们可能需要显式地指定它们。

以下是一些可能需要指定 jdbcType 和 javaType 的情况：

1. 当 MyBatis 无法自动推断类型时：在某些复杂的 SQL 语句中，特别是涉及到复杂数据类型（如自定义类型、枚举等）或复杂 SQL 表达式时，MyBatis 可能无法自动推断出正确的 JDBC 类型或 Java 类型。在这种情况下，显式指定这些类型可以确保正确的映射。
2. 避免潜在的 SQL 注入风险：在某些情况下，如果 MyBatis 无法正确识别参数的类型，它可能会将参数值作为字符串直接插入到 SQL 语句中，这可能导致 SQL 注入的风险。通过显式指定 jdbcType，我们可以确保参数以正确的类型插入到 SQL 语句中，从而减少这种风险。
3. 处理 NULL 值：当处理可能为 NULL 的字段时，有时需要显式指定 jdbcType 以确保正确的 NULL 值处理。
4. 优化性能：在某些数据库和 JDBC 驱动中，显式指定 jdbcType 可以帮助优化性能，因为数据库可以更有效地处理已知类型的参数。

对于 javaType，它主要用于指定结果集中字段的 Java 类型，当字段类型不是 MyBatis 默认支持的简单类型时，需要显式指定。例如，如果你的数据库字段是一个自定义类型或枚举类型，你可能需要指定 javaType 来确保正确的类型映射。

总的来说，虽然大多数情况下 MyBatis 可以自动处理类型映射，但在某些特定情况下，显式指定 jdbcType 和 javaType 可以确保正确的类型处理并优化性能。在编写 MyBatis 映射文件时，应该根据具体的需求和上下文来决定是否需要指定这些类型。

3. MyBatis 支持预编译吗? 怎么做?

MyBatis 确实支持预编译（PreparedStatement）的方式来执行 SQL 语句。预编译的 SQL 语句能够提高性能，因为它避免了 SQL 语句的重复解析，并且可以通过预编译的参数来防止 SQL 注入攻击。

在 MyBatis 中，预编译的 SQL 语句主要通过以下方式实现：

1. 使用 #{} 占位符：在 MyBatis 的映射文件（XML）中，你可以使用 #{} 占位符来指定参数。MyBatis 会自动将这些占位符替换为预编译 SQL 语句中的参数。例如：

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

在这个例子中，#{id} 是一个占位符，它会被替换为实际的参数值，并且 MyBatis 会使用 PreparedStatement 来执行这个查询。
2. 类型处理器：MyBatis 提供了一套类型处理器（TypeHandler）来处理 Java 类型和 JDBC 类型之间的转换。当使用预编译的 SQL 语句时，类型处理器负责将 Java 类型的参数转换为 JDBC 类型的参数，并设置到 PreparedStatement 中。
3. 动态 SQL：MyBatis 支持动态 SQL，允许你根据条件动态地构建 SQL 语句。虽然动态 SQL 本身并不直接涉及到预编译，但你可以结合使用 #{} 占位符和动态 SQL 来构建安全的、预编译的 SQL 语句。
4. **避免使用 KaTeX parse error: Expected 'EOF', got '#' at position 10: {}`**：与 `#̲{}` 不同，`{}会直接将参数值拼接到 SQL 语句中，这样做会导致 SQL 注入的风险。因此，为了使用预编译并防止 SQL 注入，应尽量避免使用${}`。

总的来说，当你在 MyBatis 的映射文件中使用 #{} 占位符来指定参数时，MyBatis 就会使用 PreparedStatement 来执行预编译的 SQL 语句。同时，确保你的 SQL 语句是安全的，避免使用可能导致 SQL 注入的语法或模式。

4. MyBatis 中的事务管理方式?

MyBatis 中的事务管理主要依赖于底层的数据库连接池和 JDBC 的事务管理机制。MyBatis 本身并不直接提供事务管理功能，而是与 Spring 等框架集成，利用这些框架提供的事务管理能力来实现。然而，MyBatis 也提供了一些配置和接口，以便开发者能够更灵活地控制事务。

以下是 MyBatis 中事务管理的主要方式：

1. 使用 JDBC 的事务管理：
   当 MyBatis 独立使用时，可以使用 JDBC 的事务管理机制。通过 java.sql.Connection 对象的 setAutoCommit(false) 方法来开启事务，然后通过 commit() 或 rollback() 方法来提交或回滚事务。这种方式需要开发者手动管理事务的边界和提交/回滚操作。

2. 与 Spring 集成的事务管理：
   当 MyBatis 与 Spring 框架集成时，可以利用 Spring 的声明式事务管理功能。Spring 提供了 @Transactional 注解，可以方便地声明事务的边界。此外，Spring 还支持编程式事务管理，通过 TransactionTemplate 或 PlatformTransactionManager 接口来手动控制事务。

3. MyBatis 的 SqlSessionFactory 和 SqlSession：
   MyBatis 的 SqlSessionFactory 负责创建 SqlSession 对象，而 SqlSession 对象代表了一个数据库会话，它内部封装了 JDBC 的 Connection 对象。SqlSession 提供了执行 SQL 语句和获取映射结果的方法，同时也提供了控制事务的方法，如 commit() 和 rollback()。当使用 MyBatis 的原生 API 时，开发者可以通过控制 SqlSession 的生命周期来管理事务。

4. 使用事务管理器插件：
   MyBatis 允许开发者通过编写插件来扩展其功能。因此，可以编写一个自定义的事务管理器插件，来管理 MyBatis 的事务。这种方式比较复杂，通常只在有特殊需求时才使用。

在实际应用中，推荐将 MyBatis 与 Spring 框架集成，利用 Spring 的强大事务管理能力来简化事务管理的复杂性。这样，开发者可以专注于业务逻辑的实现，而不需要过多关注底层的事务处理细节。

5. MyBatis 中怎么开启事务?

在 MyBatis 中，事务的开启、提交和回滚通常是通过与数据库连接池和 JDBC 的交互来完成的，而不是直接由 MyBatis 控制。MyBatis 主要关注 SQL 映射和结果集的处理，而事务管理通常是由 Spring 这样的框架来完成的。

但是，如果你在使用 MyBatis 的原生方式，没有结合 Spring 等框架，你也可以通过 JDBC 来手动管理事务。以下是一个简单的示例：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisTransactionExample {
    public static void main(String[] args) {
        String resource = "org/mybatis/example/mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        try (Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "username", "password")) {
            conn.setAutoCommit(false); // 关闭自动提交，开始事务
            try (SqlSession session = sqlSessionFactory.openSession(conn)) {
                // 执行你的 SQL 操作...
                // 例如：session.insert("insertStatement", yourObject);

                // 如果没有任何异常，提交事务
                conn.commit();
            } catch (Exception e) {
                // 如果发生异常，回滚事务
                conn.rollback();
                throw e;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们首先通过 JDBC 的 DriverManager 获取一个数据库连接，并关闭其自动提交功能，从而开始一个事务。然后，我们创建一个 SqlSession，并使用这个 SqlSession 来执行 SQL 操作。如果所有操作都成功完成，我们就调用 conn.commit() 来提交事务。如果在执行 SQL 操作的过程中发生任何异常，我们就调用 conn.rollback() 来回滚事务。

然而，这种方式的手动事务管理可能会非常复杂和容易出错，特别是在处理多个数据库操作时。因此，通常建议使用像 Spring 这样的框架来管理事务，它可以提供更高级的事务管理功能，如声明式事务管理、事务传播行为等。

6. MyBatis 事务和 Spring 事务有什么区别?

MyBatis 事务和 Spring 事务的主要区别体现在以下几个方面：

1. 管理方式和范围：

   • MyBatis 提供了基础的事务管理机制，但它主要是与 SQL 会话（即 SqlSession）相关的。当你操作 MyBatis 的 SqlSession 时，你可以开启、提交或回滚事务。然而，这种管理方式是较为底层的，需要开发者手动控制事务的边界。
   • Spring 事务管理则更为强大和灵活。它可以应用于任何的执行环境，无论是单数据源还是多数据源，无论是 JDBC 还是其他 ORM 框架如 JPA、Hibernate 等，都可以进行事务管理。Spring 提供了声明式事务管理，这意味着你可以通过注解或 XML 配置来定义事务的边界，而无需在每个方法或代码块中显式编写事务管理的代码。

2. 集成性和便利性：

   • 当 MyBatis 单独使用时，虽然可以管理事务，但相对于 Spring 的声明式事务管理，它可能显得较为繁琐。开发者需要手动处理事务的开启、提交和回滚。
   • 当 MyBatis 与 Spring 集成时，可以充分利用 Spring 的事务管理功能，简化事务处理的复杂性。Spring 的事务管理可以与 AOP（面向切面编程）结合，实现事务的自动管理，从而提高了开发效率和代码的可维护性。

3. 事务传播行为：

   • Spring 事务管理还提供了丰富的事务传播行为，如 REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW 等，这些传播行为可以根据业务需求灵活选择，以确保在复杂场景下事务的正确执行。
   • MyBatis 本身并不提供这样的事务传播行为配置，它更关注于 SQL 的执行和映射。

综上所述，MyBatis 和 Spring 在事务管理方面各有其特点和适用场景。对于简单的应用或只需要基本事务管理的场景，MyBatis 的原生事务管理可能已经足够。然而，对于更复杂的应用或需要更强大、更灵活的事务管理功能的场景，推荐使用 Spring 的事务管理功能。

7. MyBatis 使用了哪些设计模式?

MyBatis框架中使用了多种设计模式来构建其灵活且可扩展的结构。以下是一些在MyBatis中使用的关键设计模式：

1. 工厂模式：在MyBatis中，工厂模式被广泛应用，如SqlSessionFactory就是一个典型的工厂类。它负责创建SqlSession对象，使得客户端无需关心SqlSession的具体实现细节。
2. 建造者模式：MyBatis在环境的初始化过程中，SqlSessionFactoryBuilder会读取配置文件，并构建出核心对象Configuration，然后基于这个Configuration对象构建出SqlSessionFactory对象。这一过程体现了建造者模式的特点。
3. 单例模式：例如Configuration配置类就使用了单例模式，确保整个MyBatis应用中只有一个Configuration实例，从而避免了重复创建和资源浪费。
4. 代理模式：MyBatis使用动态代理为Mapper接口创建代理对象，代理对象自动实现Mapper接口的所有方法，并将方法与SqlSession相关联。这样，当调用Mapper接口的方法时，实际上是通过代理对象来执行相应的SQL操作。
5. 适配器模式：适配器模式用于解决接口不兼容的问题。在MyBatis中，适配器模式可能被用于处理不同数据库之间的SQL差异，或者用于适配不同的数据访问技术。
6. 装饰器模式：MyBatis使用装饰器模式来实现插件功能。插件可以动态地增加或修改SQL语句的执行逻辑，而无需修改原有的代码。装饰器模式允许在不改变原始类接口的情况下，向对象添加新的行为。
7. 模板方法模式：在MyBatis中，一些复杂的操作可能会被拆分成多个步骤，并在一个模板方法中进行组织。这样，子类可以通过重写特定步骤来改变行为，而无需改变整个操作的结构。

这些设计模式的应用使得MyBatis框架更加灵活、可扩展且易于维护。当然，除了上述设计模式外，MyBatis可能还使用了其他设计模式，具体取决于其实现和版本。要深入了解这些设计模式在MyBatis中的具体应用，建议查阅MyBatis的官方文档或相关源码。