MyBatis SQL 映射文件基础

一、MyBatis SQL 映射文件简介

一、MyBatis SQL 映射文件简介

在 Java 持久层框架的广阔天地里，MyBatis 无疑是一颗璀璨的明星，备受开辟者青睐。它宛如一座结实的桥梁，奇妙地毗连着 Java 应用程序与数据库，让数据的交互变得顺畅无阻。而在 MyBatis 的体系架构中，SQL 映射文件更是扮演着举足轻重的角色，犹如一位幕后好汉，默默支持着整个数据访问层的高效运转。
SQL 映射文件，简单来说，就是存放 SQL 语句的关键所在，它承载着 Java 对象与数据库表之间沟通的使命。通过将 SQL 语句从繁杂的 Java 代码中剥离出来，独立存储于 XML 文件中，MyBatis 为我们带来了诸多明显上风。一方面，代码的耦合度大幅低落，使得程序布局更加清晰，易于维护。当 SQL 语句需要调整时，无需在浩如烟海的 Java 代码中苦苦寻觅，只需在对应的映射文件中精准修改，如同在有序的文档库中查找资料，高效便捷。另一方面，这种分离为 SQL 调优开辟了绿色通道。开辟人员可以专注于 SQL 语句的优化，尽情施展数据库调优的本领，而不用担心影响到其他业务逻辑代码，为提拔系统性能提供了有力保障。
二、核心元素全解析

（一）<mapper>标签：定名空间的定义者

在深入探究 MyBatis SQL 映射文件的奥妙世界时，我们起首会邂逅至关重要的<mapper>标签。它宛如一座巍峨大厦的基石，作为整个映射文件的根元素，承载着不可或缺的使命。其核心属性namespace，更是起着关键的定名空间定义作用，犹如为每个 Mapper 文件赋予了独一无二的身份证。通过将namespace精准设置为对应的 Mapper 接口全限定名，MyBatis 能够在茫茫代码海洋中，迅速而准确地创建起 SQL 语句与 Java 方法之间的细密关联。这种一一对应的绑定关系，就像是为数据的交互搭建了一条条专属的高速通道，确保了操纵的精准性与高效性。当我们在大型项目中穿梭，面对浩繁繁杂的 Mapper 文件时，namespace的独特标识作用愈发凸显，它能让我们轻松定位到目的代码，极大地提拔了代码的可维护性与可读性。
（二）<select>元素：查询语句的载体

在 MyBatis 的 SQL 映射文件里，<select>标签无疑是一颗闪耀的明星，负担着承载查询语句的重任。它就像一位精准的导航员，引领着我们从数据库的浩瀚海洋中获取所需的数据。
先来看它的诸多属性，各个都有着独特的作用。其中，id属性宛如标签的身份证号，必须具备唯一性，它与 Mapper 接口中的方法名精准对应，使得 Java 代码在调用时能够迅速找到目的查询语句，就像在电话簿中通过姓名快速定位接洽人一样便捷。parameterType属性则像是一座桥梁，负责指定传入参数的类型，让 Java 数据能够顺利地过渡到 SQL 语句的世界中，无论是简单的基本数据类型，照旧复杂的自定义对象，它都能完美适配，确保数据传递的准确性。而resultType和resultMap属性，如同两位风格迥异的设计师，掌控着查询结果的出现形式。resultType擅长简洁明了，当查询结果能够直接映射到简单的 Java 对象，如常见的String、Integer，或是拥有简单属性的自定义实体类时，它便能大显身手，自动完成数据的封装，将数据库中的记录迅速转化为可用的 Java 对象，就像把原材料直接加工成尺度化的制品。而resultMap则像是一位精致的工匠，专为处理复杂的映射关系而生。当数据库表的字段名与 Java 对象的属性名不完全匹配，或是涉及到多表关联查询，结果会合包含了复杂的嵌套对象时，resultMap便能发挥其强大的定制化映射能力，通过精心配置，将每一个字段都精准地安置到对应的 Java 对象属性中，确保数据的完备性与准确性。
举个生动的例子，假设我们有一个简单的用户信息查询场景，只需要获取用户的姓名和年龄，且数据库表字段与 Java 对象属性完全一致，此时使用resultType便能轻松搞定：

