MyBatis常见面试题-CSDN博客

文章目录

说说 MyBatis 执行流程？
MyBatis 和 Hibernate 有什么不同？
${} 和 #{} 有什么区别？
什么是 SQL 注入？
如何解决实体类属性和表中字段不一致的问题？
- - 解决方案
  - - 1. **使用注解映射**
    - 2. **使用 XML 配置映射（适用于 MyBatis）**
MyBatis 中如何实现分页？
HashMap 和 Hashtable 可以作为查询结果吗？
说一说动态SQL
说一下 MyBatis 的缓存机制？
MyBatis 中有哪些设计模式？

说说 MyBatis 执行流程？

MyBatis 是一个优秀的持久层框架，支持自定义 SQL、存储过程和高级映射。它的执行流程大致如下：

1. 加载配置文件和映射文件

加载核心配置文件（mybatis-config.xml）：
MyBatis 会读取核心配置文件以初始化环境信息，比如数据库连接池、事务管理、映射器等。
加载映射文件（Mapper XML 文件）：
MyBatis 读取每个映射文件中的 SQL 语句定义，并将其映射到相应的 Java 接口或类的方法上。

2. 构建 `SqlSessionFactory`

创建 SqlSessionFactory：
通过 SqlSessionFactoryBuilder 构建 SqlSessionFactory 对象。SqlSessionFactory 是 MyBatis 的核心对象之一，它负责创建 SqlSession 对象。

3. 创建 `SqlSession`

获取 SqlSession：
SqlSessionFactory 创建 SqlSession 对象。SqlSession 是 MyBatis 与数据库交互的关键对象，用来执行 SQL 查询、插入、更新和删除操作。

4. 调用 Mapper 方法

获取 Mapper 接口的代理对象：
MyBatis 会为每个 Mapper 接口生成代理对象，当你调用接口方法时，实际上是调用代理对象的方法。
执行 SQL 操作：
代理对象根据 Mapper 文件中的 SQL 映射信息，动态构建 SQL 语句，发送到数据库执行。

5. 处理参数和结果映射

参数处理：
MyBatis 将传入的参数进行处理，根据 Mapper 中的配置（如 #{} 和 ${} 占位符）将参数嵌入到 SQL 语句中。
执行 SQL 并获取结果：
MyBatis 通过 JDBC 执行构建的 SQL 语句，并将返回的结果集转换为 Java 对象。
结果映射：
如果结果需要映射到自定义对象（例如 POJO），MyBatis 会根据配置将数据库字段映射到 Java 对象的属性。

6. 事务管理

事务控制：
SqlSession 提供了事务控制的方法，如 commit() 和 rollback()。如果操作成功，需要手动提交事务（或者使用自动提交），否则可以回滚。

7. 释放资源

关闭 SqlSession：
当操作完成后，需要关闭 SqlSession 以释放数据库连接等资源。这可以通过手动关闭或者使用 try-with-resources 来自动关闭。

简化流程图：

加载配置 ->
构建 SqlSessionFactory ->
创建 SqlSession ->
获取 Mapper 代理 ->
调用 Mapper 方法 ->
执行 SQL 并映射结果 ->
事务管理 ->
关闭 SqlSession

这个执行流程展现了 MyBatis 如何在配置、动态 SQL 映射和事务管理之间无缝衔接，以简化与数据库的交互。

MyBatis 和 Hibernate 有什么不同？

MyBatis 和 Hibernate 都是 Java 的 ORM（对象关系映射）框架，尽管它们都处理数据库交互，但其实现方式和适用场景有很大差异。

1. 对象关系映射层次

