程序员scholar
  • 开发笔记
  • 后端开发
scholar
2024-12-27
目录

基于 MyBatis curd

# 基于 MyBatis 的 CRUD

# 1. 数据库建表 SQL

-- 用户信息表的建表 SQL
CREATE TABLE user_info (
  id INT AUTO_INCREMENT PRIMARY KEY COMMENT '主键 ID',  -- 主键 ID，自动递增
  name VARCHAR(50) NOT NULL COMMENT '名称',                -- 用户名称，不能为空
  age INT NOT NULL COMMENT '年龄',                        -- 用户年龄，不能为空
  avatar VARCHAR(255) COMMENT '头像',                      -- 用户头像，允许为空
  address VARCHAR(255) COMMENT '地址'                      -- 用户地址，允许为空
) COMMENT '用户信息表';
1
2
3
4
5
6
7
8

# 2. 实体类（User.java）

package com.example.demo.entity;

import lombok.Data;

/**
 * 用户实体类
 */
@Data
public class User {
    private Integer id;          // 主键 ID
    private String name;         // 名称
    private Integer age;         // 年龄
    private String avatar;       // 头像
    private String address;      // 地址
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 3. Mapper 接口（UserMapper.java）

package com.example.demo.mapper;

import com.example.demo.entity.User;
import org.apache.ibatis.annotations.*;
import com.github.pagehelper.Page;
import java.util.List;

/**
 * 用户 Mapper 接口
 */
@Mapper
public interface UserMapper {

    /**
     * 获取用户列表（分页查询）
     * 使用 PageHelper 的分页插件
     *
     * @return 用户列表
     */
    @Select("SELECT * FROM user_info")
    Page<User> getUserList();

    /**
     * 获取用户总数
     *
     * @return 用户总数
     */
    @Select("SELECT COUNT(*) FROM user_info")
    int getUserCount();

    /**
     * 根据 ID 查询用户信息
     *
     * @param id 用户 ID
     * @return 用户信息
     */
    @Select("SELECT * FROM user_info WHERE id = #{id}")
    User getUserById(@Param("id") int id);

    /**
     * 新增用户
     *
     * @param user 用户信息
     * @return 插入条数
     */
    @Insert("INSERT INTO user_info (name, age, avatar, address) VALUES (#{name}, #{age}, #{avatar}, #{address})")
    int insertUser(User user);

    /**
     * 更新用户信息
     *
     * @param user 用户信息
     * @return 更新条数
     */
    @Update("UPDATE user_info SET name = #{name}, age = #{age}, avatar = #{avatar}, address = #{address} WHERE id = #{id}")
    int updateUser(User user);

    /**
     * 根据 ID 删除用户
     *
     * @param id 用户 ID
     * @return 删除条数
     */
    @Delete("DELETE FROM user_info WHERE id = #{id}")
    int deleteUserById(@Param("id") int id);

    /**
     * 批量删除用户
     *
     * @param ids 用户 ID 列表
     * @return 删除条数
     */
    @Delete({
        "<script>",
        "DELETE FROM user_info WHERE id IN",
        "<foreach collection='ids' item='id' open='(' separator=',' close=')'>",
        "#{id}",
        "</foreach>",
        "</script>"
    })
    int deleteUsersByIds(@Param("ids") List<Integer> ids);
    
    /**
     * 分页查询用户列表
     * 
     * @param name 搜索关键字
     * @return 用户列表
     */
    Page<User> searchUserByName(@Param("name") String name);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

# 4. 使用 PageHelper 分页插件

在 pom.xml 中添加 PageHelper 依赖：

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.2.13</version>
</dependency>
1
2
3
4
5

在 application.yml 中配置 PageHelper：

pagehelper:
  helperDialect: mysql
  reasonable: true
  supportMethodsArguments: true
  params: count=countSql
1
2
3
4
5

# 5. Mapper XML 配置（UserMapper.xml）

在使用 MyBatis 进行分页时，虽然我们可以直接在 Mapper 接口中编写 SQL 语句，但通常还是会通过 XML 文件配置更复杂的 SQL 逻辑。结合 PageHelper 分页插件，分页查询的 XML 配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.demo.mapper.UserMapper">

    <!-- 分页查询用户列表 -->
    <select id="getUserList" resultType="com.example.demo.entity.User">
        SELECT * FROM user_info
    </select>

    <!-- 查询用户总数 -->
    <select id="getUserCount" resultType="int">
        SELECT COUNT(*) FROM user_info
    </select>

    <!-- 根据 ID 查询用户信息 -->
    <select id="getUserById" resultType="com.example.demo.entity.User">
        SELECT * FROM user_info WHERE id = #{id}
    </select>

