在此之前我们需要知道Maven和依赖是什么。

什么是Maven？

Maven 是一个项目管理和构建自动化工具，最初由Apache软件基金会开发，主要用于Java项目的构建、依赖管理、文档生成和发布。Maven使用一种基于XML的配置文件（pom.xml）来描述项目的结构、依赖关系和其他构建信息。

Maven的主要用途

1. 依赖管理:

   • Maven可以自动下载和管理项目所需的外部库（依赖项），并将它们放入项目的classpath中，简化了依赖的管理过程。

2. 项目构建:

   • Maven提供了一系列标准的构建生命周期（如 clean、compile、test、package、install 等），开发者只需执行简单的命令即可完成复杂的构建任务。

3. 项目文档生成:

   • Maven可以自动生成项目文档，包括Javadoc文档、测试报告等。

4. 发布管理:

   • Maven支持将构建好的工件（如JAR、WAR文件）发布到本地或远程仓库，方便团队协作和部署。

在Maven中什么是依赖？

在Maven中，依赖是指项目所需的外部库或模块。这些外部库通常是由第三方开发者或组织提供的，用于实现特定的功能或特性。通过引入这些依赖，开发者可以重用已有的代码，避免重复造轮子，从而提高开发效率。

Maven中依赖的具体作用

1. 代码重用:

   • 通过引入依赖，开发者可以重用已有的库和框架，减少代码量，提高开发效率。

2. 功能扩展:

   • 依赖可以帮助项目快速集成新的功能模块。例如，通过引入数据库驱动依赖，可以轻松连接和操作数据库。

3. 版本管理:

   • Maven可以帮助管理依赖的版本，自动下载并管理不同版本的库，确保项目在不同环境中的一致性。

4. 构建自动化:

   • 依赖管理是Maven构建过程的重要组成部分。Maven会根据pom.xml文件中的依赖配置，自动下载并配置项目所需的所有依赖项。

Maven中依赖的配置示例

在Maven的pom.xml文件中，依赖通过<dependencies>标签进行配置。每个依赖项都由一个<dependency>标签定义，具体如下：

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.14</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>3.8.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

• <groupId>: 定义了依赖的组织标识，通常是库的发布者或组织。
• <artifactId>: 定义了依赖的唯一标识，通常是库的名称。
• <version>: 定义了依赖的具体版本。
• <scope>: 可选，定义了依赖的作用范围，如compile（默认）、test、provided等。

1、首先在项目根目录下的pom.xml文件中引入依赖

<dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.14</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

这段代码是一个Maven项目的pom.xml文件的一部分，主要定义了项目的依赖（<dependencies>）和构建配置（<build>）。

1.1. <dependencies> 部分

<dependencies> 标签内定义了项目所依赖的库（即依赖项）。每个依赖项都通过 <dependency> 标签来定义，具体如下：

1.1.1 <dependency> - MyBatis

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.14</version>
</dependency>

• <groupId>: 定义了项目的组织标识，这里是 org.mybatis，表示这个库是由 MyBatis 组织提供的。
• <artifactId>: 定义了项目的唯一标识，这里是 mybatis，表示这个库是一个 MyBatis 框架的核心库。
• <version>: 定义了库的具体版本，这里是 3.5.14，表示使用 MyBatis 3.5.14 版本。

作用: 这个依赖项引入了 MyBatis 框架，MyBatis 是一个持久层框架，用于简化数据库操作，提供了一种将 SQL 语句与 Java 对象映射的方式。

1.1.2 <dependency> - MySQL Connector

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
</dependency>

• <groupId>: 定义了项目的组织标识，这里是 mysql，表示这个库是由 MySQL 官方提供的。
• <artifactId>: 定义了项目的唯一标识，这里是 mysql-connector-java，表示这个库是一个 MySQL 数据库的 Java 驱动。
• <version>: 定义了库的具体版本，这里是 8.0.33，表示使用 MySQL 驱动的 8.0.33 版本。

作用: 这个依赖项引入了 MySQL 数据库的 Java 驱动，用于在 Java 应用中连接和操作 MySQL 数据库。

1.1.3 <dependency> - JUnit（可选）

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>3.8.1</version>
    <scope>test</scope>
</dependency>

