MyBatis分页查询实战案例完整流程

SELECT * FROM users LIMIT 10 OFFSET 20;

sequenceDiagram
    用户->>前端: 点击下一页
    前端->>后端: 发送pageNum=2, pageSize=10
    后端->>数据库: 执行分页SQL查询
    数据库-->>后端: 返回第2页数据
    后端-->>前端: 返回JSON格式分页结果
    前端-->>用户: 展示第2页数据

<select id="selectUsers" resultType="User">
    SELECT * FROM users
    <where>
        <if test="name != null">
            AND name LIKE CONCAT('%', #{name}, '%')
        </if>
    </where>
    LIMIT #{pageSize} OFFSET #{offset}
</select>

int pageNum = 2;
int pageSize = 10;
int offset = (pageNum - 1) * pageSize;
List<User> users = userMapper.selectUsers(offset, pageSize);

PageHelper.startPage(pageNum, pageSize);
List<User> users = userMapper.selectAll();
PageInfo<User> pageInfo = new PageInfo<>(users);

SELECT * FROM users LIMIT 10 OFFSET 10;
SELECT COUNT(*) FROM users;

<!-- MyBatis PageHelper -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>5.2.0</version>
</dependency>

<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor">
        <!-- 可选参数 -->
        <property name="helperDialect" value="mysql"/>
        <property name="reasonable" value="true"/>
        <property name="supportMethodsArguments" value="true"/>
        <property name="params" value="count=countSql"/>
    </plugin>
</plugins>

pagehelper:
  helper-dialect: mysql
  reasonable: true
  support-methods-arguments: true
  params: count=countSql

import com.github.pagehelper.PageHelper;
import java.util.List;
public List<User> getUsers(int pageNum, int pageSize) {
    // 开启分页
    PageHelper.startPage(pageNum, pageSize);
    // 查询用户列表（自动分页）
    return userMapper.selectAll();
}

import com.github.pagehelper.PageInfo;
public PageInfo<User> getUsers(int pageNum, int pageSize) {
    PageHelper.startPage(pageNum, pageSize);
    List<User> users = userMapper.selectAll();
    return new PageInfo<>(users);
}

PageHelper.startPage(1, 10, false);
List<User> users = userMapper.selectAll();

PageInfo<User> pageInfo = new PageInfo<>(users);
System.out.println("当前页码：" + pageInfo.getPageNum());
System.out.println("每页数量：" + pageInfo.getPageSize());
System.out.println("总记录数：" + pageInfo.getTotal());
System.out.println("总页数：" + pageInfo.getPages());

graph TD
    A[调用PageHelper.startPage] --> B{判断是否合理化分页}
    B -->|是| C[自动调整页码]
    B -->|否| D[使用原始页码]
    C --> E[生成分页SQL]
    D --> E
    E --> F[执行SQL查询]
    F --> G[返回分页数据]
    G --> H[创建PageInfo对象]
    H --> I[返回给调用方]

public interface IUserMapper {
    List<User> selectAllUsers();
}

<select id="selectAllUsers" resultType="User">
    SELECT * FROM users
</select>

public interface IUserMapper {
    List<User> selectAllUsers();
}

PageHelper.startPage(1, 10);
List<User> users = userMapper.selectAllUsers();

<select id="selectUsersByCondition" resultType="User">
    SELECT * FROM users
    <where>
        <if test="username != null and username != ''">
            AND username LIKE CONCAT('%', #{username}, '%')
        </if>
        <if test="email != null and email != ''">
            AND email = #{email}
        </if>
    </where>
</select>

PageHelper.startPage(1, 10);
List<User> users = userMapper.selectUsersByCondition("john", null);

<select id="selectUsersByCondition" resultType="User">
    SELECT id, username, email FROM users
    <where>
        <if test="username != null and username != ''">
            AND username LIKE CONCAT('%', #{username}, '%')
        </if>
        <if test="email != null and email != ''">
            AND email = #{email}
        </if>
    </where>
</select>

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private IUserMapper userMapper;
    @Test
    public void testSelectUsersWithPagination() {
        PageHelper.startPage(1, 10);
        List<User> users = userMapper.selectAllUsers();
        Assert.notEmpty(users, "用户列表不能为空");
        Assert.isTrue(users.size() <= 10, "返回结果数量不应超过每页限制");
    }
}

@Test(expected = RuntimeException.class)
public void testInvalidPageNumber() {
    PageHelper.startPage(-1, 10); // 无效页码
    userMapper.selectAllUsers();
}

graph TD
    A[调用Mapper方法] --> B{PageHelper是否启动}
    B -->|是| C[拦截SQL并添加分页语句]
    C --> D[执行SQL查询]
    D --> E[封装结果为PageInfo]
    B -->|否| F[直接执行SQL查询]
    F --> G[返回原始结果]

public interface UserService {
    PageInfo<UserDTO> getUsersByRoleAndStatus(String role, String status, int pageNum, int pageSize);
}

graph TD
    A[Controller层接收请求] --> B[调用Service层方法]
    B --> C[Service层封装参数]
    C --> D[调用PageHelper.startPage()]
    D --> E[执行Mapper层查询]
    E --> F[封装PageInfo对象]
    F --> G[返回分页结果]

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public PageInfo<UserDTO> getUsersByRoleAndStatus(String role, String status, int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<UserDTO> users = userMapper.selectByRoleAndStatus(role, status);
        return new PageInfo<>(users);
    }
}

PageInfo<UserDTO> pageInfo = new PageInfo<>(users);

@Override
public PageInfo<UserDTO> getUsersByRoleAndStatus(String role, String status, int pageNum, int pageSize) {
    PageHelper.startPage(pageNum, pageSize);
    List<User> users = userMapper.selectByRoleAndStatus(role, status);
    // 数据转换与脱敏
    List<UserDTO> dtoList = users.stream()
        .map(user -> {
            UserDTO dto = new UserDTO();
            dto.setId(user.getId());
            dto.setUsername(user.getUsername());
            dto.setEmail("****@example.com"); // 脱敏处理
            return dto;
        })
        .collect(Collectors.toList());
    return new PageInfo<>(dtoList);
}

@Override
public PageInfo<UserDTO> getUsersByRoleAndStatus(String role, String status, int pageNum, int pageSize) {
    try {
        PageHelper.startPage(pageNum, pageSize);
        List<User> users = userMapper.selectByRoleAndStatus(role, status);
        return new PageInfo<>(convertToDTO(users));
    } catch (Exception e) {
        // 捕获异常并封装为业务异常
        throw new BusinessException("分页查询失败：" + e.getMessage(), e);
    }
}

graph TD
    A[Service层执行分页] --> B{是否发生异常?}
    B -->|是| C[捕获异常]
    C --> D[封装为业务异常]
    D --> E[抛出异常]
    B -->|否| F[正常返回PageInfo]

private static final Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);
@Override
public PageInfo<UserDTO> getUsersByRoleAndStatus(String role, String status, int pageNum, int pageSize) {
    logger.info("开始分页查询，角色：{}, 状态：{}, 当前页：{}, 每页记录数：{}", role, status, pageNum, pageSize);
    try {
        PageHelper.startPage(pageNum, pageSize);
        List<User> users = userMapper.selectByRoleAndStatus(role, status);
        PageInfo<UserDTO> pageInfo = new PageInfo<>(convertToDTO(users));
        logger.info("分页查询成功，总记录数：{}", pageInfo.getTotal());
        return pageInfo;
    } catch (Exception e) {
        logger.error("分页查询失败：", e);
        throw new BusinessException("分页查询失败：" + e.getMessage(), e);
    }
}