1. [/code] <select id="getUserNameAndAge" parameterType="int" resultType="com.example.User">
2. select name, age from user where id = #{id}
3. </select>
4. 而在另一个复杂的业务场景中，我们需要查询订单信息以及关联的用户信息、商品信息，涉及多表关联，字段名也不尽相同，这时resultMap就会挺身而出，通过过细的配置，将复杂的数据完美地映射到对应的 Java 对象中，构建出完备的业务模子，满足系统对数据的精准需求。
5. [size=3]（三）<insert>、<update>、<delete>元素：数据变更的执行者[/size]
7. <insert>、<update>、<delete>这三个元素，如同三位英勇的战士，在 MyBatis 的世界里负担着执行数据变更操纵的重任，它们的布局有着诸多相似之处，都围绕着对数据库数据的增、改、删核心使命而设计。
8. 以<insert>为例，它身上有着一些独特的属性，在特定场景下发挥着关键作用。useGeneratedKeys和keyProperty这两个属性组合，就像是一对默契的搭档，专为应对主键生成的情况而生。当我们使用的数据库支持主键自动生成，如 MySQL 的自增主键时，将useGeneratedKeys设置为true，就像是打开了一扇获取主键值的大门，MyBatis 会自动启用 JDBC 的相关机制，在数据插入乐成后，精准地获取到由数据库内部生成的主键值。而keyProperty则像是一个精准的导航标，明确指定这个获取到的主键值应该映射到 Java 对象的哪个属性中，确保数据的一致性与完备性，方便后续业务逻辑对主键的引用。
9. 下面通过一些具体示例，来看看它们在现实应用中的强大威力。在用户注册功能中，使用<insert>标签插入新用户数据：
10. [code]

复制代码