MyBatis:
MyBatis 是 半自动化的 ORM 框架，它的核心在于 SQL 语句的控制。开发者需要手动编写 SQL 语句，MyBatis 提供了丰富的映射配置，用于将 SQL 查询结果映射到 Java 对象上。因此，它提供了对 SQL 更大的控制和灵活性，但需要开发者自己编写 SQL。
Hibernate:
Hibernate 是 全自动化的 ORM 框架，基于 POJO（Plain Old Java Objects）和映射元数据，它自动生成 SQL 并处理对象与数据库表之间的映射。开发者通常不需要手动编写 SQL，Hibernate 会根据实体类和数据库之间的映射关系来生成并执行 SQL 语句。

2. SQL 控制

MyBatis:
MyBatis 允许开发者完全控制 SQL 语句，这意味着你可以编写自定义的、优化的 SQL 语句，包括复杂的查询、插入、更新和删除操作。对于需要高度优化的 SQL 场景，MyBatis 更合适。
Hibernate:
Hibernate 尽可能屏蔽了底层的 SQL 细节，它基于 HQL（Hibernate Query Language）或 Criteria API 进行查询，并自动将 HQL 翻译成 SQL。如果开发者希望直接编写 SQL，Hibernate 也支持原生 SQL 查询，但通常不推荐频繁使用。

3. 开发复杂度

MyBatis:
MyBatis 对 SQL 的控制力高，但这意味着开发者需要对 SQL 和数据库有深入的了解，尤其是需要手动维护 SQL 语句和结果映射，这可能在项目规模增大时带来额外的复杂性。
Hibernate:
Hibernate 通过自动化映射和对象持久化减少了手动编写 SQL 的需求，对于数据模型简单或业务逻辑与数据关系明确的项目，开发难度较低。然而，由于 Hibernate 隐藏了 SQL 细节，复杂的查询可能不容易优化。

4. 性能

MyBatis:
因为 SQL 是手动编写的，MyBatis 提供了对 SQL 语句的完全控制，因此可以编写高效的 SQL 并优化性能。然而，性能优化的责任完全在开发者身上。
Hibernate:
Hibernate 有自己的缓存机制（一级缓存、二级缓存）和自动化的批量操作优化。Hibernate 的自动生成 SQL 在一些简单场景下可以提高开发效率和性能，但对于复杂查询，生成的 SQL 可能不够高效，导致性能问题。

5. 缓存机制

MyBatis:
MyBatis 支持一级和二级缓存。一级缓存是基于 SqlSession 的本地缓存，而二级缓存是跨 SqlSession 的全局缓存。但缓存机制不像 Hibernate 那么自动化和丰富，更多依赖开发者的手动配置。
Hibernate:
Hibernate 具有更强大的缓存机制，默认开启一级缓存，并且可以很方便地使用二级缓存插件（如 EHCache、Infinispan）。它自动化的缓存管理能显著提升性能，特别是在读取频繁的场景中。

6. 数据库无关性

MyBatis:
MyBatis 并没有内置的数据库无关性支持，开发者需要为不同数据库编写不同的 SQL 语句，因此在跨数据库操作时需要更多的工作。
Hibernate:
Hibernate 通过自动生成 SQL 实现了较好的数据库无关性，开发者不需要为不同数据库编写不同的 SQL，它会根据底层数据库方言自动生成合适的 SQL 语句。

7. 适用场景

MyBatis:
适用于对 SQL 控制要求高、需要复杂查询或多表联合查询、或已有复杂的数据库设计的项目。MyBatis 的灵活性非常适合对 SQL 优化要求高的场景。
Hibernate:
适用于简单的数据模型或 CRUD 操作比较多的应用场景。对于需要较多的数据库自动化管理和面向对象设计的项目，Hibernate 是一个不错的选择。Hibernate 的自动化机制可以帮助开发者快速开发原型和减少代码量。

8. 学习曲线

MyBatis:
对开发者的 SQL 和数据库知识要求较高。由于它不完全是 ORM 解决方案，开发者必须在 SQL 和 Java 对象映射中找到平衡。
Hibernate:
虽然 Hibernate 提供了许多自动化功能，简化了数据库操作，但它的学习曲线较陡，尤其是在复杂场景下（如优化、缓存管理、批量操作等）。开发者需要理解其底层原理和行为，以避免潜在的问题。