• <groupId>: 定义了项目的组织标识，这里是 junit，表示这个库是由 JUnit 组织提供的。
• <artifactId>: 定义了项目的唯一标识，这里是 junit，表示这个库是一个 JUnit 测试框架的核心库。
• <version>: 定义了库的具体版本，这里是 3.8.1，表示使用 JUnit 3.8.1 版本。
• <scope>: 定义了库的作用范围，这里是 test，表示这个库仅在测试阶段使用。

作用: 这个依赖项引入了 JUnit 测试框架，用于编写和运行单元测试。<scope>test</scope> 表示这个依赖仅在测试阶段有效，不会打包到最终的发布包中。

1.2. <build> 部分

要想知道<build>标签的作用，先要看一下下面内容：

1.2.1Maven 构建过程概述

在 Maven 中，构建一个项目通常涉及几个步骤，其中包括：

1. 编译代码：将 .java 文件编译成 .class 文件。
2. 处理资源文件：将项目中的资源文件（例如配置文件、图像等）复制到输出目录。
3. 打包：将编译后的代码和资源文件打包成最终的输出（例如 JAR 或 WAR 文件）。

资源文件的管理

• 资源文件 是那些在程序运行时需要用到的文件，通常是配置文件（如 .properties、.xml）、静态资源（如图片、HTML 文件）等。这些文件不需要编译，但是在程序运行时必须能够访到。

为什么需要包含资源文件到构建输出中？

在 Java 应用程序中，运行时可能会需要访问这些文件以获取配置信息或其他数据。如果这些资源文件没有被包含在最终的构建输出中，程序在运行时就无法找到这些文件，从而导致错误或不正确的行为。

含义详解

1. build 标签

在 Maven 的 pom.xml 文件中，<build> 标签用于配置构建行为。这个标签可以包含许多设置，包括要编译的源代码目录、要处理的资源文件等。

2. resources 标签

<resources> 标签专门用于配置哪些文件应该被视为资源文件。这些文件在构建过程中会被处理（通常是复制到某个输出位置），以便它们能够在应用程序运行时被访问到。

3. resource 标签内的配置

• <directory>：指定包含资源文件的目录。在下面例子中，指定了 src/main/java，这意味着我们将在这个目录中寻找资源文件，即 .properties 和 .xml 文件。

• <includes> 和 <include>：这部分配置告诉 Maven 哪些具体的文件需要被包含在构建输出中。在例子中，所有的 .properties 和 .xml 文件将会被包括在内。这里的匹配模式 **/*.properties 和 **/*.xml 表示在指定的目录及其子目录中找到所有的这些文件。

资源文件的复制

在构建阶段，Maven 会执行资源处理机制：

1. 查找资源：根据 pom.xml 中的 <resources> 配置，Maven 会查找 src/main/java 目录中所有的 .properties 和 .xml 文件。

2. 复制到输出目录：Maven 会将找到的这些文件复制到构建输出目录，通常是 target/classes。这个目录是 JVM 运行时会查找类和资源文件的地方。

3. 最终输出：当执行 Maven 的 package 命令时，Maven 会将 target/classes 中的所有 .class 文件和复制过来的资源文件一起打包成一个可分发的构件（例如 JAR 文件）。这就确保了在运行该构件时，资源文件是可用的。

示例

假设有以下结构：

project
│
├─ src
│   └─ main
│       ├─ java
│       │   └─ your/package
│       │       └─ YourClass.java
│       └─ resources
│           ├─ db.properties       //这个是配置文件,包括数据库的配置等等等
│           └─ mybatis-config.xml  //核心配置文件，下面会讲
└─ pom.xml 

如果在 pom.xml 中配置如下：

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

构建过程的具体步骤

1. 编译 Java 文件：YourClass.java 被编译成 YourClass.class。
2. 处理资源文件：
   • 检查 src/main/resources 目录，寻找所有的 .properties 和 .xml 文件。
   • 找到 db.properties 和 mybatis-config.xml，将它们复制到 target/classes。
3. 打包：在执行 mvn package 后，Maven 会把 target/classes 下的 YourClass.class、db.properties 和 mybatis-config.xml 一起打包到最终的 JAR 文件中。

2、然后在main/resources/中创建db.properties文件

文件内容如下：

mysql.driver=com.mysql.cj.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
mysql.username=root
mysql.password=123456