<insert id="addUser" parameterType="com.example.User" useGeneratedKeys="true" keyProperty="id">
insert into user (name, password, email) values (#{name}, #{password}, #{email})
</insert>
这段代码清晰地展示了如安在插入用户数据的同时，奇妙获取自动生成的主键值，并将其赋值给用户对象的id属性。而在更新用户信息时，<update>标签大显身手：

1. [/code] <update id="updateUserInfo" parameterType="com.example.User">
2. update user set name = #{name}, password = #{password}, email = #{email} where id = #{id}
3. </update>
4. 它能够精准地根据传入的用户对象，将对应的信息更新到数据库中，确保数据的及时性与准确性。当需要删除用户数据时，<delete>标签简洁而有力：
5. [code]

复制代码

<delete id="deleteUserById" parameterType="int">
delete from user where id = #{id}
</delete>
只需指定要删除的用户id，就能迅速从数据库中清算掉对应的记录，维护数据的整洁性。这些示例充分显现了这三个元素在数据变更操纵中的高效与便捷，是构建健壮数据层的得力工具。
（四）<sql>元素：可复用 SQL 片断的容器

<sql>标签宛如一位聪明的工匠，在 MyBatis 的世界里精心打造着可重用的 SQL 模块。它允许我们将那些频仍出现在 SQL 语句中的公共部分，如通用的字段列表、复杂的查询条件片断等，奇妙地提取出来，封装成一个个独立的、可复用的 SQL 块。就像是将建筑中的通用组件提前预制好，随时等候组装。
而<include>标签，则像是一把神奇的钥匙，能够开启复用之门。它可以在其他 SQL 语句中机动引用由<sql>标签定义的 SQL 片断，通过简单的配置，将这些预制好的组件精准地嵌入到需要的地方，实现代码的高度复用。这种复用机制带来的好处是显而易见的，它不但极大地进步了代码的编写效率，避免了重复劳动，还使得代码的维护变得更加轻松愉悦。当业务需求发生变革，需要调整公共 SQL 部分时，我们只需在<sql>标签定义处举行修改，全部引用该片断的地方都会同步更新，仿佛牵一发而动满身，确保了数据操纵的一致性。
例如，在一个多表关联查询的复杂场景中，我们需要频仍查询多个表的公共字段。此时，就可以使用<sql>标签定义一个包含这些公共字段的 SQL 片断：

1. [/code] <sql id="commonColumns">
2. a.id, a.name, b.age, c.address
3. </sql>
4. 然后，在具体的查询语句中，通过<include>标签轻松引用：
5. [code]

复制代码

<select id="getComplexData" resultType="com.example.ComplexResult">
select <include refid="commonColumns"/>
from table_a a
inner join table_b b on a.id = b.a_id
inner join table_c c on a.id = c.a_id
where a.status = #{status}
</select>
通过这种方式，复杂的 SQL 语句变得简洁明了，易于管理，为高效的数据查询奠定了坚实基础。
（五）<resultMap>元素：复杂映射的解决方案

<resultMap>标签犹如一位细密的映射大师，在 MyBatis 的舞台上显现着强大的定制化映射能力。它专为应对那些复杂的数据映射场景而设计，当数据库查询结果无法直接简单映射到 Java 对象时，<resultMap>便能挺身而出，发挥其独特的魔力。
分析<resultMap>标签的内部布局，会发现它包含了诸多精妙的子元素，每个子元素都有着明确的分工。constructor元素像是一位精准的建筑师，它能够根据查询结果，奇妙地调用 Java 对象的构造方法举行实例化，通过指定参数的顺序和类型，精准地构建出符合业务需求的对象实例。association元素则像是一位精致的红娘，专注于处理一对一的关联关系，好比在查询用户信息时，关联查询用户的具体所在信息，它能够将所在对象精准地嵌入到用户对象中，构建出完备的用户资料模子。collection元素宛如一位高效的收纳大师，擅长处理一对多的关联场景，例如查询部分信息时，一并获取该部分下的全部员工信息，它能够将多个员工对象有序地收纳进一个聚会合，方便后续业务逻辑的处理。
在现实的复杂查询场景中，这些子元素的协同作用显现出了无与伦比的魅力。以一个经典的电商订单查询为例，查询一个订单时，不但需要获取订单的基本信息，还需要关联查询下单用户的具体信息，以及订单包含的多个商品详情。此时，<resultMap>标签便能精心构建出一个复杂而精准的映射关系：

1. [/code] <resultMap id="orderResultMap" type="com.example.Order">
2. <id property="id" column="order_id"/>
3. <result property="orderNo" column="order_no"/>
4. <result property="createTime" column="create_time"/>
5. <association property="user" javaType="com.example.User">
6. <id property="id" column="user_id"/>
7. <result property="username" column="username"/>
8. <result property="email" column="email"/>
9. </association>
10. <collection property="orderItems" ofType="com.example.OrderItem">
11. <id property="id" column="item_id"/>
12. <result property="productName" column="product_name"/>
13. <result property="quantity" column="quantity"/>
14. </collection>
15. </resultMap>
16. <select id="getOrderById" resultMap="orderResultMap">
17. select o.order_id, o.order_no, o.create_time,
18. u.user_id, u.username, u.email,
19. i.item_id, i.product_name, i.quantity
20. from orders o
21. left join users u on o.user_id = u.user_id
22. left join order_items i on o.order_id = i.order_id
23. where o.order_id = #{id}
24. </select>
25. 在这段代码中，<resultMap>通过奇妙配置，将来自多个表的字段精准地映射到了Order对象及其关联的User对象、OrderItem聚会合，构建出了一个完备的订单业务模子，为电商系统的订单管理提供了强大的数据支持，充分显现了 MyBatis 在复杂数据处理方面的良好能力。
26. [size=4]三、参数传递与取值的门道[/size]
28. [size=3]（一）单个参数传递[/size]
30. 在 MyBatis 的世界里，单个参数传递是最基础的操纵之一。当我们面对的是单个基本类型参数，好比一个简单的int型用户id，在 SQL 映射文件的<select>语句中，使用#{参数名}就能轻松获取参数值，此时参数名可以随意誊写，因为 MyBatis 能够自动辨认。就像如许：
31. [code]

复制代码

<select id="getUserById" parameterType="int" resultType="com.example.User">
select * from user where id = #{anyName}
</select>
这里的anyName无论写成什么，只要在对应的 Mapper 接口方法中传入正确的int型参数，MyBatis 都能准确地将其与 SQL 语句中的占位符对应起来，从数据库中捞出对应id的用户信息。
而当参数为引用类型，例如一个包含用户各种属性的User对象时，情况稍有差别。此时，在 SQL 语句里必须使用对象的属性名来取值，即#{属性名}。假设User对象有username和password属性，我们要根据用户名查询用户信息，代码如下：

1. [/code] <select id="getUserByUsername" parameterType="com.example.User" resultType="com.example.User">
2. select * from user where username = #{username}
3. </select>
4. MyBatis 会通过反射机制，精准地从传入的User对象中获取username属性的值，用以构建查询条件，确保数据查询的准确性。这种机动又严谨的参数传递机制，为差别场景下的数据交互提供了便利。
5. [size=3]（二）多个参数传递[/size]
7. 当涉及多个参数传入 SQL 语句时，MyBatis 有着独特的处理方式。假如不做任何特别处理，MyBatis 会将多个参数自动封装成一个Map，其中Map的键默认是arg0、arg1…… 大概param1、param2…… ，值就是对应的参数值。但这种默认方式在现实开辟中存在毛病，可读性较差，开辟人员很难直接从键名看出对应参数的含义。
8. 为相识决这个问题，MyBatis 提供了@Param注解。通过在 Mapper 接口方法的参数前添加@Param("指定的key值")，MyBatis 会将参数封装进Map时，使用我们指定的key值，使得 SQL 语句中的参数取值更加清晰易懂。好比，我们要根据用户的id和username查询用户信息，使用@Param注解的代码如下：
9. [code]

复制代码

public interface UserMapper {
User getUserByIdAndUsername(@Param("id") int id, @Param("username") String username);
}
对应的 SQL 映射文件：

1. [/code] <select id="getUserByIdAndUsername" resultType="com.example.User">
2. select * from user where id = #{id} and username = #{username}
3. </select>
4. 如许，无论是开辟人员后续维护代码，照旧阅读代码逻辑，都能一览无余地知道每个参数的用途，大大进步了代码的可读性与可维护性。在现实项目中，面对多个参数的情况，发起优先使用@Param注解，为代码的妥当性和协作性保驾护航。
5. [size=3]（三）参数取值方式：#{} 与 ${} 的差异[/size]
7. 在 MyBatis 的 SQL 映射文件中，参数取值有两种至关重要的方式：#{}与${}，它们虽看似相近，实则有着天壤之别。
8. #{}是一种预编译的取值方式，它就像是一位严谨的卫士，能有效防止 SQL 注入攻击。当使用#{}时，MyBatis 在底层会将参数部分用?占位符取代，在预编译阶段才将参数值设置进去，确保参数值被安全地嵌入到 SQL 语句中。例如：
9. [code]

复制代码

<select id="getUserByName" resultType="com.example.User">
select * from user where name = #{name}
</select>
假设传入的name值为'Tom'，现实执行的 SQL 语句在预编译后会变成类似select * from user where name =?，然后将'Tom'作为参数值传入，如许即使传入的参数包含恶意 SQL 片断，如'; DROP TABLE user; --，MyBatis 也能将其作为平凡字符串处理，避免了 SQL 注入的风险，保障了数据库的安全。
而${}则是直接拼接取值的方式，它更像是一位直来直去的工匠，将参数值直接拼接到 SQL 语句中。例如：

1. [/code] <select id="getUserByTableName" resultType="com.example.User">
2. select * from ${tableName} where id = #{id}
3. </select>
4. 假如传入的tableName值为'user'，生成的 SQL 语句就是select * from user where id =?。但这种方式存在巨大的安全隐患，因为参数未经任那边理直接拼接，假如参数可控且被恶意篡改，就极易引发 SQL 注入问题。
5. 不外，${}也并非一无是处，它在某些特定场景下有着不可替换的作用。当我们需要动态传入表名、列名等数据库对象时，由于这些对象在 SQL 语法中不能被预编译，只能使用${}举行拼接。好比，在分表查询的场景下，根据差别的时间范围查询差别的数据表：
6. [code]

复制代码

<select id="getOrderByTimeRange" resultType="com.example.Order">
select * from ${tableName} where create_time between #{startTime} and #{endTime}
</select>
这里的tableName假如是根据业务规则动态生成的，如order_202301、order_202302等，就必须使用${}来确保 SQL 语句的正确性。
总之，在一样平常开辟中，为了保障系统安全，应优先使用#{}举行参数取值。只有在碰到必须动态传入表名、列名等特别情况时，才审慎使用${}，并且要对传入的参数举行严格的校验与过滤，避免 SQL 注入漏洞的出现，确保数据交互的安全与稳定。
四、实战演练：从理论到实践的超过

（一）搭建环境

在开启 MyBatis 的实战之旅前，精心搭建一个稳定且符合的开辟环境至关重要，这是后续全部操纵的基石。
我们起首创建一个 Maven 项目，在项目的pom.xml文件中引入 MyBatis 以及相关依靠，确保项目具备强大的数据库交互能力。以下是关键的依靠配置片断：

1. [/code] <dependencies>
2. <!-- MyBatis核心依靠 -->
3. <dependency>
4. <groupId>org.mybatis</groupId>
5. <artifactId>mybatis</artifactId>
6. <version>3.5.7</version>
7. </dependency>
8. <!-- MySQL数据库毗连驱动 -->
9. <dependency>
10. <groupId>mysql</groupId>
11. <artifactId>mysql-connector-java</artifactId>
12. <version>8.0.26</version>
13. </dependency>
14. <!-- 单元测试依靠，方便后续编写测试用例 -->
15. <dependency>
16. <groupId>junit</groupId>
17. <artifactId>junit</artifactId>
18. <version>4.13.2</version>
19. <scope>test</scope>
20. </dependency>
21. </dependencies>
22. 紧接着，配置 MyBatis 的核心文件mybatis-config.xml，它宛如项目的总指挥中心，掌控着数据库毗连、映射文件加载等关键环节。示例配置如下：
23. [code]

复制代码

<?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">
<!-- 事务管理器，这里使用JDBC原生事务 -->
<transactionManager type="JDBC"/>
<!-- 数据源配置，接纳毗连池进步性能 -->
<dataSource type="OOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mydb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=UTF-8&useAffectedRows=true"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<!-- 加载映射文件，可接纳多种方式，这里指定具体路径 -->
<mappers>
<mapper resource="com/example/mapper/UserMapper.xml"/>
</mappers>
</configuration>
在这个配置中，我们明确指定了毗连的 MySQL 数据库的具体信息，包括驱动、URL、用户名和暗码，同时精准加载了对应的 SQL 映射文件，为后续的数据交互搭建好了稳固的桥梁。
（二）简单查询实例

环境搭建完毕后，让我们通过一个简单的查询用户信息案例，来深入领会 MyBatis 的强大之处。
起首，定义一个实体类User，它如同数据库表在 Java 世界中的 “代言人”，精准反映表的布局：

1. [/code] public class User {
2. private Long id;
3. private String username;
4. private String password;
5. private Integer age;
6. // 省略getter和setter方法
7. }
8. 接着，在 Mapper 接口UserMapper中定义查询方法：
9. [code]

复制代码

public interface UserMapper {
User getUserById(Long id);
}
随后，在 SQL 映射文件UserMapper.xml中编写对应的<select>语句：

1. [/code] <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3. <mapper namespace="com.example.mapper.UserMapper">
4. <select id="getUserById" parameterType="java.lang.Long" resultType="com.example.User">
5. select id, username, password, age from user where id = #{id}
6. </select>
7. </mapper>
8. 万事俱备，编写测试类来验证我们的代码：
9. [code]

复制代码

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 org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
public class MyBatisTest {
@Test
public void testGetUserById() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = userMapper.getUserById(1L);
System.out.println(user.getUsername());
sqlSession.close();
}
}
运行测试方法，假如一切顺利，控制台将输出对应id为 1 的用户的用户名，这标志着我们乐成地通过 MyBatis 从数据库中获取到了期望的数据，完成了一次简单而又关键的查询操纵。
（三）复杂查询与数据变更实例