    <!-- 插入用户 -->
    <insert id="insertUser">
        INSERT INTO user_info (name, age, avatar, address)
        VALUES (#{name}, #{age}, #{avatar}, #{address})
    </insert>

    <!-- 更新用户信息 -->
    <update id="updateUser">
        UPDATE user_info SET
        name = #{name},
        age = #{age},
        avatar = #{avatar},
        address = #{address}
        WHERE id = #{id}
    </update>

    <!-- 根据 ID 删除用户 -->
    <delete id="deleteUserById">
        DELETE FROM user_info WHERE id = #{id}
    </delete>

    <!-- 批量删除用户 -->
    <delete id="deleteUsersByIds">
        DELETE FROM user_info WHERE id IN
        <foreach collection="ids" item="id" open="(" separator="," close=")">
            #{id}
        </foreach>
    </delete>
    
        <!-- 搜索并分页查询用户 -->
    <select id="searchUserByName" resultType="com.example.demo.entity.User">
        SELECT * FROM user_info
        WHERE name LIKE CONCAT('%', #{name}, '%')
    </select>

</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

关键点说明：

  • 在使用 PageHelper 插件进行分页时，getUserList 方法的 SQL 配置不需要写 LIMIT，PageHelper 会自动处理分页逻辑，只需编写基础的查询语句即可。
  • resultType 属性用于指定查询结果的映射类型，这里是映射到 User 实体类。
  • MyBatis 的 foreach 标签用于批量操作，如批量删除用户。

# 6. Service 接口（UserService.java）

package com.example.demo.service;

import com.example.demo.entity.User;
import com.github.pagehelper.Page;

import java.util.List;

/**
 * 用户服务接口
 */
public interface UserService {
    Page<User> getUserList(int page, int size);

    int getUserCount();

    User getUserById(int id);

    void saveUser(User user);

    void deleteUserById(int id);

    void deleteUsersByIds(List<Integer> ids);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 7. Service 实现类（UserServiceImpl.java）

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.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 用户服务实现类
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public Page<User> getUserList(int page, int size) {
        // 使用 PageHelper 进行分页
        PageHelper.startPage(page, size);
        return userMapper.getUserList();
    }

    @Override
    public int getUserCount() {
        return userMapper.getUserCount();
    }

    @Override
    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }

    @Override
    public void saveUser(User user) {
        if (user.getId() == null) {
            userMapper.insertUser(user);
        } else {
            userMapper.updateUser(user);
        }
    }

    @Override
    public void deleteUserById(int id) {
        userMapper.deleteUserById(id);
    }

    @Override
    public void deleteUsersByIds(List<Integer> ids) {
        userMapper.deleteUsersByIds(ids);
    }
    
   @Override
    public Page<User> searchUserByName(String name, int page, int size) {
        // 使用 PageHelper 进行分页
        PageHelper.startPage(page, size);
        return userMapper.searchUserByName(name);
    }    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# 8 Controller 层（UserController.java）

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import com.github.pagehelper.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 用户控制器
 */
@RestController
@RequestMapping("/api/user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 获取用户列表（分页）
     *
     * @param page 页码
     * @param size 每页条数
     * @return 分页结果
     */
    @GetMapping("/data")
    public Map<String, Object> getUserList(@RequestParam int page, @RequestParam int size) {
        Page<User> userList = userService.getUserList(page, size);
        int total = userService.getUserCount();
        Map<String, Object> result = new HashMap<>();
        result.put("data", userList.getResult());
        result.put("total", total);
        return result;
    }

    /**
     * 根据 ID 查询用户
     *
     * @param id 用户 ID
     * @return 用户信息
     */
    @GetMapping("/{id}")
    public User getUserById(@PathVariable int id) {
        return userService.getUserById(id);
    }

    /**
     * 新增用户
     *
     * @param user 用户信息
     * @return 操作结果
     */
    @PostMapping("/add")
    public String addUser(@RequestBody User user) {
        userService.saveUser(user);
        return "新增成功";
    }

    /**
     * 编辑用户信息
     *
     * @param user 用户信息
     * @return 操作结果
     */
    @PutMapping("/save/{id}")
    public String updateUser(@RequestBody User user, @PathVariable int id) {
        user.setId(id);
        userService.saveUser(user);
        return "编辑成功";
    }

    /**
     * 根据 ID 删除用户
     *
     * @param id 用户 ID
     * @return 操作结果
     */
    @DeleteMapping("/delete/{id}")
    public String deleteUserById(@PathVariable int id) {
        userService.deleteUserById(id);
        return "删除成功";
    }

    /**
     * 批量删除用户
     *
     * @param ids 用户 ID 列表
     * @return 操作结果
     */
    @PostMapping("/deleteRows")
    public String deleteUsersByIds(@RequestBody List<Integer> ids) {
        userService.deleteUsersByIds(ids);
        return "批量删除成功";
    }

    /**
     * 搜索用户并分页返回结果
     *
     * @param name 搜索关键字
     * @param page 页码
     * @param size 每页条数
     * @return 搜索结果
     */
    @GetMapping("/search")
    public Map<String, Object> searchUserByName(@RequestParam String name,
                                                @RequestParam int page,
                                                @RequestParam int size) {
        Page<User> userPage = userService.searchUserByName(name, page, size);
        Map<String, Object> result = new HashMap<>();
        result.put("data", userPage.getResult());
        result.put("total", userPage.getTotal());
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

# 9. 项目配置文件（application.yml）

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo_db?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: yourpassword
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis:
  mapper-locations: classpath*:mapper/*.xml
  type-aliases-package: com.example.demo.entity

pagehelper:
  helperDialect: mysql
  reasonable: true
  supportMethodsArguments: true
  params: count=countSql
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 10. 测试数据插入

INSERT INTO user_info (name, age, avatar, address) VALUES ('常涛', 35, NULL, '四川省 内江市');
INSERT INTO user_info (name, age, avatar, address) VALUES ('钱娜', 27, NULL, '山西省 晋中市');
INSERT INTO user_info (name, age, avatar, address) VALUES ('林艳', 24, NULL, '台湾 高雄市');
1
2
3

# 11. 用户信息管理接口文档

# 1. 获取用户列表（分页）

接口地址： /api/user/data

请求方式： GET

请求参数：

参数名 类型 是否必填 说明
page int 是 页码，从 1 开始
size int 是 每页显示的条数

响应参数：

参数名 类型 说明
data List<User> 用户列表数据
total int 用户总数

响应示例：

{
  "data": [
    {
      "id": 1,
      "name": "常涛",
      "age": 35,
      "avatar": null,
      "address": "四川省 内江市"
    },
    {
      "id": 2,
      "name": "钱娜",
      "age": 27,
      "avatar": null,
      "address": "山西省 晋中市"
    },
    {
      "id": 3,
      "name": "林艳",
      "age": 24,
      "avatar": null,
      "address": "台湾 高雄市"
    }
  ],
  "total": 3
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 2. 根据 ID 获取用户详情

接口地址： /api/user/{id}

请求方式： GET

请求参数：

参数名 类型 是否必填 说明
id int 是 用户 ID

响应参数：

参数名 类型 说明
id int 用户 ID
name String 用户名称
age int 用户年龄
avatar String 用户头像 URL
address String 用户地址

响应示例：

{
  "id": 1,
  "name": "常涛",
  "age": 35,
  "avatar": null,
  "address": "四川省 内江市"
}
1
2
3
4
5
6
7

# 3. 新增用户

接口地址： /api/user/add

请求方式： POST

请求参数：

参数名 类型 是否必填 说明
name String 是 用户名称
age int 是 用户年龄
avatar String 否 用户头像 URL
address String 是 用户地址

请求示例：

{
  "name": "张三",
  "age": 28,
  "avatar": null,
  "address": "北京市 朝阳区"
}
1
2
3
4
5
6

响应参数：

参数名 类型 说明
message String 操作结果

响应示例：

{
  "message": "新增成功"
}
1
2
3

# 4. 编辑用户信息

接口地址： /api/user/save/{id}

请求方式： PUT

请求参数：

参数名 类型 是否必填 说明
id int 是 用户 ID
name String 是 用户名称
age int 是 用户年龄
avatar String 否 用户头像 URL
address String 是 用户地址

请求示例：

{
  "name": "李四",
  "age": 30,
  "avatar": null,
  "address": "上海市 浦东新区"
}
1
2
3
4
5
6

响应参数：

参数名 类型 说明
message String 操作结果

响应示例：

{
  "message": "编辑成功"
}
1
2
3

# 5. 根据 ID 删除用户

接口地址： /api/user/delete/{id}

请求方式： DELETE

请求参数：

参数名 类型 是否必填 说明
id int 是 用户 ID

响应参数：

参数名 类型 说明
message String 操作结果

响应示例：

{
  "message": "删除成功"
}
1
2
3

# 6. 批量删除用户

接口地址： /api/user/deleteRows

请求方式： POST

请求参数：

参数名 类型 是否必填 说明
ids List<Integer> 是 用户 ID 列表

请求示例：

{
  "ids": [1, 2, 3]
}
1
2
3

响应参数：

参数名 类型 说明
message String 操作结果

响应示例：

{
  "message": "批量删除成功"
}
1
2
3

# 7. 搜索用户

接口地址： /api/user/search

请求方式： GET

请求参数：

参数名 类型 是否必填 说明
name String 是 搜索关键词

响应参数：

参数名 类型 说明
data List<User> 匹配的用户列表

响应示例：

[
  {
    "id": 1,
    "name": "钱涛",
    "age": 35,
    "avatar": null,
    "address": "四川省 内江市"
  },
  {
    "id": 2,
    "name": "钱娜",
    "age": 27,
    "avatar": null,
    "address": "山西省 晋中市"
  }
]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

API 使用说明

  • 所有接口返回的 message 字段用于提示操作是否成功。
  • 查询接口如 /data 和 /search 支持分页和关键字筛选。
  • 批量删除接口需要传递一个包含用户 ID 的列表，用于删除多条记录。
编辑此页 (opens new window)
上次更新: 2025/03/16, 22:19:39
通用 普通 注册模块
基于 MyBatis-Plus curd

← 基于 MyBatis-Plus curd→

Theme by Vdoing | Copyright © 2019-2025 程序员scholar