在Java项目中，db.properties 文件是一个常见的配置文件，它用于存储数据库连接的相关参数。这样做的主要优点是可以将配置信息与代码分离，从而提高代码的可维护性和灵活性。特别是在使用框架（如 MyBatis）时，这种配置文件尤为常见。

2.1. mysql.driver=com.mysql.cj.jdbc.Driver

• mysql.driver：

  • 这是一个键（key），指定了数据库驱动的配置项。
  • mysql.driver 表示用于连接MySQL数据库的JDBC驱动程序。

• com.mysql.cj.jdbc.Driver：

  • 这是键对应的值（value），指定实际的JDBC驱动类。
  • com.mysql.cj.jdbc.Driver 是MySQL Connector/J驱动程序的类名。cj 表示这是较新的MySQL连接器版本（对应于Java8及以上版本）。旧版本的驱动类名是 com.mysql.jdbc.Driver。

2. mysql.url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false

• mysql.url：

  • 这是另一个键，指定了连接到数据库的URL。
  • mysql.url 表示数据库连接的URL。

• jdbc:mysql://localhost:3306/mybatis：

  • jdbc：JDBC协议的前缀，表示这是一个JDBC连接。
  • mysql：表示使用的数据库类型是MySQL。
  • localhost：数据库服务器的主机名或IP地址，这里指的是本地主机。
  • 3306：MySQL服务的端口号。
  • mybatis：这是一个数据库的名称，表示连接到名为 mybatis 的数据库。

• ?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false：

  • 这是一个查询字符串（query string），包含连接参数。
  • serverTimezone=UTC：指定服务器时区为UTC（协调世界时）。
  • characterEncoding=utf8：指定字符编码为UTF-8，确保数据传输过程中的字符编码正确。
  • useUnicode=true：表示使用Unicode字符集进行通信。
  • useSSL=false：表示不使用SSL进行连接。

3. mysql.username=root

• mysql.username：

  • 这是另一个键，指定了数据库连接的用户名。
  • mysql.username 表示连接数据库时使用的用户名。

• root：

  • 这是键对应的值，指定数据库的用户名。
  • root 是MySQL数据库的默认超级用户名。

4. mysql.password=123456

• mysql.password：

  • 这是另一个键，指定了数据库连接的密码。
  • mysql.password 表示连接数据库时使用的密码。

• 123456：

  • 这是键对应的值，指定了数据库的密码。
  • 123456 是一个示例密码，实际项目中应使用更加安全的密码。

3、然后需要在项目的src/main/resources目录下创建MyBatis的核心配置文件mybatis-config.xml，主要用于项目的环境配置，如数据库连接等相关配置。

注意，初次使用肯能需要自己设置一个核心配置文件的模板，步骤如下：

1、点击settings...

2、选择Editor

3、找到Code Style下的File and Code Templates

4、首先先点击+添加模板、然后将Name修改称自己起的名字，吧后缀修改为xml，然后再下面写好内容，然后点击Apply、OK

具体内容如下：

下面时我本人自己的配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <properties resource="db.properties"/>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${mysql.driver}"/>
        <property name="url" value="${mysql.url}"/>
        <property name="username" value="${mysql.username}"/>
        <property name="password" value="${mysql.password}"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  </mappers>
</configuration>

官网的配置模板如下：

官网：mybatis – MyBatis 3 | 入门 (p2hp.com)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  </mappers>
</configuration>

3.1每个标签的作用

3.1.1. <configuration>

<configuration>
  <!-- 配置内容 -->
</configuration>

• 作用：这是 MyBatis 配置文件的根元素。所有的MyBatis配置内容都放在这个元素内部。它是整个配置的起点。

3.1.2. <environments>

<environments default="development">
  <!-- environment 元素 -->
</environments>

• 作用：用于定义 MyBatis 支持的不同环境（如开发、测试、生产等）。
• 属性：
  • default：指定默认使用的环境ID。当 MyBatis 初始化时，如果没有明确指定环境，程序将使用这里定义的默认环境。

3.1.3. <environment>

<environment id="development">
  <!-- transactionManager 和 dataSource 元素 -->
</environment>

• 作用：定义一个具体的环境配置。每个环境都有其独特的事务管理器和数据源配置。
• 属性：
  • id：环境的唯一标识符。可以任意命名，但必须在 <environments> 内唯一。

3.1.4. <transactionManager>

<transactionManager type="JDBC"/>