在现实项目中，除了简单查询，复杂查询与数据变更操纵更是屡见不鲜。接下来，我们设计一个多表关联查询与插入数据的综合实例，进一步显现 MyBatis 的强大实力。
假设有用户表user、订单表order和商品表product，它们之间存在着细密的关联关系。我们要查询某个用户的全部订单信息，以及每个订单所包含的商品详情。
起首，创建相应的实体类：

1. [/code] public class Order {
2. private Long id;
3. private Long userId;
4. private String orderNo;
5. private List<Product> products;
6. // 省略getter和setter方法
7. }
8. public class Product {
9. private Long id;
10. private String productName;
11. private BigDecimal price;
12. // 省略getter和setter方法
13. }
14. 在 Mapper 接口OrderMapper中定义查询方法：
15. [code]

复制代码

public interface OrderMapper {
Order getOrderByUserId(Long userId);
}
然后，在 SQL 映射文件OrderMapper.xml中使用<resultMap>和<association>、<collection>等元素编写复杂的查询语句：

1. [/code] <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3. <mapper namespace="com.example.mapper.OrderMapper">
4. <resultMap id="orderResultMap" type="com.example.Order">
5. <id property="id" column="o_id"/>
6. <result property="userId" column="user_id"/>
7. <result property="orderNo" column="order_no"/>
8. <collection property="products" ofType="com.example.Product">
9. <id property="id" column="p_id"/>
10. <result property="productName" column="product_name"/>
11. <result property="price" column="price"/>
12. </collection>
13. </resultMap>
14. <select id="getOrderByUserId" resultMap="orderResultMap">
15. select o.id as o_id, o.user_id, o.order_no, p.id as p_id, p.product_name, p.price
16. from `order` o
17. left join order_item oi on o.id = oi.order_id
18. left join product p on oi.product_id = p.id
19. where o.user_id = #{userId}
20. </select>
21. </mapper>
22. 编写测试方法验证：
23. [code]