总结

MyBatis: 灵活、可控性强，适合对 SQL 有较高要求和复杂查询的项目。
Hibernate: 自动化程度高、面向对象映射良好，适合 CRUD 操作较多且开发者希望避免直接与 SQL 打交道的场景。

两者各有优缺点，选择使用哪一个框架需要根据项目需求、团队技能和对 SQL 控制的需求来权衡。

${} 和 #{} 有什么区别？

${} 和 #{} 是 MyBatis 中用来在 SQL 语句中引用参数的两种方式，它们的区别主要体现在 SQL 解析、参数处理、安全性和性能等方面。

1. `${}`（字符串拼接）

作用: 直接将参数的值拼接到 SQL 语句中，类似于字符串替换。
解析方式: ${} 在 MyBatis 执行 SQL 时，参数不会被预处理，它会将传入的参数直接嵌入到生成的 SQL 语句中。
使用场景: 适用于动态生成 SQL 语句的场景，例如动态表名、列名或某些 SQL 关键字。

SELECT * FROM ${tableName};

在这里，tableName 的值将直接替换 ${tableName}。如果 tableName = "users"，最终生成的 SQL 将是：

SELECT * FROM users;

优点: 灵活，适用于动态 SQL 生成。
缺点: 存在 SQL 注入风险，参数不会被 MyBatis 进行预处理和转义。

2. `#{}`（预编译处理）

作用: 将参数作为预编译 SQL 语句的占位符（类似于 JDBC 的 ?），MyBatis 会将 #{} 中的参数值传递给 JDBC 处理，并将其安全地设置为 SQL 语句的参数。
解析方式: #{} 在 MyBatis 中会被解析为 ?，并使用 PreparedStatement 将参数值绑定到这个占位符。参数会被自动转义，以防止 SQL 注入攻击。
使用场景: 适用于传递普通的 SQL 参数，如查询条件、插入值等。

SELECT * FROM users WHERE id = #{userId};

在这里，#{userId} 会被解析为 ?，MyBatis 会将 userId 的值绑定到这个占位符上。如果 userId = 1，最终生成的 SQL 是：

SELECT * FROM users WHERE id = ?;

然后 MyBatis 会通过 PreparedStatement 绑定参数，将 1 传递给 SQL。

优点: 安全性高，防止 SQL 注入。MyBatis 会自动处理数据类型和转义。
缺点: 不适用于动态生成 SQL 语句的场景（如动态表名、列名等）。

3. 对比总结

特性	`${}`	`#{}`
工作原理	直接将参数值拼接到 SQL 中	使用占位符 `?` 预编译处理
适用场景	动态 SQL（如表名、列名等）	普通 SQL 参数传递
安全性	存在 SQL 注入风险	防止 SQL 注入
性能	每次执行都重新编译 SQL	预编译后重复执行，效率高
转义处理	无自动转义	自动转义（避免特殊字符问题）

什么时候用哪个？

使用 #{} 主要是为了传递普通参数，特别是对于用户输入的数据，这样可以避免 SQL 注入问题。
使用 ${} 主要用于拼接 SQL 动态部分，比如表名、列名等，不能用于传递用户输入的数据，因为这种方式不会进行转义和预处理。

示例

假设你有一段 SQL 查询代码：

SELECT * FROM ${tableName} WHERE name = #{name};

如果 tableName = "users" 且 name = "John"，生成的 SQL 会是：

SELECT * FROM users WHERE name = ?;

然后 MyBatis 会安全地将 name 的值 "John" 绑定到 ? 处。

在这种组合场景下，${} 用于动态表名，而 #{} 用于安全的参数传递。

什么是 SQL 注入？

