首页 > 软件编程 > java > Spring Boot 整合 MyBatis-Plus

Spring Boot 中整合 MyBatis-Plus详细步骤(最新推荐)

2025-01-03 11:24:25 作者：颜淡慕潇

本文详细介绍了如何在SpringBoot项目中整合MyBatis-Plus,包括整合步骤、基本CRUD操作、分页查询、批量操作、自定义SQL操作等,通过这些步骤,开发者可以快速实现数据库操作,提高开发效率,感兴趣的朋友一起看看吧

在 Spring Boot 中整合 MyBatis-Plus 可以按照以下步骤进行：

一、整合步骤

1. 创建 Spring Boot 项目

首先，使用 Spring Initializr（https://start.spring.io/）创建一个新的 Spring Boot 项目。在创建过程中，选择以下依赖：

Spring Web
MySQL Driver
MyBatis-Plus

2. 配置项目依赖

如果手动创建 pom.xml 文件，确保添加以下依赖：

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- MyBatis-Plus Starter -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>最新版本</version>
    </dependency>
    <!-- MySQL Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- Spring Boot Starter Test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

请将 最新版本 替换为 MyBatis-Plus 的实际最新版本号。

3. 配置数据源

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

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/yourdatabase
    username: yourusername
    password: yourpassword
    driver-class-name: com.mysql.cj.jdbc.Driver

将 yourdatabase、yourusername 和 yourpassword 替换为实际的数据库名称、用户名和密码。

4. 创建实体类

创建一个 Java 实体类，用于映射数据库表。例如，创建一个 User 实体类：

package com.example.demo.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
@Data
@TableName("user")
public class User {
    private Long id;
    private String username;
    private String password;
}

@Data 是 Lombok 注解，用于自动生成 getter、setter、equals、hashCode 和 toString 方法。@TableName 注解指定实体类对应的数据库表名。

5. 创建 Mapper 接口

创建一个 Mapper 接口，继承 BaseMapper 接口，BaseMapper 是 MyBatis-Plus 提供的基础接口，包含了常用的 CRUD 方法。例如，创建一个 UserMapper 接口：

package com.example.demo.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface UserMapper extends BaseMapper<User> {
    // 可以在这里定义自定义的 SQL 方法
}

@Mapper 注解用于将该接口标记为 MyBatis 的 Mapper 接口。

6. 创建 Service 层

创建一个 Service 接口和其实现类。例如，创建一个 UserService 接口和 UserServiceImpl 实现类：

package com.example.demo.service;
import com.example.demo.entity.User;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
public interface UserService extends IService<User> {
    // 可以在这里定义自定义的业务方法
}

package com.example.demo.service.impl;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import com.example.demo.service.UserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 如果需要，可以重写或实现自定义方法
}

ServiceImpl 是 MyBatis-Plus 提供的基础 Service 实现类，它提供了基本的 CRUD 方法实现。

7. 创建 Controller 层

创建一个 Controller 层，用于处理客户端请求。例如，创建一个 UserController：

package com.example.demo.controller;
import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;
    @GetMapping
    public List<User> findAll() {
        return userService.list();
    }
    @GetMapping("/{id}")
    public User findById(@PathVariable Long id) {
        return userService.getById(id);
    }
    @PostMapping
    public boolean save(@RequestBody User user) {
        return userService.save(user);
    }
    @PutMapping
    public boolean update(@RequestBody User user) {
        return userService.updateById(user);
    }
    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable Long id) {
        return userService.removeById(id);
    }
}

8. 配置 MyBatis-Plus 扫描

在 Spring Boot 主应用类上添加 @MapperScan 注解，扫描 Mapper 接口所在的包：

package com.example.demo;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@MapperScan("com.example.demo.mapper")
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

9. 测试

可以使用 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;
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
public class DemoApplicationTests {
    @Autowired
    private UserService userService;
    @Test
    public void testFindAll() {
        assertTrue(userService.list().size() >= 0);
    }
    @Test
    public void testFindById() {
        User user = new User();
        user.setUsername("testuser");
        user.setPassword("testpassword");
        userService.save(user);
        assertNotNull(userService.getById(user.getId()));
    }
    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("newuser");
        user.setPassword("newpassword");
        assertTrue(userService.save(user));
    }
    @Test
    public void testUpdate() {
        User user = new User();
        user.setUsername("updateuser");
        user.setPassword("updatepassword");
        userService.save(user);
        user.setPassword("newupdatepassword");
        assertTrue(userService.updateById(user));
    }
    @Test
    public void testDelete() {
        User user = new User();
        user.setUsername("deleteuser");
        user.setPassword("deletepassword");
        userService.save(user);
        assertTrue(userService.removeById(user.getId()));
    }
}