INFO  UserServiceImpl - 开始分页查询，角色：admin, 状态：active, 当前页：1, 每页记录数：10
INFO  UserServiceImpl - 分页查询成功，总记录数：50

@GetMapping("/users")
public PageInfo<User> getUsers(@RequestParam int pageNum, @RequestParam int pageSize) {
    return userService.getUsersByPage(pageNum, pageSize);
}

@RestController
@RequestMapping("/v1/users")
public class UserController {
    @Autowired
    private UserService userService;
    @GetMapping
    public ResponseEntity<PageInfo<User>> getUsers(
            @RequestParam @Min(1) int pageNum,
            @RequestParam @Min(1) @Max(100) int pageSize) {
        PageInfo<User> pageInfo = userService.getUsersByPage(pageNum, pageSize);
        return ResponseEntity.ok(pageInfo);
    }
}

public class ResponseResult<T> {
    private int code;
    private String message;
    private T data;

    // 构造方法、getters、setters
}

@GetMapping
public ResponseResult<PageInfo<User>> getUsers(
        @RequestParam @Min(1) int pageNum,
        @RequestParam @Min(1) @Max(100) int pageSize) {
    PageInfo<User> pageInfo = userService.getUsersByPage(pageNum, pageSize);
    return ResponseResult.success(pageInfo);
}