• 作用：配置事务管理器，决定了如何处理数据库事务。
• 属性：
  • type：指定使用的事务管理器的类型。常用的类型包括：
    • JDBC：直接使用JDBC进行事务管理，适合简单的数据库操作。
    • MANAGED：用于服务器端事务管理，通常在容器（如Spring）管理的环境中使用。

3.1.5. <dataSource>

<dataSource type="POOLED">
  <!-- property 元素 -->
</dataSource>

• 作用：定义数据库的数据源，主要用于连接数据库。
• 属性：
  • type：指定数据源的类型。常用类型包括：
    • POOLED：使用连接池来管理数据库连接，提高性能。
    • UNPOOLED：每次请求新建数据库连接，不会使用连接池。
    • JNDI：通过Java命名和目录接口（JNDI）获取数据源，适用于托管环境。

3.1.6. <property>

<property name="driver" value="${driver}"/>

• 作用：用于为数据源配置具体的属性。
• 属性：
  • name：属性的名称，例如数据库驱动、URL、用户名和密码等。
  • value：属性的值，可以直接写值，也可以使用占位符（如 ${driver}），在运行时从外部配置文件中动态获取值。

注意：在 MyBatis 的 <property> 标签中，name 属性用于指定数据源的具体属性的名称。根据 MyBatis 的官方文档和实际使用情况，常见的 name 属性值包括以下几类：

• driver:

  • 作用：指定数据库驱动的类名。
  • 示例：<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
  • 说明：用于指定数据库驱动类，如 MySQL 的 com.mysql.cj.jdbc.Driver。

• url:

  • 作用：指定数据库连接的 URL。
  • 示例：<property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
  • 说明：用于指定数据库连接的URL，格式通常为 jdbc:subprotocol:subname。

• username:

  • 作用：指定数据库连接的用户名。
  • 示例：<property name="username" value="root"/>
  • 说明：用于指定连接数据库时使用的用户名。

• password:

  • 作用：指定数据库连接的密码。
  • 示例：<property name="password" value="secret"/>
  • 说明：用于指定连接数据库时使用的密码。

如果使用连接池数据源（type="POOLED"），还可以配置连接池的一些属性：

• poolMaximumActiveConnections:

  • 作用：指定连接池中允许的最大活动连接数。
  • 示例：<property name="poolMaximumActiveConnections" value="10"/>
  • 说明：连接池中可同时使用的最大连接数。

• poolMaximumIdleConnections:

  • 作用：指定连接池中允许的最大空闲连接数。
  • 示例：<property name="poolMaximumIdleConnections" value="5"/>
  • 说明：连接池中允许保持空闲的最大连接数。

• poolMaximumCheckoutTime:

  • 作用：指定连接在被强制回收前的最大存活时间。
  • 示例：<property name="poolMaximumCheckoutTime" value="20000"/>
  • 说明：连接在被强制回收前的最大存活时间，单位为毫秒。

• poolTimeToWait:

  • 作用：指定连接池在等待可用连接时的等待时间。
  • 示例：<property name="poolTimeToWait" value="20000"/>
  • 说明：连接池在等待可用连接时的等待时间，单位为毫秒。

• poolPingQuery:

  • 作用：指定连接池用于检测连接是否可用的SQL查询。
  • 示例：<property name="poolPingQuery" value="SELECT 1"/>
  • 说明：用于检测连接是否可用的SQL查询语句。

• poolPingEnabled:

  • 作用：指定是否启用连接池的连接检测。
  • 示例：<property name="poolPingEnabled" value="true"/>
  • 说明：是否启用连接池的连接检测功能。

• poolPingConnectionsNotUsedFor:

  • 作用：指定连接池检测连接的频率。
  • 示例：<property name="poolPingConnectionsNotUsedFor" value="60000"/>
  • 说明：连接池检测连接的时间间隔，单位为毫秒。

• autoCommit:

  • 作用：指定是否自动提交事务。
  • 示例：<property name="autoCommit" value="true"/>
  • 说明：是否在每次SQL执行后自动提交事务，true 表示自动提交，false 表示手动提交。

• defaultTransactionIsolationLevel:

  • 作用：指定默认的事务隔离级别。
  • 示例：<property name="defaultTransactionIsolationLevel" value="READ_COMMITTED"/>
  • 说明：设置默认的事务隔离级别，如 READ_COMMITTED、REPEATABLE_READ 等。

