【Mybatis】Web中的数据库操作

MyBatis 是一个流行的持久层框架，主要用于简化 Java 应用程序中对数据库的访问。与传统的 JDBC（Java Database Connectivity）相比，MyBatis 提供了更高层次的抽象，帮助开发者更方便地进行数据库操作。

工作机制

MyBatis 的执行流程是指在一个完整的数据库操作中，MyBatis 如何从接收到用户请求到最终执行 SQL 并返回结果的整个过程。以下是 MyBatis 的典型执行流程：

1. 加载配置文件：

• 加载主配置文件（mybatis-config.xml）： MyBatis 在启动时会加载主配置文件，这个文件定义了数据库连接池、事务管理器、以及其他全局设置。
• 加载映射文件（Mapper XML）： 映射文件通常包括 SQL 语句及其与 Java 对象的映射关系。

2. 创建 SqlSessionFactory：

• MyBatis 使用配置文件中的信息创建 SqlSessionFactory 对象。这个工厂对象是创建 SqlSession 实例的入口，每个 SqlSession 实例都表示一个与数据库的会话。

3. 获取 SqlSession：

• 使用 SqlSessionFactory 来获取 SqlSession 对象。SqlSession 是执行 SQL 语句的核心接口，它提供了执行增删改查操作的方法。

4. 获取 Mapper 接口：

• SqlSession 提供了获取 Mapper 接口实例的方法，MyBatis 会动态生成该接口的实现类。Mapper 是 MyBatis 的核心组件，它将接口方法映射到具体的 SQL 语句。

5. 执行 SQL 语句：

• 调用 Mapper 接口方法： 你可以通过调用 Mapper 接口的方法来执行对应的 SQL 语句。MyBatis 会根据方法签名和参数，自动匹配并执行相应的 SQL。
• 参数处理： MyBatis 会将方法的参数传递给映射文件中定义的 SQL 语句，并对这些参数进行必要的转换和处理（如将对象的属性值注入到 SQL 中）。

6. SQL 语句解析和执行：

• 动态 SQL 解析： 如果 SQL 语句中包含动态 SQL 元素（如 <if>、<foreach> 等），MyBatis 会根据实际传入的参数对 SQL 进行动态解析和生成。
• SQL 执行： 生成的 SQL 语句通过 MyBatis 的底层执行器（Executor）提交给数据库执行。

7. 结果映射：

• 结果集映射： 数据库返回的结果集会被 MyBatis 自动映射为 Java 对象。映射规则由映射文件中的 <resultMap> 标签或注解指定，MyBatis 会根据这些配置将结果集转换为预期的 Java 对象。
• 结果处理： MyBatis 会将映射后的 Java 对象返回给调用者，通常是一个 POJO（Plain Old Java Object）或集合。

8. 事务管理：

• MyBatis 支持事务管理，SqlSession 提供了手动提交和回滚事务的方法。在 SqlSession 关闭前，开发者可以选择提交或回滚事务。

9. 关闭 SqlSession：

• 在操作完成后，必须关闭 SqlSession，以释放数据库连接等资源。通常情况下，SqlSession 是在try-finally 代码块中使用，以确保在异常发生时资源能够被正确释放。

10. 返回结果：

• 最终，SqlSession 返回结果给调用者，调用者可以直接使用这些映射后的 Java 对象。

总结来说，MyBatis 的执行流程是从加载配置文件到生成 SQL、执行 SQL，再到结果映射的一个完整过程。每一步都有相应的组件和机制来保证 SQL 的正确执行和结果的准确返回。

与JDBC对比

相比于传统的 JDBC，MyBatis 增加了丰富的功能，使得数据库操作更加简洁、灵活且易于维护。它将大量繁琐的手动编码工作自动化，并且提供了强大的配置、扩展和管理能力，极大地提高了开发效率和代码质量。

1. 自动对象映射

• 对象关系映射（ORM）： MyBatis 能够自动将 SQL 查询结果映射为 Java 对象，或者将 Java 对象的属性映射为 SQL 参数。这避免了在 JDBC 中手动处理结果集（ResultSet）和对象之间的映射。
• ResultMap 配置： 通过 ResultMap，MyBatis 提供了强大的映射配置，允许你精确地定义数据库字段与 Java 对象属性之间的关系。

2. SQL 语句管理

• SQL 分离： 在 MyBatis 中，SQL 语句通常被写在 XML 文件或注解中，这样可以将 SQL 语句与 Java 代码分离，避免了在代码中嵌入大量的 SQL 字符串，使代码更加清晰和易于维护。
• 动态 SQL： MyBatis 提供了动态 SQL 功能，允许你根据条件动态生成 SQL 语句。这比在 JDBC 中手动拼接 SQL 字符串更安全、更灵活，尤其在处理复杂查询时非常有用。

