首页手记 MyBatis Plus入门：简洁教程助你快速上手

MyBatis Plus入门：简洁教程助你快速上手

标签：

Java 开源数据库

概述

MyBatis Plus 是一个简单易用的数据库操作框架，提供了丰富的 CRUD 操作、分页、条件构造器等功能。本文详细介绍了 MyBatis Plus 的安装与集成、配置文件设置以及基础操作，帮助读者快速入门 MyBatis Plus。

MyBatis Plus简介

MyBatis Plus是什么

MyBatis Plus 是 MyBatis 的增强工具，它在 MyBatis 的基础上提供了简单易用的 CRUD 操作、分页、条件构造器等功能。MyBatis Plus 不是对 MyBatis 的简单封装，而是在原有的基础上增加了对数据库表的自动操作、逻辑删除等高级特性，使得开发人员可以更加高效地进行数据库操作。

MyBatis Plus的优势

简单易用的 CRUD 操作：
- MyBatis Plus 提供了丰富的 CRUD 方法，使得数据库操作变得非常简单。例如，用户的增删改查操作可以通过简单的几行代码实现。
分页与排序功能：
- MyBatis Plus 集成了分页插件，可以方便地进行分页操作。同时，它还提供了排序功能，使得数据的排序变得简单。
条件构造器：
- MyBatis Plus 的条件构造器 QueryWrapper 可以帮助开发人员轻松构建复杂的查询条件，避免了在 SQL 中编写复杂的条件语句。
自动生成代码：
- MyBatis Plus 提供了自动生成代码的功能，可以自动生成实体类、Mapper 接口等，减少了重复性的工作。
逻辑删除：
- MyBatis Plus 支持逻辑删除，通过一个字段来标记数据是否被删除，而不是直接在数据库中删除数据。
乐观锁机制：
- MyBatis Plus 集成了乐观锁机制，可以防止并发更新时的数据丢失。
自动填充与字段填充：
- MyBatis Plus 提供了自动填充与字段填充的功能，可以在插入或更新数据时自动填充某些字段的值，如创建时间、更新时间等。

MyBatis Plus的安装与集成

安装与集成步骤：
- 在你的项目中添加 MyBatis Plus 的依赖。
添加依赖：
- 在 Maven 项目中，需要在 pom.xml 文件中添加 MyBatis Plus 的依赖。示例如下：
```
<dependency>
   <groupId>com.baomidou</groupId>
   <artifactId>mybatis-plus-boot-starter</artifactId>
   <version>3.4.3</version>
</dependency>
```
如果你使用的是 Gradle 项目，则需要在 build.gradle 文件中添加依赖，示例如下：
```
implementation 'com.baomidou:mybatis-plus-boot-starter:3.4.3'
```

配置文件设置：

在 Spring Boot 项目中，需要在 application.yml 或 application.properties 文件中进行配置。示例如下：