3.1.7. <mappers>

<mappers>
  <!-- mapper 元素 -->
</mappers>

• 作用：用于定义 SQL 映射文件，也就是 Mapper 的配置。这些映射文件通常包含 SQL 语句和 Java 对象之间的映射关系。

3.1.8. <mapper>

<mapper resource="org/mybatis/example/BlogMapper.xml"/>

• 作用：定义具体的映射文件。
• 属性：
  • resource：指定映射文件的路径，通常是相对路径，如 org/mybatis/example/BlogMapper.xml。MyBatis 会根据这个路径加载对应的 Mapper 映射文件。

至此基本配置完成！！！

如何使用

下面再讲一下如何使用：

我们知道java中的基本元素可以说成类，就像C语言是函数。我们在开发过程中经常使用面向对象的思想进行开发。我们可以把数据库中的一个表的格式映射为一个对象，这其实叫“对象关系映射”。为什么要这么做呢？

**对象关系映射（ORM, Object-Relational Mapping）**是一种编程技术，可将对象模型（通常是在面向对象编程中的模型）与关系数据库之间的关系进行映射。它允许开发人员在使用面向对象的编程语言（如 Java）时，以对象的形式来操作数据，而不需要直接操作数据库中的 SQL 语句。

ORM 的优点

1. 简化数据库操作：开发人员可以通过操作 Java 对象（POJO）来自动化数据库的插入、查询、更新和删除（CRUD）操作，而不需要编写大量的 SQL 语句。

2. 结构清晰：ORM 将数据与业务逻辑分开，使代码更易于管理和维护。

3. 加强数据一致性：ORM 框架通常会负责数据验证和转换，确保在数据持久化期间的一致性和完整性。

4. 减少代码冗余：ORM 可以生成大部分数据库操作代码，减少手动重复编写相似代码的需要。

5. 支持多种数据库：有使用 ORM 的框架可以很容易地在不同的数据库之间进行更换，只需调整一些配置，而无需重写大部分代码。

POJO 类

**POJO（Plain Old Java Object）**是一个简单的 Java 对象，通常不包含任何用于特定框架的内容（例如注解、继承等），是独立于任何特定 Java 类库或框架的纯 Java 类。POJO 类通常具备以下特征：