复制代码

@Test
public void testGetOrderByUserId() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
Order order = orderMapper.getOrderByUserId(1L);
System.out.println(order.getOrderNo());
for (Product product : order.getProducts()) {
System.out.println(product.getProductName());
}
sqlSession.close();
}
运行测试，将能清晰看到用户的订单编号以及订单下的商品名称列表，乐成实现复杂的多表关联查询。
再来看一个插入数据的示例，在UserMapper.xml中新增插入用户的<insert>语句：

1. [/code] <insert id="addUser" parameterType="com.example.User" useGeneratedKeys="true" keyProperty="id">
2. insert into user (username, password, age) values (#{username}, #{password}, #{age})
3. </insert>
4. 在测试类中编写插入测试方法：
5. [code]

复制代码

@Test
public void testAddUser() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession(true);
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = new User();
user.setUsername("new_user");
user.setPassword("123456");
user.setAge(25);
userMapper.addUser(user);
System.out.println("插入用户的id: " + user.getId());
sqlSession.close();
}
运行该测试，数据将乐成插入数据库，同时控制台会打印出由数据库自动生成并回填到用户对象的id值，完成一次完备的数据插入操纵，充分展示了 MyBatis 在复杂业务场景下的数据处理能力。
五、总结与拓展

至此，我们已深入探索了 MyBatis SQL 映射文件的基础领域，揭开了其神秘面纱的一角。通过对核心元素如<mapper>、<select>、<insert>等的具体分析，我们明晰了它们在构建稳固数据访问层时的关键职责与独特魅力。参数传递与取值的本领，无论是单个参数的机动运用，照旧多个参数的精准处理，乃至#{}与${}的奇妙抉择，都为我们编写高效、安全的 SQL 语句提供了有力保障。实战演练环节更是将理论转化为实践，让我们逼真感受到 MyBatis 在现实项目中的强大效能。
然而，这仅仅是 MyBatis 世界的开篇。前方尚有更多高级特性等候我们去征服，动态 SQL 犹如一位灵动的舞者，能根据差别业务场景动态拼接出精准的 SQL 语句，让数据查询更加智能高效；缓存机制则像一位默默守护的卫士，通过合理配置，可大幅提拔查询性能，减轻数据库压力；尚有延迟加载、拦截器等强大功能，每一个都蕴含着无限潜力，等候我们在后续学习与实践中去发掘、去运用，助力我们成为 MyBatis 领域的行家里手，打造出更加良好的数据库驱动应用。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。