手记

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

侃侃无极
2024-11-15 19:26:25浏览 62
概述

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

MyBatis Plus简介

MyBatis Plus是什么

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

MyBatis Plus的优势

  1. 简单易用的 CRUD 操作：

    • MyBatis Plus 提供了丰富的 CRUD 方法，使得数据库操作变得非常简单。例如，用户的增删改查操作可以通过简单的几行代码实现。

  2. 分页与排序功能：

    • MyBatis Plus 集成了分页插件，可以方便地进行分页操作。同时，它还提供了排序功能，使得数据的排序变得简单。

  3. 条件构造器：

    • MyBatis Plus 的条件构造器 QueryWrapper 可以帮助开发人员轻松构建复杂的查询条件，避免了在 SQL 中编写复杂的条件语句。

  4. 自动生成代码：

    • MyBatis Plus 提供了自动生成代码的功能，可以自动生成实体类、Mapper 接口等，减少了重复性的工作。

  5. 逻辑删除：

    • MyBatis Plus 支持逻辑删除，通过一个字段来标记数据是否被删除，而不是直接在数据库中删除数据。

  6. 乐观锁机制：

    • MyBatis Plus 集成了乐观锁机制，可以防止并发更新时的数据丢失。
  7. 自动填充与字段填充：
    • MyBatis Plus 提供了自动填充与字段填充的功能，可以在插入或更新数据时自动填充某些字段的值，如创建时间、更新时间等。

MyBatis Plus的安装与集成

  1. 安装与集成步骤：

    • 在你的项目中添加 MyBatis Plus 的依赖。

  2. 添加依赖：

    • 在 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'

  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快速入门

创建项目环境

  1. 创建 Spring Boot 项目：

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

添加MyBatis Plus依赖

  1. 添加依赖方式：

    • 如上文所述，通过在 Maven 或 Gradle 项目中添加 MyBatis Plus 的依赖。

  2. 配置文件位置：

    • 在 Spring Boot 项目中，配置文件通常位于 src/main/resources 目录下，文件名可以是 application.yml 或 application.properties。

  3. 配置文件内容：

    • 一些常用的配置项如下：
    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基础操作

数据库连接配置

  1. 数据库连接配置：

    • 在 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

实体类与表的映射

  1. 实体类定义：

    • 实体类通常对应数据库中的表。例如，定义一个 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操作实例

  1. 创建操作：

    • 创建一个 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);
   }
}

  2. 查询操作：

    • 查询操作可以通过 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);
   }
}

  3. 更新操作：

    • 更新操作可以通过 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);
   }
}

  4. 删除操作：

    • 删除操作可以通过 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);
   }
}

分页与排序功能

  1. 分页功能：

    • 使用 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>());
   }
}

  2. 排序功能：

    • 使用 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));
   }
}

测试代码

  1. 测试 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类介绍

  1. QueryWrapper 类：

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

条件构造器使用案例

  1. 查询条件：

    • 查询 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);
   }
}

  2. 多条件查询：

    • 查询 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);
   }
}

  3. 动态查询：

    • 动态构建查询条件：
    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);
   }
}

测试代码

  1. 测试条件构造器：

    • 编写测试代码，对条件构造器进行单元测试，确保功能正常。
    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的高级特性

自动填充与逻辑删除

  1. 自动填充：

    • 自动填充是指在插入或更新数据时，自动填充某些字段的值。例如，创建时间、更新时间等。
    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 表示在插入和更新时填充。

  1. 逻辑删除：

    • 逻辑删除是指在数据库中不直接删除数据，而是通过一个字段标记数据是否被删除。
    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 注解用于标记逻辑删除字段。

测试代码

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

    • 编写测试代码，对自动填充与逻辑删除进行单元测试，确保功能正常。
    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);
   }
}

乐观锁机制

  1. 乐观锁机制：

    • 乐观锁机制是指在更新数据时，检查数据的版本号是否一致，如果不一致则认为数据已被其他事务修改，从而回滚事务。
    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 注解用于标记版本号字段。

测试代码

  1. 测试乐观锁机制：

    • 编写测试代码，对乐观锁机制进行单元测试，确保功能正常。
    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");
   }
}

事务管理

  1. 事务管理：

    • 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 注解来控制事务。

测试代码

  1. 测试事务管理：

    • 编写测试代码，对事务管理进行单元测试，确保功能正常。
    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实战案例

用户管理模块设计与实现

  1. 需求分析：

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

  2. 实体类：

    • 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;
   }
}

  3. 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> {
}

  4. 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);
   }
}

测试代码

  1. 测试用户管理模块：

    • 编写测试代码，对用户管理模块进行单元测试，确保功能正常。
    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);
   }
}

商品管理模块设计与实现

  1. 需求分析：

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

  2. 实体类：

    • 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;
   }
}

  3. 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> {
}

  4. 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);
   }
}

测试代码

  1. 测试商品管理模块：

    • 编写测试代码，对商品管理模块进行单元测试，确保功能正常。
    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);
   }
}

项目部署与测试

  1. 部署环境：

    • 确保数据库已经启动，并且项目中的数据库连接信息已经正确配置。

  2. 启动项目：

    • 通过 IDEA 或者命令行启动 Spring Boot 项目。

  3. 测试代码：

    • 编写测试代码，对服务进行单元测试，确保功能正常。
    
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 的基本使用和高级特性的应用，实现一个简单的用户管理模块和商品管理模块。

相关标签
Java
开源
数据库
0人推荐
随时随地看视频
慕课网APP