• 只有属性（变量），没有任何业务逻辑。
• 拥有无参和带参构造函数。
• 提供 getter 和 setter 方法，允许外部访问和修改私有字段。
• 这个类要在src/main/java/*下面

比如有下面的表users：

uid	uname	uage
1	张三	25
2	李四	23
3	王五	24

我们就可以建立一个对象（一般我们单独创建一个包，叫POJO类，然后在POJO下面建立一个类叫User）

public class User {
    private int uid;      // 用户ID
    private String uname; // 用户名
    private int uage;     // 用户年龄

    // 无参构造器
    public User() {}

    // 带参构造器
    public User(int uid, String uname, int uage) {
        this.uid = uid;
        this.uname = uname;
        this.uage = uage;
    }

    // Getter 和 Setter 方法
    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public int getUage() {
        return uage;
    }

    public void setUage(int uage) {
        this.uage = uage;
    }
}

数据库查询

虽然我们有了映射的类，但是我们还没有进行数据库查询，想一下，我们接下来要干什么？要建立一个映射文件，将从数据库查到的数据映射为这个类。

一般来说，我们会在src/main/resources下建立一个mapper文件夹,单独存放映射文件。

然后我们建立一个UserMapper.xml文件。

一般我们也需要自己建立一个模板，这样以后我们每次建立这个文件就可以只写很少的一部分了，建立模板的过程上面有，这里我们建立一个如下的模板：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.mybatis.example.BlogMapper">
  <select id="selectBlog" resultType="Blog">
    select * from Blog where id = #{id}
  </select>
</mapper>

下面详细讲解一下各种标签的作用：

1. XML 头部信息

<?xml version="1.0" encoding="UTF-8" ?>

• <?xml version="1.0" encoding="UTF-8"?>：这是 XML 声明，指定了 XML 文件的版本（1.0）和字符编码（UTF-8）。

2. DTD 声明

<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

• <!DOCTYPE mapper ...>：定义了文档类型声明（DTD），告诉解析器这个 XML 文件符合 MyBatis Mapper 3.0 的规范。
• PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"：表示这是一个公共 DTD，标识符为 -//mybatis.org//DTD Mapper 3.0//EN。
• "https://mybatis.org/dtd/mybatis-3-mapper.dtd"：指定了 DTD 文件的 URL，用于验证 XML 文件的结构是否符合规范。

3. Mapper 标签

<mapper namespace="org.mybatis.example.UserMapper">

• <mapper>：这是 MyBatis 映射文件的根标签，所有 SQL 映射语句都在这个标签内定义。
• namespace="org.mybatis.example.UserMapper"：指定映射文件的命名空间。通常是与 Java 接口的全限定名相同，用于将 SQL 语句与接口方法进行映射。

4. Select 标签

<select id="selectUser" resultType="User">
  select * from users where uid = #{uid}
</select>

• <select>：定义一个查询语句。
• id="selectUser"：唯一标识符，用于在 Java 代码中引用这个查询语句。通常与接口中的方法名一致。
• resultType="User"：指定查询结果的类型，这里是 User POJO 类。MyBatis 会将查询结果自动映射到这个类的实例。除了类名，还可以使用全限定名或别名。
• select * from users where uid = #{uid}：具体的 SQL 查询语句。#{uid} 是 MyBatis 的参数占位符，表示查询条件，uid 是传入的参数名。

常用的其他标签和属性

1. <insert>

用于定义插入语句：

<insert id="insertUser">
  INSERT INTO users (uid, uname, uage) VALUES (#{uid}, #{uname}, #{uage})
</insert>

• id="insertUser"：插入语句的唯一标识符。
• INSERT INTO users (uid, uname, uage) VALUES (#{uid}, #{uname}, #{uage})：具体的插入 SQL 语句。

2. <update>

用于定义更新语句：

<update id="updateUser">
  UPDATE users SET uname = #{uname}, uage = #{uage} WHERE uid = #{uid}
</update>

• id="updateUser"：更新语句的唯一标识符。
• UPDATE users SET uname = #{uname}, uage = #{uage} WHERE uid = #{uid}：具体的更新 SQL 语句。

3. <delete>

用于定义删除语句：

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

• id="deleteUser"：删除语句的唯一标识符。
• DELETE FROM users WHERE uid = #{uid}：具体的删除 SQL 语句。

4. <resultMap>

用于定义复杂的查询结果映射：

<resultMap id="UserResultMap" type="User">
  <id property="uid" column="uid"/>
  <result property="uname" column="uname"/>
  <result property="uage" column="uage"/>
</resultMap>

<select id="selectUser" resultMap="UserResultMap">
  SELECT uid, uname, uage FROM users WHERE uid = #{uid}
</select>

• <resultMap>：定义复杂的结果映射，适用于字段名与类属性名不一致或需要进行复杂的映射关系的情况。
• id="UserResultMap"：结果映射的唯一标识符。
• type="User"：指定映射的目标类。
• <id> 和 <result>：定义字段与属性的映射关系，column 指定数据库字段名，property 指定 Java 类属性名。

5. <parameterMap>

用于定义参数映射，但一般不常用：

<parameterMap id="UserParameterMap" type="User">
  <parameter property="uid" javaType="int"/>
  <parameter property="uname" javaType="String"/>
  <parameter property="uage" javaType="int"/>
</parameterMap>

<select id="selectUser" parameterMap="UserParameterMap" resultType="User">
  SELECT * FROM users WHERE uid = #{uid}
</select>

• <parameterMap>：定义参数映射，适用于需要精细控制参数类型的情况。
• id="UserParameterMap"：参数映射的唯一标识符。
• type="User"：指定映射的目标类。
• <parameter>：定义参数映射，property 指定 Java 类属性名，javaType 指定 Java 类型。

工作原理

1. 会话工厂（SqlSessionFactory）

作用

• 创建会话对象：SqlSessionFactory 是 MyBatis 的核心接口之一，用于创建 SqlSession 对象。
• 配置管理：它管理 MyBatis 的配置信息，如数据库连接信息、映射文件等。

创建方式

通常通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory：

InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

注意，下面讲一下文件读入的内容：

1. 背景

在使用 MyBatis 时，通常需要一个配置文件（通常是 mybatis-config.xml）来提供数据库的连接信息、映射文件的位置、其他设置等。为了能够读取这个配置文件，我们需要使用 Java 的 InputStream 类。

2. 代码解析

InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");

各部分功能解释：

• Resources：

  • Resources 是 MyBatis 提供的一个工具类，用于方便地加载资源（如配置文件、映射文件等）。它提供了一些静态方法来查找和加载这些资源。

• getResourceAsStream 方法：

  • getResourceAsStream 方法会根据传入的字符串参数（即资源的路径）返回一个输入流（InputStream）对象。这个输入流可以读取指定资源的内容。
  • 方法的参数是相对于类路径的资源名称，所以 "mybatis-config.xml" 表示在类路径下搜寻 mybatis-config.xml 文件。

• "mybatis-config.xml"：

  • 这是要加载的 MyBatis 配置文件的名称，它通常是放在项目的 src/main/resources 目录下（如果你是在使用 Maven 项目的话），因为在打包时，这个目录的内容会被放到类路径中。

• InputStream inputStream：

  • 这部分声明了一个 InputStream 类型的变量 inputStream，用于存放读取到的资源流内容。通过这个流，你可以后续将它传递给 SqlSessionFactoryBuilder 来构建一个 SqlSessionFactory 对象。

3. 示例：如何使用

在一个典型的 MyBatis 应用程序中，可能会有如下代码结构：

import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisExample {
    public static void main(String[] args) {
        try {
            // 1. 加载 MyBatis 配置文件
            InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");

            // 2. 创建 SqlSessionFactory
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

            // 3. 开启 SqlSession 等后续操作...
            // ...

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. 会话对象（SqlSession）

作用

• 执行 SQL 语句：通过 SqlSession 对象可以直接执行 SQL 语句，如 select、insert、update、delete 等。
• 获取 Mapper 接口实例：SqlSession 可以获取 Mapper 接口的实例，通过接口方法来执行数据库操作。

使用示例

try (SqlSession session = sqlSessionFactory.openSession()) {
    User user = session.selectOne("org.mybatis.example.UserMapper.selectUser", 1);
    System.out.println(user);
}

3. 执行器（Executor）

作用

• 执行 SQL 语句：Executor 是 MyBatis 的底层接口，负责执行具体的 SQL 语句。
• 事务管理：Executor 还负责事务的管理和提交。

类型

MyBatis 提供了几种不同的 Executor 实现：

• SimpleExecutor：每次执行 SQL 语句时都会创建新的 Statement 对象。
• ReuseExecutor：重用 Statement 对象，减少资源消耗。
• BatchExecutor：批量执行 SQL 语句，适用于大批量数据操作。

4. 映射信息（Mapper）

作用

• SQL 语句映射：映射文件（如 UserMapper.xml）中定义了 SQL 语句与 Java 方法的映射关系。
• 结果映射：将查询结果映射为 Java 对象。

示例

<mapper namespace="org.mybatis.example.UserMapper">
  <select id="selectUser" resultType="User">
    select * from users where uid = #{uid}
  </select>
</mapper>

5. 工作流程

1. 创建 SqlSessionFactory：通过 SqlSessionFactoryBuilder 读取配置文件并创建 SqlSessionFactory。
2. 开启 SqlSession：使用 SqlSessionFactory 创建 SqlSession 对象。
3. 执行 SQL 操作：通过 SqlSession 执行 SQL 语句或获取 Mapper 接口实例并调用接口方法。
4. 映射结果：MyBatis 将查询结果映射为指定的 Java 对象。
5. 关闭 SqlSession：操作完成后关闭 SqlSession，释放资源。

6. 核心组件关系图

+-------------------+        +-------------------+
| SqlSessionFactory | -----> |    SqlSession     |
+-------------------+        +-------------------+
        ^                              |
        |                              |
        |                              v
        |                      +--------------+
        |                      |   Executor   |
        |                      +--------------+
        |                              |
        |                              |
        |                              v
+-------------------+        +-------------------+
|  Mapper XML File  | -----> |   MapperProxy   |
+-------------------+        +-------------------+

7. 代码示例

// 1. 创建 SqlSessionFactory
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

// 2. 开启 SqlSession
try (SqlSession session = sqlSessionFactory.openSession()) {
    // 3. 执行 SQL 操作
    UserMapper mapper = session.getMapper(UserMapper.class);
    User user = mapper.selectUser(1);
    System.out.println(user);

    // 4. 关闭 SqlSession
}

至此：本文结束！！！