SQL 注入（SQL Injection）是一种网络攻击技术，攻击者通过在输入字段中插入恶意的 SQL 代码，使应用程序生成恶意的 SQL 查询，从而操纵数据库的执行行为。SQL 注入可以导致严重的安全问题，包括数据泄露、数据篡改、删除数据甚至获取系统控制权。

SQL 注入示例

假设有一个登录功能，接受用户名和密码并在数据库中验证用户凭证。SQL 查询可能是这样写的：

SELECT * FROM users WHERE username = 'admin' AND password = 'password123';

如果这个查询中的 username 和 password 直接来自用户的输入，并且没有适当的处理，那么攻击者可以输入恶意的 SQL 代码。

假设攻击者在用户名字段输入 ' OR '1' = '1，而在密码字段随意输入数据，那么生成的 SQL 查询可能会变成：

SELECT * FROM users WHERE username = '' OR '1' = '1' AND password = 'whatever';

这段 SQL 会返回所有用户的数据，因为 '1' = '1' 始终为真，导致 SQL 查询条件总是成立。攻击者因此可以绕过登录验证，并以系统管理员或其他用户的身份登录。

SQL 注入的常见类型

基于错误的注入（Error-Based Injection）：
攻击者通过故意输入错误的数据来获取数据库错误信息，进而推断数据库结构和内容。
联合查询注入（Union-Based Injection）：
攻击者利用 UNION 语句，将恶意查询与原查询合并，获取数据库的额外信息。
盲注入（Blind SQL Injection）：
当数据库不会返回错误信息时，攻击者通过逐步测试布尔条件或时间延迟来推测数据库信息。
基于时间的注入（Time-Based Injection）：
通过让数据库查询执行时间延迟的方式，推断数据库是否执行了某条 SQL 语句，进而获取数据。

SQL 注入的危害

数据泄露: 攻击者可以读取敏感数据，例如用户信息、财务数据等。
数据篡改: 攻击者可以修改数据库中的信息，如更改密码、篡改记录。
删除数据: 攻击者可以执行 DELETE 操作，删除数据库中的数据。
执行系统命令: 在某些情况下，攻击者可以通过 SQL 注入执行数据库系统命令，甚至接管整个服务器。

防止 SQL 注入的最佳实践

使用预编译语句和参数化查询：
避免直接拼接 SQL 字符串，使用像 PreparedStatement 或其他框架（如 MyBatis 中的 #{}）来处理参数。这可以有效防止 SQL 注入。

String sql = "SELECT * FROM users WHERE username = ? AND password = ?";
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setString(1, username);
stmt.setString(2, password);
ResultSet rs = stmt.executeQuery();

使用 ORM 框架：
使用 Hibernate、MyBatis 等 ORM 框架，它们通常会自动处理参数化查询，减少 SQL 注入的风险。

如何解决实体类属性和表中字段不一致的问题？

在开发中，数据库表的字段名和实体类的属性名不一致是常见的问题。为了解决这种不一致性，常见的 ORM 框架（如 MyBatis、Hibernate 等）提供了多种机制来将数据库字段与实体类的属性进行映射。

解决方案

1. 使用注解映射

如果使用的是基于注解的 ORM 框架，可以通过注解明确地指定实体类属性与数据库表字段之间的映射。

在 MyBatis 中：
可以使用 @Results 和 @Result 注解来指定属性和数据库字段的映射关系。

@Select("SELECT id, user_name FROM users WHERE id = #{id}")
@Results({
     
     
    @Result(property = "id", column = "id"),
    @Result(property = "username", column = "user_name")
})
User selectUserById(int id);

在这个例子中，username 是实体类的属性，而 user_name 是数据库中的字段名，通过 @Result 注解将它们对应起来。

在 Hibernate 中：
使用 @Column 注解来指定实体类属性和数据库字段之间的映射。

@Entity
public class User {
     
     
    @Id
    private Long id;
    
    @Column(name = "user_name")
    private String username;
    
    // getter, setter
}