Spring Boot 集成 MyBatis 全面讲解

卖不甜枣  论坛元老 | 2025-1-18 16:03:30 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1041|帖子 1041|积分 3123


Spring Boot 集成 MyBatis 全面讲解

MyBatis 是一款良好的持久层框架，与 Spring Boot 集成后可以大大简化开发流程。本文将全面讲解如何在 Spring Boot 中集成 MyBatis，包括情况配置、基础利用、高级功能和最佳实践。
一、MyBatis 简介

1. SqlSession

SqlSession 是 MyBatis 的核心接口，负责执行 SQL 语句、获取映射器实例以及管理事务。
1.1 SqlSession 的创建

SqlSession 通常通过 SqlSessionFactory 获取。以下是创建 SqlSessionFactory 的典范代码：
  1. InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
  2. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  3. try (SqlSession session = sqlSessionFactory.openSession()) {
  4.     // 使用 session 进行数据库操作
  5. }
复制代码
  注意：在 Spring 集成中，SqlSessionFactory 和 SqlSession 的创建由框架管理，我们只必要通过依赖注入获取即可。
  
1.2 SqlSession 的常用方法

SqlSession 提供了多种方法，用于执行数据库利用：


  • 查询利用：
    1. // 单条记录查询
    2. User user = session.selectOne("namespace.statementId", parameter);
    4. // 多条记录查询
    5. List<User> users = session.selectList("namespace.statementId", parameter);
    复制代码
  • 插入利用：
    1. int rows = session.insert("namespace.statementId", parameter);
    复制代码
  • 更新利用：
    1. int rows = session.update("namespace.statementId", parameter);
    复制代码
  • 删除利用：
    1. int rows = session.delete("namespace.statementId", parameter);
    复制代码
  • 事务控制：
    1. session.commit();  // 提交事务
    2. session.rollback();  // 回滚事务
    复制代码
2. Mapper 映射器

Mapper 映射器是 MyBatis 的核心功能，用于实现 SQL 和 Java 方法之间的映射。它可以通过注解或 XML 配置。
2.1 基于注解的 Mapper

注解方式直接将 SQL 写在 Mapper 接口中，简单高效，恰当简单场景。
示例代码：
  1. @Mapper
  2. public interface UserMapper {
  4.     @Select("SELECT * FROM user WHERE id = #{id}")
  5.     User selectById(Long id);
  7.     @Insert("INSERT INTO user (username, email) VALUES (#{username}, #{email})")
  8.     int insertUser(User user);
  10.     @Update("UPDATE user SET email = #{email} WHERE id = #{id}")
  11.     int updateUser(User user);
  13.     @Delete("DELETE FROM user WHERE id = #{id}")
  14.     int deleteUser(Long id);
  15. }
复制代码
2.2 基于 XML 的 Mapper