3. 简化的数据库操作

• 简化 CRUD 操作： MyBatis 提供了非常简洁的 API 来执行常见的数据库操作（增删改查）。例如，你只需要调用一个 Mapper 方法就能执行对应的 SQL 操作，而不必像 JDBC 那样手动编写大量的代码来执行这些操作。
• 批量操作支持： MyBatis 对批量插入、更新、删除提供了很好的支持，这在 JDBC 中通常需要额外处理。

4. 配置与管理

• 配置管理： MyBatis 通过 XML 或注解的方式集中管理 SQL 语句、数据库连接信息等配置，使得配置更加集中化、规范化。
• 事务管理： MyBatis 提供了内置的事务管理功能，能够更方便地控制事务的提交和回滚，而不需要在每个数据库操作中手动管理事务。

5. 插件机制

• 插件扩展： MyBatis 提供了插件机制，允许开发者在执行 SQL 语句的各个阶段（如执行前、执行后、结果处理等）插入自定义逻辑。这使得你可以轻松地扩展 MyBatis 的功能，比如实现自定义的日志记录、性能监控等。

6. 支持注解

• 注解支持： 除了 XML 配置，MyBatis 还支持使用 Java 注解来定义 SQL 语句和映射关系，这使得配置更加灵活，减少了 XML 的使用。

7. 灵活的查询和缓存机制

• 嵌套查询与关联查询： MyBatis 支持嵌套查询和关联查询，能够处理复杂的数据关系，并将结果集映射到嵌套的 Java 对象中。
• 二级缓存： MyBatis 提供了二级缓存机制，允许你在同一个 SqlSession 中缓存查询结果，提高应用性能。

8. 更好的错误处理

• 错误处理： MyBatis 提供了更好的错误处理机制，包括详细的错误日志和异常处理能力，能够帮助开发者快速定位和解决问题。而在 JDBC 中，错误信息通常较为粗糙，调试较为困难。

9. 易于与其他框架集成

• Spring 集成： MyBatis 与 Spring 框架无缝集成，能够利用 Spring 的事务管理和依赖注入功能，简化应用程序的开发。

三个显著特点

1. SQL映射
2. 动态SQL
3. 对象关系映射（ORM）支持

我们将用一个简单的代码演示，来理解这三个特点
以下是一个简单的示例，展示了MyBatis的基本用法和特点，包括SQL映射、动态SQL以及对象关系映射。

代码示例

1. 配置MyBatis

首先，你需要一个MyBatis的配置文件（mybatis-config.xml），来配置数据库连接和其他参数。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_demo"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

2. 创建数据库表

创建一个简单的用户表作为示例。

CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50),
    email VARCHAR(50)
);

3. 创建POJO类

定义一个与数据库表对应的Java类User。

public class User {
    private int id;
    private String name;
    private String email;

    // Getters and Setters
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

4. 编写Mapper接口

MyBatis中Mapper接口用于定义与数据库操作相关的方法。

public interface UserMapper {
    User getUserById(int id);
    List<User> getAllUsers();
    void insertUser(User user);
    void updateUser(User user);
    void deleteUser(int id);
}

5. 编写SQL映射文件

UserMapper.xml用于定义SQL语句并将它们映射到Mapper接口的方法上。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="UserMapper">

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

    <select id="getAllUsers" resultType="User">
        SELECT * FROM users
    </select>

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

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

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

</mapper>

6. 使用MyBatis进行数据库操作

编写主程序来演示如何使用MyBatis执行数据库操作。

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyBatisExample {
    public static void main(String[] args) throws IOException {
        // 1. 读取MyBatis配置文件
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        // 2. 获取SqlSession
        try (SqlSession session = sqlSessionFactory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);

            // 3. 插入新用户
            User newUser = new User();
            newUser.setName("John Doe");
            newUser.setEmail("john.doe@example.com");
            mapper.insertUser(newUser);
            session.commit(); // 提交事务

            // 4. 查询所有用户
            List<User> users = mapper.getAllUsers();
            users.forEach(user -> System.out.println(user.getName() + ": " + user.getEmail()));

            // 5. 更新用户
            User existingUser = users.get(0);
            existingUser.setName("Jane Doe");
            mapper.updateUser(existingUser);
            session.commit();

            // 6. 删除用户
            mapper.deleteUser(existingUser.getId());
            session.commit();
        }
    }
}

解释：

1. SQL 映射： SQL语句直接写在XML文件中，并通过Mapper接口映射到方法上。
2. 对象关系映射： User对象与数据库中的记录相对应，MyBatis自动将查询结果映射为User对象。
3. 动态SQL： 在复杂查询中可以使用动态SQL标签（未在此示例中展示），比如<if>、<foreach>等。