通过以上步骤，你就可以在 Spring Boot 项目中成功整合 MyBatis-Plus，并实现基本的 CRUD 操作。在实际项目中，你可以根据需求进一步扩展和优化代码。

二、基本 CRUD 操作

在前面整合的基础上，我们已经有了基本的 CRUD 方法。

新增操作

在 UserService 中调用 save 方法：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 新增操作
    @Override
    public boolean saveUser(User user) {
        return this.save(user);
    }
}

查询操作

根据 ID 查询：调用 getById 方法。

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 根据 ID 查询
    @Override
    public User getUserById(Long id) {
        return this.getById(id);
    }
}

查询所有：调用 list 方法。

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 查询所有
    @Override
    public List<User> getAllUsers() {
        return this.list();
    }
}

更新操作

调用 updateById 方法：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 更新操作
    @Override
    public boolean updateUser(User user) {
        return this.updateById(user);
    }
}

删除操作

根据 ID 删除：调用 removeById 方法。

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 根据 ID 删除
    @Override
    public boolean deleteUserById(Long id) {
        return this.removeById(id);
    }
}

条件查询

使用 QueryWrapper 构建查询条件。

简单条件查询

例如，查询用户名等于某个值的用户：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Override
    public List<User> findUsersByUsername(String username) {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username", username);
        return this.list(queryWrapper);
    }
}

复杂条件查询

多个条件组合，例如查询用户名包含某个字符串且年龄大于某个值的用户：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Override
    public List<User> findComplexUsers(String usernameLike, Integer ageGreaterThan) {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("username", usernameLike);
        queryWrapper.gt("age", ageGreaterThan);
        return this.list(queryWrapper);
    }
}

分页查询

使用 Page 类实现分页查询。

首先，在 UserService 中定义分页查询方法：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Override
    public Page<User> getUserPage(int current, int size) {
        Page<User> page = new Page<>(current, size);
        return this.page(page);
    }
}

批量操作

批量插入

使用 saveBatch 方法批量插入用户：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Override
    public boolean saveUserBatch(List<User> userList) {
        return this.saveBatch(userList);
    }
}

批量更新

使用 updateBatchById 方法批量更新用户：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Override
    public boolean updateUserBatch(List<User> userList) {
        return this.updateBatchById(userList);
    }
}

批量删除

使用 removeByIds 方法批量删除用户：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Override
    public boolean deleteUserBatch(List<Long> idList) {
        return this.removeByIds(idList);
    }
}

自定义 SQL 操作

如果 MyBatis-Plus 提供的内置方法无法满足需求，可以在 Mapper 接口中定义自定义 SQL 方法。

在 Mapper 接口中定义方法

@Mapper
public interface UserMapper extends BaseMapper<User> {
    @Select("SELECT * FROM user WHERE age > #{age}")
    List<User> findUsersByAge(int age);
}

在 Service 层调用自定义方法

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Override
    public List<User> findUsersByAge(int age) {
        return userMapper.findUsersByAge(age);
    }
}

示例代码总结

上述示例展示了在 Spring Boot 中使用 MyBatis-Plus 进行各种数据库操作的方法。在实际项目中，可以根据具体需求，在 Service 层和 Mapper 层灵活组合和扩展这些方法，以实现复杂的业务逻辑。

注意事项

确保数据库表结构与实体类属性对应，否则可能导致数据操作异常。
在使用 QueryWrapper 构建条件时，注意条件的正确性和安全性，防止 SQL 注入。
对于分页操作，要合理设置分页参数，避免数据量过大导致性能问题。

通过以上内容，你可以全面掌握在 Spring Boot 中使用 MyBatis-Plus 进行数据库操作的方法。

到此这篇关于Spring Boot 中整合 MyBatis-Plus详细步骤的文章就介绍到这了,更多相关Spring Boot 整合 MyBatis-Plus内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！