XML 配置更加灵活，恰当复杂查询场景。Mapper XML 文件通常位于 resources/mapper 目录。
Mapper XML 文件示例：
  1. <?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">
  5.     <!-- 查询 -->
  6.     <select id="selectById" parameterType="long" resultType="com.example.entity.User">
  7.         SELECT * FROM user WHERE id = #{id}
  8.     </select>
  10.     <!-- 插入 -->
  11.     <insert id="insertUser" parameterType="com.example.entity.User">
  12.         INSERT INTO user (username, email)
  13.         VALUES (#{username}, #{email})
  14.     </insert>
  16.     <!-- 更新 -->
  17.     <update id="updateUser" parameterType="com.example.entity.User">
  18.         UPDATE user SET email = #{email} WHERE id = #{id}
  19.     </update>
  21.     <!-- 删除 -->
  22.     <delete id="deleteUser" parameterType="long">
  23.         DELETE FROM user WHERE id = #{id}
  24.     </delete>
  25. </mapper>
复制代码
2.3 Mapper 映射器的工作机制

Mapper 接口的方法名和参数必要与 XML 中的 id 和 parameterType 对应。MyBatis 会通过动态代理为 Mapper 接口生成实现类，并调用对应的 SQL。
3. 配置文件

MyBatis 的配置文件包括全局配置文件（mybatis-config.xml）和映射文件（mapper.xml）。
3.1 全局配置文件

mybatis-config.xml 界说了数据库连接、日志设置、别名等全局配置。
典范配置示例：
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
  3. <configuration>
  4.     <!-- 环境配置 -->
  5.     <environments default="development">
  6.         <environment id="development">
  7.             <transactionManager type="JDBC"/>
  8.             <dataSource type="POOLED">
  9.                 <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
  10.                 <property name="url" value="jdbc:mysql://localhost:3306/mybatis_demo"/>
  11.                 <property name="username" value="root"/>
  12.                 <property name="password" value="root"/>
  13.             </dataSource>
  14.         </environment>
  15.     </environments>
  17.     <!-- 别名配置 -->
  18.     <typeAliases>
  19.         <typeAlias type="com.example.entity.User" alias="User"/>
  20.     </typeAliases>
  22.     <!-- Mapper 映射文件 -->
  23.     <mappers>
  24.         <mapper resource="mapper/UserMapper.xml"/>
  25.     </mappers>
  26. </configuration>
复制代码
3.2 映射文件配置

映射文件界说了详细的 SQL 和 Java 对象之间的关系。以 UserMapper.xml 为例：
  1. <mapper namespace="com.example.mapper.UserMapper">
  3.     <select id="selectAll" resultType="User">
  4.         SELECT * FROM user
  5.     </select>
  7.     <resultMap id="UserResultMap" type="User">
  8.         <id column="id" property="id"/>
  9.         <result column="username" property="username"/>
  10.         <result column="email" property="email"/>
  11.     </resultMap>
  12. </mapper>
复制代码
4. ResultMap

ResultMap 是 MyBatis 的强大特性之一，用于处置惩罚复杂查询效果与 Java 对象的映射关系。
4.1 什么是 ResultMap？

ResultMap 用于自界说数据库字段与 Java 对象属性的映射。它支持嵌套映射、别名和字段处置惩罚，恰当复杂的对象映射场景。
4.2 ResultMap 配置示例

以下是一个带嵌套对象的 ResultMap 配置：
数据库表：

  1. CREATE TABLE user (
  2.     id BIGINT PRIMARY KEY,
  3.     username VARCHAR(50),
  4.     email VARCHAR(100)
  5. );
  7. CREATE TABLE address (
  8.     id BIGINT PRIMARY KEY,
  9.     user_id BIGINT,
  10.     city VARCHAR(50),
  11.     FOREIGN KEY (user_id) REFERENCES user(id)
  12. );
复制代码
Java 对象：

  1. @Data
  2. public class User {
  3.     private Long id;
  4.     private String username;
  5.     private String email;
  6.     private Address address;
  7. }
  9. @Data
  10. public class Address {
  11.     private Long id;
  12.     private String city;
  13. }
复制代码
ResultMap 配置：

  1. <resultMap id="UserWithAddress" type="User">
  2.     <id column="id" property="id"/>
  3.     <result column="username" property="username"/>
  4.     <result column="email" property="email"/>
  5.     <association property="address" javaType="Address">
  6.         <id column="address_id" property="id"/>
  7.         <result column="city" property="city"/>
  8.     </association>
  9. </resultMap>
复制代码
查询语句：

  1. <select id="getUserWithAddress" resultMap="UserWithAddress">
  2.     SELECT u.id, u.username, u.email, a.id AS address_id, a.city
  3.     FROM user u
  4.     LEFT JOIN address a ON u.id = a.user_id
  5.     WHERE u.id = #{id}
  6. </select>
复制代码
4.3 嵌套集合映射

对于一对多的嵌套关系，可以使用 <collection>：
  1. <resultMap id="UserWithPosts" type="User">
  2.     <id column="id" property="id"/>
  3.     <result column="username" property="username"/>
  4.     <collection property="posts" ofType="Post">
  5.         <id column="post_id" property="id"/>
  6.         <result column="title" property="title"/>
  7.     </collection>
  8. </resultMap>
复制代码
总结

SqlSession、Mapper、配置文件 和 ResultMap 是 MyBatis 的核心概念。通过灵活的配置和映射，MyBatis 可以高效地处置惩罚各种复杂的数据库利用需求。熟练掌握这些特性可以让开发者在项目中更高效地处置惩罚数据访问逻辑。
三、Spring Boot 集成 MyBatis

MyBatis 是一种轻量级的持久层框架，与 Spring Boot 集成后可以极大地提拔开发效率。以下是集成的完备步调，包括项目配置、数据库设计和根本利用。
1. 创建 Spring Boot 项目

在创建项目时，可以使用 Spring Initializr 快速生成骨架项目。以下依赖是集成 MyBatis 所必需的：


  • Spring Web：用于创建 REST API。
  • MyBatis Framework：MyBatis 的核心依赖。
  • MySQL Driver：连接 MySQL 数据库。
  • Lombok：简化实体类的开发，镌汰样板代码。
2. 配置 pom.xml

以下是必要在 pom.xml 中添加的 Maven 依赖：
  1. <dependencies>
  2.     <!-- Spring Boot Starter -->
  3.     <dependency>
  4.         <groupId>org.springframework.boot</groupId>
  5.         <artifactId>spring-boot-starter</artifactId>
  6.     </dependency>
  8.     <!-- MyBatis Starter -->
  9.     <dependency>
  10.         <groupId>org.mybatis.spring.boot</groupId>
  11.         <artifactId>mybatis-spring-boot-starter</artifactId>
  12.         <version>3.0.0</version>
  13.     </dependency>
  15.     <!-- MySQL Driver -->
  16.     <dependency>
  17.         <groupId>mysql</groupId>
  18.         <artifactId>mysql-connector-j</artifactId>
  19.     </dependency>
  21.     <!-- Lombok -->
  22.     <dependency>
  23.         <groupId>org.projectlombok</groupId>
  24.         <artifactId>lombok</artifactId>
  25.     </dependency>
  26. </dependencies>
复制代码
这些依赖包括 Spring Boot 核心、MyBatis 框架、MySQL 数据库驱动和 Lombok。版本号可以根据项目需求进行调解。
3. 配置数据库连接

在 src/main/resources 目录下创建 application.yml 文件，用于配置项目的数据库连接。
application.yml 示例

  1. spring:
  2.   datasource:
  3.     url: jdbc:mysql://localhost:3306/mybatis_demo?useSSL=false&serverTimezone=UTC
  4.     username: root
  5.     password: root
  6.     driver-class-name: com.mysql.cj.jdbc.Driver
  8. mybatis:
  9.   mapper-locations: classpath:mapper/*.xml
  10.   type-aliases-package: com.example.demo.entity
复制代码
  阐明：
  

  • url：数据库连接地址。
  • username 和 password：数据库的用户名和密码。
  • mapper-locations：指定 MyBatis 的 XML 映射文件路径。
  • type-aliases-package：指定实体类地点的包，用于启用简化的类名映射。
  
4. 创建数据库表

使用以下 SQL 语句创建一个简单的用户表：
SQL 示例

  1. CREATE DATABASE IF NOT EXISTS mybatis_demo;
  3. USE mybatis_demo;
  5. CREATE TABLE user (
  6.     id BIGINT PRIMARY KEY AUTO_INCREMENT,
  7.     username VARCHAR(50) NOT NULL,
  8.     password VARCHAR(50) NOT NULL,
  9.     email VARCHAR(100) NOT NULL,
  10.     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
  11. );
复制代码
此 SQL 创建了一个名为 user 的表，用于存储用户信息。字段包括用户 ID、用户名、密码、电子邮件以及创建时间。
5. 编写实体类

创建与数据库表对应的 Java 实体类。
User.java

  1. package com.example.demo.entity;
  3. import lombok.Data;
  4. import java.time.LocalDateTime;
  6. @Data
  7. public class User {
  8.     private Long id;
  9.     private String username;
  10.     private String password;
  11.     private String email;
  12.     private LocalDateTime createdAt;
  13. }
复制代码
  阐明：
  

  • 使用了 Lombok 的 @Data 注解，自动生成 getter、setter、toString 等方法。
  • 字段名称与数据库表的列名保持一致，便于自动映射。
  
6. 创建 Mapper 接口

MyBatis 的 Mapper 接口用于界说数据库利用。可以选择使用注解方式或者 XML 配置方式编写 SQL。
注解方式 Mapper

以下是一个基于注解的 Mapper 接口示例：
  1. package com.example.demo.mapper;
  3. import com.example.demo.entity.User;
  4. import org.apache.ibatis.annotations.*;
  6. import java.util.List;
  8. @Mapper
  9. public interface UserMapper {
  11.     @Insert("INSERT INTO user (username, password, email) VALUES (#{username}, #{password}, #{email})")
  12.     int insertUser(User user);
  14.     @Select("SELECT * FROM user WHERE id = #{id}")
  15.     User selectById(Long id);
  17.     @Select("SELECT * FROM user")
  18.     List<User> selectAllUsers();
  20.     @Update("UPDATE user SET username = #{username}, password = #{password}, email = #{email} WHERE id = #{id}")
  21.     int updateUser(User user);
  23.     @Delete("DELETE FROM user WHERE id = #{id}")
  24.     int deleteUser(Long id);
  25. }
复制代码
XML 配置方式 Mapper

XML 配置方式更灵活，恰当复杂查询场景。以下是对应的 XML 映射文件。
文件位置：src/main/resources/mapper/UserMapper.xml

  1. <?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.demo.mapper.UserMapper">
  5.     <insert id="insertUser" parameterType="com.example.demo.entity.User">
  6.         INSERT INTO user (username, password, email)
  7.         VALUES (#{username}, #{password}, #{email})
  8.     </insert>
  10.     <select id="selectById" parameterType="long" resultType="com.example.demo.entity.User">
  11.         SELECT * FROM user WHERE id = #{id}
  12.     </select>
  14.     <select id="selectAllUsers" resultType="com.example.demo.entity.User">
  15.         SELECT * FROM user
  16.     </select>
  18.     <update id="updateUser" parameterType="com.example.demo.entity.User">
  19.         UPDATE user SET username = #{username}, password = #{password}, email = #{email} WHERE id = #{id}
  20.     </update>
  22.     <delete id="deleteUser" parameterType="long">
  23.         DELETE FROM user WHERE id = #{id}
  24.     </delete>
  26. </mapper>
复制代码
在 Spring Boot 中，MyBatis 会自动扫描 mapper 文件夹下的 XML 文件。
7. 创建 Service 层

为了更好地分离业务逻辑，发起将 Mapper 利用封装到 Service 层中。
UserService.java

  1. package com.example.demo.service;
  3. import com.example.demo.entity.User;
  4. import com.example.demo.mapper.UserMapper;
  5. import org.springframework.stereotype.Service;
  7. import java.util.List;
  9. @Service
  10. public class UserService {
  12.     private final UserMapper userMapper;
  14.     public UserService(UserMapper userMapper) {
  15.         this.userMapper = userMapper;
  16.     }
  18.     public int createUser(User user) {
  19.         return userMapper.insertUser(user);
  20.     }
  22.     public User getUserById(Long id) {
  23.         return userMapper.selectById(id);
  24.     }
  26.     public List<User> getAllUsers() {
  27.         return userMapper.selectAllUsers();
  28.     }
  30.     public int updateUser(User user) {
  31.         return userMapper.updateUser(user);
  32.     }
  34.     public int deleteUser(Long id) {
  35.         return userMapper.deleteUser(id);
  36.     }
  37. }
复制代码
8. 创建 Controller 层

末了，为了提供对外接口，创建 Controller。
UserController.java

  1. package com.example.demo.controller;
  3. import com.example.demo.entity.User;
  4. import com.example.demo.service.UserService;
  5. import org.springframework.web.bind.annotation.*;
  7. import java.util.List;
  9. @RestController
  10. @RequestMapping("/api/users")
  11. public class UserController {
  13.     private final UserService userService;
  15.     public UserController(UserService userService) {
  16.         this.userService = userService;
  17.     }
  19.     @PostMapping
  20.     public String createUser(@RequestBody User user) {
  21.         userService.createUser(user);
  22.         return "User created successfully!";
  23.     }
  25.     @GetMapping("/{id}")
  26.     public User getUserById(@PathVariable Long id) {
  27.         return userService.getUserById(id);
  28.     }
  30.     @GetMapping
  31.     public List<User> getAllUsers() {
  32.         return userService.getAllUsers();
  33.     }
  35.     @PutMapping
  36.     public String updateUser(@RequestBody User user) {
  37.         userService.updateUser(user);
  38.         return "User updated successfully!";
  39.     }
  41.     @DeleteMapping("/{id}")
  42.     public String deleteUser(@PathVariable Long id) {
  43.         userService.deleteUser(id);
  44.         return "User deleted successfully!";
  45.     }
  46. }
复制代码
9. 启动应用

创建项目主类 MyBatisDemoApplication.java：
  1. package com.example.demo;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class MyBatisDemoApplication {
  8.     public static void main(String[] args) {
  9.         SpringApplication.run(MyBatisDemoApplication.class, args);
  10.     }
  11. }
复制代码
启动项目，使用工具（如 Postman 或 CURL）测试接口。
四、MyBatis 基础利用详解

以下将详细讲解 MyBatis 的基础利用，包括如何创建实体类、Mapper 接口、XML 映射文件，以及如何通过 Service 和 Controller 层完成基础的增删改查功能。
1. 创建实体类

实体类用于表示数据库中的表记录，在 MyBatis 中，实体类字段与数据库表的列进行逐一对应。
示例代码：User.java

  1. package com.example.demo.entity;
  3. import lombok.Data;
  4. import java.time.LocalDateTime;
  6. @Data
  7. public class User {
  8.     private Long id;             // 用户ID
  9.     private String username;     // 用户名
  10.     private String password;     // 密码
  11.     private String email;        // 邮箱
  12.     private LocalDateTime createdAt; // 创建时间
  13. }
复制代码
  阐明：
  

  • 使用 @Data 注解自动生成 getter、setter、toString 等方法。
  • 字段名称与数据库表的列名保持一致，便于 MyBatis 自动映射。
  
2. 创建 Mapper 接口

Mapper 接口界说了对数据库表的利用。MyBatis 支持两种方式：基于注解和基于 XML 映射文件。
基于注解的 Mapper 接口

以下是使用注解界说的基础增删改查利用：
  1. package com.example.demo.mapper;
  3. import com.example.demo.entity.User;
  4. import org.apache.ibatis.annotations.*;
  6. import java.util.List;
  8. @Mapper
  9. public interface UserMapper {
  11.     // 插入用户
  12.     @Insert("INSERT INTO user (username, password, email) VALUES (#{username}, #{password}, #{email})")
  13.     int insertUser(User user);
  15.     // 查询所有用户
  16.     @Select("SELECT * FROM user")
  17.     List<User> getAllUsers();
  19.     // 根据 ID 查询用户
  20.     @Select("SELECT * FROM user WHERE id = #{id}")
  21.     User getUserById(Long id);
  23.     // 更新用户
  24.     @Update("UPDATE user SET username = #{username}, password = #{password}, email = #{email} WHERE id = #{id}")
  25.     int updateUser(User user);
  27.     // 删除用户
  28.     @Delete("DELETE FROM user WHERE id = #{id}")
  29.     int deleteUser(Long id);
  30. }
复制代码
  注意：
  

  • 使用 @Mapper 注解让 Spring 容器自动扫描 Mapper 接口。
  • 注解方式恰当简单的 SQL 语句，对于复杂查询发起使用 XML。
  
3. 配置 XML 映射文件

在复杂查询场景中，XML 配置文件更加灵活。
文件位置

  1. src/main/resources/mapper/UserMapper.xml
复制代码
UserMapper.xml 示例

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="com.example.demo.mapper.UserMapper">
  8.     <!-- 定义字段与属性的映射 -->
  9.     <resultMap id="UserResultMap" type="com.example.demo.entity.User">
  10.         <id column="id" property="id" />
  11.         <result column="username" property="username" />
  12.         <result column="password" property="password" />
  13.         <result column="email" property="email" />
  14.         <result column="created_at" property="createdAt" />
  15.     </resultMap>
  17.     <!-- 查询所有用户 -->
  18.     <select id="getAllUsers" resultMap="UserResultMap">
  19.         SELECT * FROM user
  20.     </select>
  22.     <!-- 插入用户 -->
  23.     <insert id="insertUser" parameterType="com.example.demo.entity.User">
  24.         INSERT INTO user (username, password, email)
  25.         VALUES (#{username}, #{password}, #{email})
  26.     </insert>
  28.     <!-- 更新用户 -->
  29.     <update id="updateUser" parameterType="com.example.demo.entity.User">
  30.         UPDATE user
  31.         SET username = #{username}, password = #{password}, email = #{email}
  32.         WHERE id = #{id}
  33.     </update>
  35.     <!-- 删除用户 -->
  36.     <delete id="deleteUser" parameterType="long">
  37.         DELETE FROM user WHERE id = #{id}
  38.     </delete>
  40. </mapper>
复制代码
  注意：
  

  • namespace 必须与 Mapper 接口的全路径名称一致。
  • <resultMap> 界说了表字段与实体类属性之间的映射关系。
  • #{} 用于参数占位，MyBatis 会根据参数范例自动替换。
  
4. 创建 Service 层

为了实现业务逻辑与数据访问的分离，发起通过 Service 层封装 Mapper 的利用。
示例代码：UserService.java

  1. package com.example.demo.service;
  3. import com.example.demo.entity.User;
  4. import com.example.demo.mapper.UserMapper;
  5. import org.springframework.stereotype.Service;
  7. import java.util.List;
  9. @Service
  10. public class UserService {
  12.     private final UserMapper userMapper;
  14.     public UserService(UserMapper userMapper) {
  15.         this.userMapper = userMapper;
  16.     }
  18.     // 添加用户
  19.     public int addUser(User user) {
  20.         return userMapper.insertUser(user);
  21.     }
  23.     // 获取所有用户
  24.     public List<User> getAllUsers() {
  25.         return userMapper.getAllUsers();
  26.     }
  28.     // 根据 ID 查询用户
  29.     public User getUserById(Long id) {
  30.         return userMapper.getUserById(id);
  31.     }
  33.     // 更新用户
  34.     public int updateUser(User user) {
  35.         return userMapper.updateUser(user);
  36.     }
  38.     // 删除用户
  39.     public int deleteUser(Long id) {
  40.         return userMapper.deleteUser(id);
  41.     }
  42. }
复制代码
  阐明：
  

  • 通过依赖注入的方式引入 UserMapper。
  • 将所有的数据库利用封装为独立的方法，便于管理和复用。
  
5. 创建 Controller 层

Controller 层提供 RESTful API 接口，供外部访问 Service 方法。
示例代码：UserController.java

  1. package com.example.demo.controller;
  3. import com.example.demo.entity.User;
  4. import com.example.demo.service.UserService;
  5. import org.springframework.web.bind.annotation.*;
  7. import java.util.List;
  9. @RestController
  10. @RequestMapping("/api/users")
  11. public class UserController {
  13.     private final UserService userService;
  15.     public UserController(UserService userService) {
  16.         this.userService = userService;
  17.     }
  19.     // 创建用户
  20.     @PostMapping
  21.     public String createUser(@RequestBody User user) {
  22.         userService.addUser(user);
  23.         return "User created successfully!";
  24.     }
  26.     // 获取所有用户
  27.     @GetMapping
  28.     public List<User> getAllUsers() {
  29.         return userService.getAllUsers();
  30.     }
  32.     // 根据 ID 获取用户
  33.     @GetMapping("/{id}")
  34.     public User getUserById(@PathVariable Long id) {
  35.         return userService.getUserById(id);
  36.     }
  38.     // 更新用户
  39.     @PutMapping
  40.     public String updateUser(@RequestBody User user) {
  41.         userService.updateUser(user);
  42.         return "User updated successfully!";
  43.     }
  45.     // 删除用户
  46.     @DeleteMapping("/{id}")
  47.     public String deleteUser(@PathVariable Long id) {
  48.         userService.deleteUser(id);
  49.         return "User deleted successfully!";
  50.     }
  51. }
复制代码
  阐明：
  

  • 使用 @RestController 标注类，返回 JSON 数据。
  • 通过 @RequestBody 接收前端传递的 JSON 数据。
  • 通过 @PathVariable 获取 URL 中的动态参数。
  
五、高级功能

1. 动态 SQL

动态 SQL 是 MyBatis 的强大功能之一，可以根据输入条件动态生成 SQL 语句。相比手动拼接 SQL，这种方式更加安全、高效且可维护。
1.1 动态 SQL 标签

MyBatis 提供了以下动态 SQL 标签：

  • <if>：用于条件判断。
  • <choose>：雷同于 Java 的 switch-case。
  • <where>：自动添加 WHERE 关键字并处置惩罚多个条件。
  • <set>：动态生成 SET 子句，常用于更新语句。
  • <foreach>：用于迭代生成 SQL（如 IN 子句或批量插入）。
  • <trim>：自界说 SQL 前后缀（如添加括号、处置惩罚多余逗号等）。
1.2 动态 SQL 示例

（1）条件查询：根据用户输入动态生成查询条件
XML 配置文件：
  1. <select id="searchUsers" resultMap="UserResultMap">
  2.     SELECT * FROM user
  3.     <where>
  4.         <if test="username != null">
  5.             AND username = #{username}
  6.         </if>
  7.         <if test="email != null">
  8.             AND email = #{email}
  9.         </if>
  10.     </where>
  11. </select>
复制代码
  注意：<where> 标签会自动处置惩罚条件的拼接，并在至少有一个条件建立时自动添加 WHERE 关键字。
  Java 调用代码：
  1. Map<String, Object> params = new HashMap<>();
  2. params.put("username", "John");
  3. params.put("email", null);
  5. List<User> users = userMapper.searchUsers(params);
复制代码
（2）动态更新：根据非空字段更新用户信息
在实际场景中，每每必要对部分字段进行更新，MyBatis 的动态 SQL 可以轻松实现。
XML 配置文件：
  1. <update id="updateUser" parameterType="User">
  2.     UPDATE user
  3.     <set>
  4.         <if test="username != null">
  5.             username = #{username},
  6.         </if>
  7.         <if test="password != null">
  8.             password = #{password},
  9.         </if>
  10.         <if test="email != null">
  11.             email = #{email},
  12.         </if>
  13.     </set>
  14.     WHERE id = #{id}
  15. </update>
复制代码
  注意：
  

  • <set> 标签会自动处置惩罚逗号，确保生成的 SQL 语句语法准确。
  • null 值的字段会被忽略，克制误更新。
  Java 调用代码：
  1. User user = new User();
  2. user.setId(1L);
  3. user.setUsername("NewName");
  5. int rows = userMapper.updateUser(user);
复制代码
（3）批量查询：使用 <foreach> 生成 IN 子句
XML 配置文件：
  1. <select id="findUsersByIds" resultMap="UserResultMap">
  2.     SELECT * FROM user
  3.     WHERE id IN
  4.     <foreach collection="idList" item="id" open="(" separator="," close=")">
  5.         #{id}
  6.     </foreach>
  7. </select>
复制代码
  阐明：
  

  • collection 指定输入参数（一样平常为 List 或数组）。
  • item 是每次迭代的变量。
  • open、separator 和 close 分别界说 SQL 子句的开头、分隔符和结尾。
  Java 调用代码：
  1. List<Long> idList = Arrays.asList(1L, 2L, 3L);
  2. List<User> users = userMapper.findUsersByIds(idList);
复制代码
生成的 SQL：
  1. SELECT * FROM user WHERE id IN (1, 2, 3);
复制代码
2. 分页查询

分页查询是 Web 应用中最常见的功能之一。在 MyBatis 中，可以借助 PageHelper 插件实现高效分页。
2.1 使用 PageHelper 插件

（1）引入依赖
在 pom.xml 中添加以下依赖：
  1. <dependency>
  2.     <groupId>com.github.pagehelper</groupId>
  3.     <artifactId>pagehelper-spring-boot-starter</artifactId>
  4.     <version>1.4.0</version>
  5. </dependency>
复制代码
（2）分页查询示例
在 Service 层调用分页方法：
  1. import com.github.pagehelper.PageHelper;
  2. import com.github.pagehelper.PageInfo;
  4. public List<User> getUsersByPage(int pageNum, int pageSize) {
  5.     // 启用分页
  6.     PageHelper.startPage(pageNum, pageSize);
  7.     List<User> users = userMapper.getAllUsers();
  8.     // 封装分页结果
  9.     return new PageInfo<>(users).getList();
  10. }
复制代码
（3）自界说分页
如果不想引入插件，也可以通过手动拼接分页 SQL：
XML 配置文件：
  1. <select id="getUsersByPage" resultMap="UserResultMap">
  2.     SELECT * FROM user
  3.     LIMIT #{offset}, #{pageSize}
  4. </select>
复制代码
Mapper 接口：
  1. List<User> getUsersByPage(@Param("offset") int offset, @Param("pageSize") int pageSize);
复制代码
Java 调用代码：
  1. int offset = (pageNum - 1) * pageSize;
  2. List<User> users = userMapper.getUsersByPage(offset, pageSize);
复制代码
3. 复杂对象映射

3.1 一对多映射

场景：一个用户有多个订单。
数据库表设计：
  1. CREATE TABLE orders (
  2.     id BIGINT PRIMARY KEY,
  3.     user_id BIGINT,
  4.     order_name VARCHAR(255),
  5.     FOREIGN KEY (user_id) REFERENCES user(id)
  6. );
复制代码
XML 配置文件：
  1. <resultMap id="UserWithOrders" type="User">
  2.     <id column="id" property="id"/>
  3.     <result column="username" property="username"/>
  4.     <collection property="orders" ofType="Order">
  5.         <id column="order_id" property="id"/>
  6.         <result column="order_name" property="orderName"/>
  7.     </collection>
  8. </resultMap>
  10. <select id="getUserWithOrders" resultMap="UserWithOrders">
  11.     SELECT u.id, u.username, o.id AS order_id, o.order_name
  12.     FROM user u
  13.     LEFT JOIN orders o ON u.id = o.user_id
  14.     WHERE u.id = #{id}
  15. </select>
复制代码
3.2 嵌套查询

对于复杂的多表查询，可以使用嵌套查询实现。
XML 配置：
  1. <resultMap id="OrderResultMap" type="Order">
  2.     <id column="id" property="id"/>
  3.     <result column="order_name" property="orderName"/>
  4. </resultMap>
  6. <resultMap id="UserWithOrders" type="User">
  7.     <id column="id" property="id"/>
  8.     <result column="username" property="username"/>
  9.     <collection property="orders" resultMap="OrderResultMap" column="id"/>
  10. </resultMap>
  12. <select id="getUserWithOrders" resultMap="UserWithOrders">
  13.     SELECT * FROM user WHERE id = #{id};
  14. </select>
复制代码
六、最佳实践

1. 分层设计



  • Controller 层：负责接收哀求和返回相应。
  • Service 层：封装业务逻辑。
  • Mapper 层：专注于数据库交互。
2. 克制 N+1 查询

一对多、多对多场景中，优先使用联合查询或嵌套查询，克制多个 SQL 执行。
3. 启用日志

在 application.yml 中启用 MyBatis 日志：
  1. mybatis:
  2.   configuration:
  3.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
复制代码
4. 动态 SQL



  • 使用 <foreach> 实现批量利用。
  • 使用 <if> 结合 <set> 实现动态更新。

总结

MyBatis 的高级功能如动态 SQL、分页查询和复杂对象映射，为开发者提供了极大的灵活性。在项目中，结合实际场景选择合适的实现方式，可以显著提高开发效率并降低维护成本。如果有任何疑问，欢迎在评论区留言讨论！


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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

卖不甜枣

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表