{
  "code": 200,
  "message": "操作成功",
  "data": {
    "pageNum": 1,
    "pageSize": 10,
    "total": 150,
    "pages": 15,
    "list": [
      {"id": 1, "name": "张三", "email": "zhangsan@example.com"},
      ...
    ]
  }
}

graph TD
    A[前端请求] --> B[Controller接收参数]
    B --> C{参数校验是否通过?}
    C -->|是| D[调用Service获取PageInfo]
    D --> E[封装ResponseResult]
    E --> F[返回JSON格式数据]
    C -->|否| G[返回错误信息]

# application.yml
logging:
  level:
    com.example.mapper: debug

DEBUG  c.e.m.UserMapper.getUsersByPage - ==>  Preparing: SELECT * FROM users LIMIT 0,10
DEBUG  c.e.m.UserMapper.getUsersByPage - ==> Parameters: 
DEBUG  c.e.m.UserMapper.getUsersByPage - <==      Total: 10

PageHelper.startPage(pageNum, pageSize);  // 设置分页参数
List<User> users = userMapper.selectAll(); // 执行查询
PageInfo<User> pageInfo = new PageInfo<>(users); // 封装成PageInfo

@GetMapping("/users")
public ResponseEntity<PageInfo<User>> getUsers(@RequestParam int pageNum, @RequestParam int pageSize) {
    PageInfo<User> pageInfo = userService.getUsers(pageNum, pageSize);
    return ResponseEntity.ok(pageInfo);
}

fetch(`/api/users?pageNum=1&pageSize=10`)
  .then(response => response.json())
  .then(data => {
    console.log('当前页码:', data.pageNum);
    console.log('总页数:', data.pages);
    console.log('用户列表:', data.list);
  });

<template>
  <div class="pagination">
    <button :disabled="!pageInfo.hasPreviousPage" @click="prevPage">上一页</button>
    <span>当前页：{{ pageInfo.pageNum }} / {{ pageInfo.pages }}</span>
    <button :disabled="!pageInfo.hasNextPage" @click="nextPage">下一页</button>
  </div>
</template>
<script>
export default {
  props: ['pageInfo'],
  methods: {
    prevPage() {
      this.$emit('change-page', this.pageInfo.pageNum - 1);
    },
    nextPage() {
      this.$emit('change-page', this.pageInfo.pageNum + 1);
    }
  }
}
</script>

public class CustomPageResponse<T> {
    private int currentPage;
    private int pageSize;
    private long totalElements;
    private int totalPages;
    private List<T> content;
    private boolean hasNext;
    private boolean hasPrevious;
    public static <T> CustomPageResponse<T> fromPageInfo(PageInfo<T> pageInfo) {
        CustomPageResponse<T> response = new CustomPageResponse<>();
        response.setCurrentPage(pageInfo.getPageNum());
        response.setPageSize(pageInfo.getPageSize());
        response.setTotalElements(pageInfo.getTotal());
        response.setTotalPages(pageInfo.getPages());
        response.setContent(pageInfo.getList());
        response.setHasNext(pageInfo.isHasNextPage());
        response.setHasPrevious(pageInfo.isHasPreviousPage());
        return response;
    }
    // Getters and Setters
}

@GetMapping("/users")
public ResponseEntity<CustomPageResponse<User>> getUsers(@RequestParam int pageNum, @RequestParam int pageSize) {
    PageInfo<User> pageInfo = userService.getUsers(pageNum, pageSize);
    CustomPageResponse<User> response = CustomPageResponse.fromPageInfo(pageInfo);
    return ResponseEntity.ok(response);
}

public class UserPageResponse {
    private PageInfo<User> pageInfo;
    private int activeUserCount;
    private int totalUserCount;

    // 构造方法、Getters、Setters
}

@GetMapping("/users")
public ResponseEntity<UserPageResponse> getUsers(@RequestParam int pageNum, @RequestParam int pageSize) {
    PageInfo<User> pageInfo = userService.getUsers(pageNum, pageSize);
    int activeCount = userService.getActiveUserCount();
    int totalCount = pageInfo.getTotal();

    UserPageResponse response = new UserPageResponse();
    response.setPageInfo(pageInfo);
    response.setActiveUserCount(activeCount);
    response.setTotalUserCount(totalCount);

    return ResponseEntity.ok(response);
}