MyBatis-Plus入门案例

本文目录导读：

1. 环境准备
2. 创建实体类
3. 创建Mapper接口
4. 创建Service层
5. 创建Controller
6. 创建配置类（可选）
7. 启动类
8. 测试代码
9. 常用功能总结

我来为你提供一个完整的MyBatis-Plus入门案例，从环境搭建到基本CRUD操作。

环境准备

1 创建Spring Boot项目

在pom.xml中添加依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>mybatis-plus-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- MyBatis-Plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- 测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2 配置文件 application.yml

server:
  port: 8080
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis_plus_demo?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
# MyBatis-Plus配置
mybatis-plus:
  # 实体扫描，多个package用逗号或者分号分隔
  type-aliases-package: com.example.entity
  # 控制台打印SQL日志
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true
  # 全局配置
  global-config:
    db-config:
      # 主键类型
      id-type: auto
      # 表名前缀
      # table-prefix: t_
      # 逻辑删除字段
      logic-delete-field: deleted
      logic-delete-value: 1
      logic-not-delete-value: 0

3 数据库表结构

-- 创建数据库
CREATE DATABASE IF NOT EXISTS mybatis_plus_demo 
DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
USE mybatis_plus_demo;
-- 用户表
DROP TABLE IF EXISTS user;
CREATE TABLE user (
    id BIGINT(20) PRIMARY KEY AUTO_INCREMENT COMMENT '主键ID',
    name VARCHAR(30) NOT NULL COMMENT '姓名',
    age INT(11) DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    deleted INT(1) DEFAULT 0 COMMENT '逻辑删除标记'
) COMMENT '用户表';
-- 插入测试数据
INSERT INTO user (name, age, email) VALUES
('张三', 25, 'zhangsan@example.com'),
('李四', 30, 'lisi@example.com'),
('王五', 28, 'wangwu@example.com'),
('赵六', 22, 'zhaoliu@example.com');

创建实体类

package com.example.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.time.LocalDateTime;
@Data
@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;
    @TableLogic
    @TableField(select = false)
    private Integer deleted;
}

创建Mapper接口

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

创建Service层

package com.example.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.example.entity.User;
public interface UserService extends IService<User> {
    // 业务方法
}

package com.example.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.entity.User;
import com.example.mapper.UserMapper;
import com.example.service.UserService;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 实现业务方法
}

创建Controller

package com.example.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.entity.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;
    /**
     * 查询所有用户
     */
    @GetMapping("/list")
    public List<User> list() {
        return userService.list();
    }
    /**
     * 根据ID查询用户
     */
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getById(id);
    }
    /**
     * 新增用户
     */
    @PostMapping("/add")
    public User addUser(@RequestBody User user) {
        userService.save(user);
        return user;
    }
    /**
     * 更新用户
     */
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        userService.updateById(user);
        return user;
    }
    /**
     * 删除用户（逻辑删除）
     */
    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable Long id) {
        boolean success = userService.removeById(id);
        return success ? "删除成功" : "删除失败";
    }
    /**
     * 条件查询 - 通过名字查询
     */
    @GetMapping("/search")
    public List<User> searchUser(@RequestParam(required = false) String name,
                                @RequestParam(required = false) Integer age) {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        if (name != null && !name.isEmpty()) {
            wrapper.like("name", name);
        }
        if (age != null) {
            wrapper.eq("age", age);
        }
        wrapper.orderByDesc("age");
        return userService.list(wrapper);
    }
    /**
     * 分页查询
     */
    @GetMapping("/page")
    public IPage<User> pageQuery(@RequestParam(defaultValue = "1") Integer current,
                                @RequestParam(defaultValue = "10") Integer size) {
        Page<User> page = new Page<>(current, size);
        userService.page(page);
        return page;
    }
    /**
     * 批量删除
     */
    @DeleteMapping("/batch")
    public String batchDelete(@RequestBody List<Long> ids) {
        boolean success = userService.removeByIds(ids);
        return success ? "批量删除成功" : "批量删除失败";
    }
    /**
     * 使用条件构造器精确更新
     */
    @PutMapping("/update-by-condition")
    public String updateByCondition(@RequestParam Long id, @RequestParam Integer age) {
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", id)
                    .set("age", age);
        boolean success = userService.update(updateWrapper);
        return success ? "更新成功" : "更新失败";
    }
}

创建配置类（可选）

1 分页插件配置

package com.example.config;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 添加分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

2 字段自动填充配置（可选）

package com.example.config;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now());
        this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }
    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }
}

启动类

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

测试代码

package com.example;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@SpringBootTest
class MybatisPlusDemoApplicationTests {
    @Autowired
    private UserMapper userMapper;
    /**
     * 测试插入
     */
    @Test
    void testInsert() {
        User user = new User();
        user.setName("测试用户");
        user.setAge(20);
        user.setEmail("test@example.com");
        int result = userMapper.insert(user);
        System.out.println("插入结果：" + result);
        System.out.println("生成ID：" + user.getId());
    }
    /**
     * 测试查询
     */
    @Test
    void testSelect() {
        // 根据ID查询
        User user = userMapper.selectById(1L);
        System.out.println("根据ID查询：" + user);
        // 查询所有
        List<User> userList = userMapper.selectList(null);
        System.out.println("查询所有：" + userList);
        // 条件查询
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("age", 25);
        List<User> ageList = userMapper.selectList(wrapper);
        System.out.println("条件查询：" + ageList);
    }
    /**
     * 测试更新
     */
    @Test
    void testUpdate() {
        User user = new User();
        user.setId(1L);
        user.setAge(26);
        int result = userMapper.updateById(user);
        System.out.println("更新结果：" + result);
    }
    /**
     * 测试删除
     */
    @Test
    void testDelete() {
        // 根据ID删除（逻辑删除）
        int result = userMapper.deleteById(1L);
        System.out.println("删除结果：" + result);
        // 根据条件删除
        Map<String, Object> map = new HashMap<>();
        map.put("name", "测试用户");
        int result2 = userMapper.deleteByMap(map);
        System.out.println("条件删除结果：" + result2);
    }
}

常用功能总结

1 QueryWrapper常用方法

// 创建查询条件
QueryWrapper<User> wrapper = new QueryWrapper<>();
// 等于
wrapper.eq("name", "张三");
// 不等于
wrapper.ne("age", 25);
// 大于
wrapper.gt("age", 20);
// 小于
wrapper.lt("age", 30);
// 大于等于
wrapper.ge("age", 25);
// 小于等于
wrapper.le("age", 25);
// LIKE查询
wrapper.like("name", "张");
// IN查询
wrapper.in("id", Arrays.asList(1, 2, 3));
// BETWEEN
wrapper.between("age", 20, 30);
// 排序
wrapper.orderByAsc("age");
wrapper.orderByDesc("create_time");
// 限制数量
wrapper.last("LIMIT 10");

2 常用注解

@TableName("user")                    // 指定表名
@TableId(type = IdType.AUTO)          // 主键策略
@TableField("name")                   // 指定字段名
@TableField(exist = false)            // 非数据库字段
@TableField(fill = FieldFill.INSERT)  // 自动填充
@TableLogic                           // 逻辑删除
@Version                              // 乐观锁

这个入门案例涵盖了MyBatis-Plus的主要功能，包括基本的CRUD操作、条件构造器、分页查询、逻辑删除等特性，你可以根据实际需求进行扩展和调整。