mybatis-plus:
 mapper-locations: classpath*:mapper/*.xml
 global-config:
   db-config:
     id-type: ASSIGN_ID
 type-aliases-package: com.example.demo.entity

MyBatis Plus快速入门

创建项目环境

创建 Spring Boot 项目：
- 使用 Spring Initializr 创建一个新的 Spring Boot 项目，并选择 Web 和 MyBatis 依赖。
- 项目的主要组成部分包括 src/main/java 和 src/main/resources。其中 src/main/java 存放项目的源代码，src/main/resources 存放配置文件和资源文件。
项目目录结构：
- 项目的主要组成部分包括 src/main/java 和 src/main/resources。其中 src/main/java 存放项目的源代码，src/main/resources 存放配置文件和资源文件。

添加MyBatis Plus依赖

添加依赖方式：
- 如上文所述，通过在 Maven 或 Gradle 项目中添加 MyBatis Plus 的依赖。
配置文件位置：
- 在 Spring Boot 项目中，配置文件通常位于 src/main/resources 目录下，文件名可以是 application.yml 或 application.properties。

配置文件内容：

一些常用的配置项如下：

spring:
 datasource:
   url: jdbc:mysql://localhost:3306/mybatis_plus
   driver-class-name: com.mysql.cj.jdbc.Driver
   username: root
   password: root

mybatis-plus:
 mapper-locations: classpath*:mapper/*.xml
 global-config:
   db-config:
     id-type: ASSIGN_ID
 type-aliases-package: com.example.demo.entity

spring.datasource：配置数据库连接信息，包括 URL、驱动类名称、用户名和密码。
mybatis-plus.mapper-locations：配置 MyBatis Plus 的 Mapper XML 文件路径。
mybatis-plus.global-config：全局配置，包括数据库配置。
mybatis-plus.type-aliases-package：实体类包名，用于自动扫描实体类。

MyBatis Plus基础操作

数据库连接配置

数据库连接配置：

在 application.yml 或 application.properties 文件中配置数据库连接信息。

spring:
 datasource:
   url: jdbc:mysql://localhost:3306/mybatis_plus
   driver-class-name: com.mysql.cj.jdbc.Driver
   username: root
   password: root

实体类与表的映射

实体类定义：

实体类通常对应数据库中的表。例如，定义一个 User 实体类：

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

@TableName("user")
public class User {
   @TableId
   private Long id;
   private String username;
   private String password;
   private String email;

   // 构造器和 getter/setter 方法

   public User() {
   }

   public User(String username, String password, String email) {
       this.username = username;
       this.password = password;
       this.email = email;
   }

   public Long getId() {
       return id;
   }

   public void setId(Long id) {
       this.id = id;
   }

   public String getUsername() {
       return username;
   }

   public void setUsername(String username) {
       this.username = username;
   }

   public String getPassword() {
       return password;
   }

   public void setPassword(String password) {
       this.password = password;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }
}

@TableName 注解用于指定实体类对应的数据库表名。
@TableId 注解用于指定主键字段。
实体类中的字段需要与数据库表中的字段一一对应。

CRUD操作实例

创建操作：

创建一个 UserMapper 接口：

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.User;

public interface UserMapper extends BaseMapper<User> {
}

创建一个 UserService 类来执行创建操作：

package com.example.demo.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.stereotype.Service;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
   public void createUser(String username, String password, String email) {
       User user = new User(username, password, email);
       save(user);
   }
}

查询操作：

查询操作可以通过 UserMapper 接口来实现：

package com.example.demo.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.stereotype.Service;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
   public User getUserById(Long id) {
       return getById(id);
   }
}

更新操作：

更新操作可以通过 UserMapper 接口来实现：

package com.example.demo.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.stereotype.Service;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
   public void updateUser(Long id, String username, String password, String email) {
       User user = new User();
       user.setId(id);
       user.setUsername(username);
       user.setPassword(password);
       user.setEmail(email);
       updateById(user);
   }
}

删除操作：

删除操作可以通过 UserMapper 接口来实现：

package com.example.demo.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.stereotype.Service;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
   public void deleteUser(Long id) {
       removeById(id);
   }
}

分页与排序功能

分页功能：

使用 Page 类来进行分页操作：

package com.example.demo.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.stereotype.Service;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
   public Page<User> getUsersByPage(int currentPage, int pageSize) {
       Page<User> page = new Page<>(currentPage, pageSize);
       return page(page, new QueryWrapper<User>());
   }
}

排序功能：

使用 QueryWrapper 类来进行排序操作：

package com.example.demo.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.stereotype.Service;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
   public IPage<User> getUsersByPageAndSort(int currentPage, int pageSize, String orderByField) {
       Page<User> page = new Page<>(currentPage, pageSize);
       return page(page, new QueryWrapper<User>().orderByAsc(orderByField));
   }
}

测试代码

测试 CRUD 操作：

编写测试代码，对服务进行单元测试，确保功能正常。

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceTest {
   @Autowired
   private UserService userService;

   @Test
   public void testCreateUser() {
       userService.createUser("test", "password", "test@example.com");
       User user = userService.getUserById(1L);
       System.out.println(user);
   }

   @Test
   public void testGetUserById() {
       User user = userService.getUserById(1L);
       System.out.println(user);
   }

   @Test
   public void testUpdateUserById() {
       userService.updateUserById(1L, "test2", "password2", "test2@example.com");
   }

   @Test
   public void testDeleteUserById() {
       userService.deleteUserById(1L);
   }
}

MyBatis Plus条件构造器

QueryWrapper类介绍

QueryWrapper 类：
- QueryWrapper 是 MyBatis Plus 提供的一个条件构造器，可以方便地构建复杂的查询条件。
常用方法：
- eq：等于条件。
- ne：不等于条件。
- like：模糊查询条件。
- between：区间查询条件。
- orderByAsc：升序排序条件。
- orderByDesc：降序排序条件。

条件构造器使用案例

查询条件：

查询 username 为 test 的用户：

package com.example.demo.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.demo.entity.User;
import org.springframework.stereotype.Service;

@Service
public class UserService {
   public List<User> getUsersByUsername(String username) {
       QueryWrapper<User> queryWrapper = new QueryWrapper<>();
       queryWrapper.eq("username", username);
       return userMapper.selectList(queryWrapper);
   }
}

多条件查询：

查询 username 为 test 且 email 为 test@example.com 的用户：

package com.example.demo.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.demo.entity.User;
import org.springframework.stereotype.Service;

@Service
public class UserService {
   public List<User> getUsersByUsernameAndEmail(String username, String email) {
       QueryWrapper<User> queryWrapper = new QueryWrapper<>();
       queryWrapper.eq("username", username);
       queryWrapper.eq("email", email);
       return userMapper.selectList(queryWrapper);
   }
}

动态查询：

动态构建查询条件：

package com.example.demo.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.demo.entity.User;
import org.springframework.stereotype.Service;

@Service
public class UserService {
   public List<User> getUsersByDynamicQuery(String username, String email) {
       QueryWrapper<User> queryWrapper = new QueryWrapper<>();
       if (username != null) {
           queryWrapper.eq("username", username);
       }
       if (email != null) {
           queryWrapper.eq("email", email);
       }
       return userMapper.selectList(queryWrapper);
   }
}

测试代码

测试条件构造器：

编写测试代码，对条件构造器进行单元测试，确保功能正常。

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceTest {
   @Autowired
   private UserService userService;

   @Test
   public void testGetUsersByUsername() {
       List<User> users = userService.getUsersByUsername("test");
       System.out.println(users);
   }

   @Test
   public void testGetUsersByUsernameAndEmail() {
       List<User> users = userService.getUsersByUsernameAndEmail("test", "test@example.com");
       System.out.println(users);
   }

   @Test
   public void testGetUsersByDynamicQuery() {
       List<User> users = userService.getUsersByDynamicQuery("test", "test@example.com");
       System.out.println(users);
   }
}

MyBatis Plus的高级特性

自动填充与逻辑删除

自动填充：

自动填充是指在插入或更新数据时，自动填充某些字段的值。例如，创建时间、更新时间等。

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;

import java.time.LocalDateTime;

@TableName("user")
public class User {
   @TableId
   private Long id;
   private String username;
   private String password;
   private String email;

   @TableField(fill = FieldFill.INSERT)
   private LocalDateTime createTime;

   @TableField(fill = FieldFill.INSERT_UPDATE)
   private LocalDateTime updateTime;

   // 构造器和 getter/setter 方法

   public User() {
   }

   public User(String username, String password, String email) {
       this.username = username;
       this.password = password;
       this.email = email;
   }

   public Long getId() {
       return id;
   }

   public void setId(Long id) {
       this.id = id;
   }

   public String getUsername() {
       return username;
   }

   public void setUsername(String username) {
       this.username = username;
   }

   public String getPassword() {
       return password;
   }

   public void setPassword(String password) {
       this.password = password;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   public LocalDateTime getCreateTime() {
       return createTime;
   }

   public void setCreateTime(LocalDateTime createTime) {
       this.createTime = createTime;
   }

   public LocalDateTime getUpdateTime() {
       return updateTime;
   }

   public void setUpdateTime(LocalDateTime updateTime) {
       this.updateTime = updateTime;
   }
}

@TableField 注解中的 fill 属性可以指定填充时机，如 FieldFill.INSERT 表示仅在插入时填充，FieldFill.INSERT_UPDATE 表示在插入和更新时填充。

逻辑删除：

逻辑删除是指在数据库中不直接删除数据，而是通过一个字段标记数据是否被删除。

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;

import java.time.LocalDateTime;

@TableName("user")
public class User {
   @TableId
   private Long id;
   private String username;
   private String password;
   private String email;

   @TableField(fill = FieldFill.INSERT)
   private LocalDateTime createTime;

   @TableField(fill = FieldFill.INSERT_UPDATE)
   private LocalDateTime updateTime;

   @TableField(fill = FieldFill.INSERT_UPDATE)
   @TableLogic
   private Integer isDeleted;

   // 构造器和 getter/setter 方法

   public User() {
   }

   public User(String username, String password, String email) {
       this.username = username;
       this.password = password;
       this.email = email;
   }

   public Long getId() {
       return id;
   }

   public void setId(Long id) {
       this.id = id;
   }

   public String getUsername() {
       return username;
   }

   public void setUsername(String username) {
       this.username = username;
   }

   public String getPassword() {
       return password;
   }

   public void setPassword(String password) {
       this.password = password;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   public LocalDateTime getCreateTime() {
       return createTime;
   }

   public void setCreateTime(LocalDateTime createTime) {
       this.createTime = createTime;
   }

   public LocalDateTime getUpdateTime() {
       return updateTime;
   }

   public void setUpdateTime(LocalDateTime updateTime) {
       this.updateTime = updateTime;
   }

   public Integer getIsDeleted() {
       return isDeleted;
   }

   public void setIsDeleted(Integer isDeleted) {
       this.isDeleted = isDeleted;
   }
}

@TableField 和 @TableLogic 注解用于标记逻辑删除字段。

测试代码

测试自动填充与逻辑删除：

编写测试代码，对自动填充与逻辑删除进行单元测试，确保功能正常。

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceTest {
   @Autowired
   private UserService userService;

   @Test
   public void testCreateUserWithAutoFill() {
       User user = new User("test", "password", "test@example.com");
       userService.createUser(user);
       User createdUser = userService.getUserById(1L);
       System.out.println(createdUser);
   }

   @Test
   public void testLogicalDelete() {
       User user = userService.getUserById(1L);
       userService.deleteUserById(1L);
       user = userService.getUserById(1L);
       System.out.println(user);
   }
}

乐观锁机制

乐观锁机制：

乐观锁机制是指在更新数据时，检查数据的版本号是否一致，如果不一致则认为数据已被其他事务修改，从而回滚事务。

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.Version;

import java.time.LocalDateTime;

@TableName("user")
public class User {
   @TableId
   private Long id;
   private String username;
   private String password;
   private String email;

   @TableField(fill = FieldFill.INSERT)
   private LocalDateTime createTime;

   @TableField(fill = FieldFill.INSERT_UPDATE)
   private LocalDateTime updateTime;

   @Version
   @TableField(fill = FieldFill.INSERT)
   private Integer version;

   // 构造器和 getter/setter 方法

   public User() {
   }

   public User(String username, String password, String email) {
       this.username = username;
       this.password = password;
       this.email = email;
   }

   public Long getId() {
       return id;
   }

   public void setId(Long id) {
       this.id = id;
   }

   public String getUsername() {
       return username;
   }

   public void setUsername(String username) {
       this.username = username;
   }

   public String getPassword() {
       return password;
   }

   public void setPassword(String password) {
       this.password = password;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   public LocalDateTime getCreateTime() {
       return createTime;
   }

   public void setCreateTime(LocalDateTime createTime) {
       this.createTime = createTime;
   }

   public LocalDateTime getUpdateTime() {
       return updateTime;
   }

   public void setUpdateTime(LocalDateTime updateTime) {
       this.updateTime = updateTime;
   }

   public Integer getVersion() {
       return version;
   }

   public void setVersion(Integer version) {
       this.version = version;
   }
}

@Version 注解用于标记版本号字段。

测试代码

测试乐观锁机制：

编写测试代码，对乐观锁机制进行单元测试，确保功能正常。

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceTest {
   @Autowired
   private UserService userService;

   @Test
   public void testOptimisticLocking() {
       User user = userService.getUserById(1L);
       userService.updateUserById(1L, "test2", "password2", "test2@example.com");
       userService.updateUserById(1L, "test3", "password3", "test3@example.com");
   }
}

事务管理

事务管理：

MyBatis Plus 提供了对事务的管理功能，可以方便地进行事务控制。

package com.example.demo.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
   @Transactional
   public void createUserAndEmail(String username, String password, String email) {
       User user = new User(username, password, email);
       save(user);
       // 假设有另一个方法 updateEmail
       // updateEmail(email);
   }
}

使用 @Transactional 注解来控制事务。

测试代码

测试事务管理：

编写测试代码，对事务管理进行单元测试，确保功能正常。

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceTest {
   @Autowired
   private UserService userService;

   @Test
   public void testTransactionManagement() {
       try {
           userService.createUserAndEmail("test", "password", "test@example.com");
           throw new RuntimeException("Simulate Exception");
       } catch (Exception e) {
           System.out.println("Transaction rollback because of exception");
       }
   }
}

MyBatis Plus实战案例

用户管理模块设计与实现

需求分析：
- 用户管理模块需要实现用户的基本 CRUD 操作，并支持分页、排序等功能。

实体类：

User 实体类定义如下：

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.Version;

import java.time.LocalDateTime;

@TableName("user")
public class User {
   @TableId
   private Long id;
   private String username;
   private String password;
   private String email;

   @TableField(fill = FieldFill.INSERT)
   private LocalDateTime createTime;

   @TableField(fill = FieldFill.INSERT_UPDATE)
   private LocalDateTime updateTime;

   @Version
   @TableField(fill = FieldFill.INSERT)
   private Integer version;

   // 构造器和 getter/setter 方法

   public User() {
   }

   public User(String username, String password, String email) {
       this.username = username;
       this.password = password;
       this.email = email;
   }

   public Long getId() {
       return id;
   }

   public void setId(Long id) {
       this.id = id;
   }

   public String getUsername() {
       return username;
   }

   public void setUsername(String username) {
       this.username = username;
   }

   public String getPassword() {
       return password;
   }

   public void setPassword(String password) {
       this.password = password;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   public LocalDateTime getCreateTime() {
       return createTime;
   }

   public void setCreateTime(LocalDateTime createTime) {
       this.createTime = createTime;
   }

   public LocalDateTime getUpdateTime() {
       return updateTime;
   }

   public void setUpdateTime(LocalDateTime updateTime) {
       this.updateTime = updateTime;
   }

   public Integer getVersion() {
       return version;
   }

   public void setVersion(Integer version) {
       this.version = version;
   }
}

Mapper 接口：

UserMapper 接口定义如下：

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.User;

public interface UserMapper extends BaseMapper<User> {
}

Service 实现：

UserService 类实现 CRUD 操作：

package com.example.demo.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService extends ServiceImpl<UserMapper, User> {
   public void createUser(String username, String password, String email) {
       User user = new User(username, password, email);
       save(user);
   }

   public User getUserById(Long id) {
       return getOne(id);
   }

   public void updateUserById(Long id, String username, String password, String email) {
       User user = new User();
       user.setId(id);
       user.setUsername(username);
       user.setPassword(password);
       user.setEmail(email);
       updateById(user);
   }

   public void deleteUserById(Long id) {
       removeById(id);
   }

   @Transactional
   public void createUserAndEmail(String username, String password, String email) {
       User user = new User(username, password, email);
       save(user);
       // 假设有另一个方法 updateEmail
       // updateEmail(email);
   }
}

测试代码

测试用户管理模块：

编写测试代码，对用户管理模块进行单元测试，确保功能正常。

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceTest {
   @Autowired
   private UserService userService;

   @Test
   public void testCreateUser() {
       userService.createUser("test", "password", "test@example.com");
       User user = userService.getUserById(1L);
       System.out.println(user);
   }

   @Test
   public void testGetUserById() {
       User user = userService.getUserById(1L);
       System.out.println(user);
   }

   @Test
   public void testUpdateUserById() {
       userService.updateUserById(1L, "test2", "password2", "test2@example.com");
   }

   @Test
   public void testDeleteUserById() {
       userService.deleteUserById(1L);
   }
}

商品管理模块设计与实现

需求分析：
- 商品管理模块需要实现商品的基本 CRUD 操作，并支持分页、排序等功能。

实体类：

Product 实体类定义如下：

package com.example.demo.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.time.LocalDateTime;

@TableName("product")
public class Product {
   @TableId
   private Long id;
   private String name;
   private Double price;
   private Integer stock;

   @TableField(fill = FieldFill.INSERT)
   private LocalDateTime createTime;

   @TableField(fill = FieldFill.INSERT_UPDATE)
   private LocalDateTime updateTime;

   // 构造器和 getter/setter 方法

   public Product() {
   }

   public Product(String name, Double price, Integer stock) {
       this.name = name;
       this.price = price;
       this.stock = stock;
   }

   public Long getId() {
       return id;
   }

   public void setId(Long id) {
       this.id = id;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public Double getPrice() {
       return price;
   }

   public void setPrice(Double price) {
       this.price = price;
   }

   public Integer getStock() {
       return stock;
   }

   public void setStock(Integer stock) {
       this.stock = stock;
   }

   public LocalDateTime getCreateTime() {
       return createTime;
   }

   public void setCreateTime(LocalDateTime createTime) {
       this.createTime = createTime;
   }

   public LocalDateTime getUpdateTime() {
       return updateTime;
   }

   public void setUpdateTime(LocalDateTime updateTime) {
       this.updateTime = updateTime;
   }
}

Mapper 接口：

ProductMapper 接口定义如下：

package com.example.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.Product;

public interface ProductMapper extends BaseMapper<Product> {
}

Service 实现：

ProductService 类实现 CRUD 操作：

package com.example.demo.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.Product;
import com.example.demo.mapper.ProductMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ProductService extends ServiceImpl<ProductMapper, Product> {
   public void createProduct(String name, Double price, Integer stock) {
       Product product = new Product(name, price, stock);
       save(product);
   }

   public Product getProductById(Long id) {
       return getOne(id);
   }

   public void updateProductById(Long id, String name, Double price, Integer stock) {
       Product product = new Product();
       product.setId(id);
       product.setName(name);
       product.setPrice(price);
       product.setStock(stock);
       updateById(product);
   }

   public void deleteProductById(Long id) {
       removeById(id);
   }

   @Transactional
   public void createProductAndStock(String name, Double price, Integer stock) {
       Product product = new Product(name, price, stock);
       save(product);
       // 假设有另一个方法 updateStock
       // updateStock(stock);
   }
}

测试代码

测试商品管理模块：

编写测试代码，对商品管理模块进行单元测试，确保功能正常。

package com.example.demo;

import com.example.demo.entity.Product;
import com.example.demo.service.ProductService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class ProductServiceTest {
   @Autowired
   private ProductService productService;

   @Test
   public void testCreateProduct() {
       productService.createProduct("test", 9.99, 10);
       Product product = productService.getProductById(1L);
       System.out.println(product);
   }

   @Test
   public void testGetProductById() {
       Product product = productService.getProductById(1L);
       System.out.println(product);
   }

   @Test
   public void testUpdateProductById() {
       productService.updateProductById(1L, "test2", 9.99, 10);
   }

   @Test
   public void testDeleteProductById() {
       productService.deleteProductById(1L);
   }
}

项目部署与测试

部署环境：
- 确保数据库已经启动，并且项目中的数据库连接信息已经正确配置。
启动项目：
- 通过 IDEA 或者命令行启动 Spring Boot 项目。

测试代码：

编写测试代码，对服务进行单元测试，确保功能正常。


package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceTest {
   @Autowired
   private UserService userService;

   @Test
   public void testCreateUser() {
       userService.createUser("test", "password", "test@example.com");
       User user = userService.getUserById(1L);
       System.out.println(user);
   }

   @Test
   public void testGetUserById() {
       User user = userService.getUserById(1L);
       System.out.println(user);
   }

   @Test
   public void testUpdateUserById() {
       userService.updateUserById(1L, "test2", "password2", "test2@example.com");
   }

   @Test
   public void testDeleteUserById() {
       userService.deleteUserById(1L);
   }
}
``

通过以上步骤，你可以完成 MyBatis Plus 的基本使用和高级特性的应用，实现一个简单的用户管理模块和商品管理模块。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

侃侃无极

手记
篇

粉丝

7

获赞与收藏

25

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19195 313

Java 并发原理入门教程

26个小节 38920 566

Java 入门教程

50个小节 341149 3156

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

MyBatis Plus入门：简洁教程助你快速上手

MyBatis Plus是什么

MyBatis Plus的优势

MyBatis Plus的安装与集成

创建项目环境

添加MyBatis Plus依赖

数据库连接配置

实体类与表的映射

CRUD操作实例

分页与排序功能

测试代码

QueryWrapper类介绍

条件构造器使用案例

测试代码

自动填充与逻辑删除

测试代码

乐观锁机制

测试代码

事务管理

测试代码

用户管理模块设计与实现

测试代码

商品管理模块设计与实现

测试代码

项目部署与测试

阅读免费教程