MybatisPlus快速学习

MybatisPlus

一、快速开始

①创建数据库和表

CREATE DATABASE `mybatis_plus` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
use `mybatis_plus`;
CREATE TABLE `user` (
`id` bigint(20) NOT NULL COMMENT '主键ID',
`name` varchar(30) DEFAULT NULL COMMENT '姓名',
`age` int(11) DEFAULT NULL COMMENT '年龄',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

②搭建springboot环境

③导入依赖

<dependency>
<groupId>com.baomidougroupId>
<artifactId>mybatis-plus-boot-starterartifactId>
<version>3.5.1version>
dependency>

<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<optional>trueoptional>
dependency>

<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<scope>runtimescope>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

④配置数据源

spring:
    # 配置数据源信息
    datasource:
      #配置数据源
      type: com.zaxxer.hikari.HikariDataSource
      #配置连接数据库的各个信息
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql//localhost:3306/mybatis_plus?characterEncoding=utf-8&userSSL=false
      username: root
      password: root
# 添加mybatisPlus日志
mybatis-plus:
   configuration:
     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl 
  #  设置Mybatis-plus的全局配置
   global-config:
     db-config:
      # 设置实体类读取表的前缀
       table-prefix: yhq_
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

二、基本CRUD

1.BaseMapper

Mybatis-plus中的基本CRUD在内置的BaseMapper中都已经实现，我们可以直接使用，接口如下：

/**
* 插入一条记录 
* @param entity 实体对象 
*/
int insert(T entity);
/**
* 根据 ID 删除 
* @param id 主键ID 
*/
int deleteById(Serializable id);
/**
* 根据实体(ID)删除 
* @param entity 实体对象 
* @since 3.4.4 
*/
int deleteById(T entity);

/**
* 根据columnMap条件删除记录
* @param columnMap 表字段 map 对象
*/
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
@Test 
public void testDeleteByMap(){ 
    //根据map集合中所设置的条件删除记录 
    //DELETE FROM user WHERE name = ? AND age = ? 
    Map<String, Object> map = new HashMap<>(); map.put("age", 23); 
    map.put("name", "张三"); 
    int result = userMapper.deleteByMap(map); 
    System.out.println("受影响行数："+result); }

/**
* 根据 entity 条件，删除记录 
* @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 删除（根据ID 批量删除） 
* @param idList 主键ID列表(不能为 null 以及 empty) 
*/
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
例子：
@Test 
public void testDeleteBatchIds(){ 
    //通过多个id批量删除 
    //DELETE FROM user WHERE id IN ( ? , ? , ? ) 
    List<Long> idList = Arrays.asList(1L, 2L, 3L); 
    int result = userMapper.deleteBatchIds(idList); 
    System.out.println("受影响行数："+result); 
}

/**
* 根据 ID 修改 该对象值
* @param entity 实体对象 
*/
int updateById(@Param(Constants.ENTITY) T entity);
@Test 
public void testUpdateById(){ 
    User user = new User(4L, "admin", 22, null); 
    //UPDATE user SET name=?, age=? WHERE id=? int result = userMapper.updateById(user); 
    System.out.println("受影响行数："+result); }

/**
* 根据 whereEntity 条件，更新记录 
* @param entity 实体对象 (set 条件值,可以为 null) 
* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句） 
*/
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
/**
* 根据 ID 查询 
* @param id 主键ID 
*/
T selectById(Serializable id);

/**
* 查询（根据ID 批量查询） 
* @param idList 主键ID列表(不能为 null 以及 empty) 
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
@Test 
public void testSelectBatchIds(){ 
    //根据多个id查询多个用户信息 
    //SELECT id,name,age,email FROM user WHERE id IN ( ? , ? ) 
    List<Long> idList = Arrays.asList(4L, 5L); 
    List<User> list = userMapper.selectBatchIds(idList); 				               list.forEach(System.out::println); }


/**
* 查询（根据 columnMap 条件） 
* @param columnMap 表字段 map 对象 
*/
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
@Test 
public void testSelectByMap(){ 
    //通过map条件查询用户信息 
    //SELECT id,name,age,email FROM user WHERE name = ? AND age = ? 
    Map<String, Object> map = new HashMap<>(); 
    map.put("age", 22); map.put("name", "admin"); 
    List<User> list = userMapper.selectByMap(map);                                     list.forEach(System.out::println); }

/**
* 根据 entity 条件，查询一条记录 
* 
查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常 
 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) { 
    List<T> ts = this.selectList(queryWrapper); 
    if (CollectionUtils.isNotEmpty(ts)) { 
        if (ts.size() != 1) { 
            throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records"); 
        }
        return ts.get(0); 
    }
    return null; 
}
/**
* 根据 Wrapper 条件，查询总记录数 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
Long selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 entity 条件，查询全部记录 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
@Test 
public void testSelectList(){ 
    //查询所有用户信息 
    //SELECT id,name,age,email FROM user 
    List<User> list = userMapper.selectList(null);                                     list.forEach(System.out::println); }

/**
* 根据 Wrapper 条件，查询全部记录 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录 
* 
注意： 只返回第一个字段的值
 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 entity 条件，查询全部记录（并翻页） 
* @param page 分页查询条件（可以为 RowBounds.DEFAULT） 
* @param queryWrapper 实体对象封装操作类（可以为 null） 
*/
<P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录（并翻页） 
* @param page 分页查询条件 * @param queryWrapper 实体对象封装操作类 
*/
<P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

三、常用注解

1、@TableName （表名和类名不一致）

​ Mybatis-Plus在确定操作的表时，由BaseMapper的泛型决定是哪一张数据表，即就是实体类型决定。且默认操作的表名和实体类型的类名一致。

①此注解用于解决实体类和数据库表名不一致时的问题，在实体类的类上使用@TableName(“数据库表名”)；

@TableName("yhq_user")
public class User {
    ...
}
1
2
3
4

②使用全局配置解决数据不一致的情况

mybatis-plus: 
  configuration: 
     # 配置MyBatis日志 
     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl 
  global-config: 
     db-config: 
       # 配置MyBatis-Plus操作表的默认前缀 
       table-prefix: t_
1
2
3
4
5
6
7
8

2、@Tableld (类中id不叫id)

​ MyBatis-Plus在实现CRUD时，会默认将id作为主键列，并在插入数据时，默认基于雪花算法的策略生成id。

a>问题：若实体类和表中表示主键的不是id，而是其他字段，例如uid，MyBatis-Plus会自动识别uid为主键列吗？

b>通过@TableId解决问题：在实体类中uid属性上通过@TableId将其标识为主键，即可成功执行SQL语句。

c>@TableId的value属性：若实体类中主键对应的属性为id，而表中表示主键的字段为uid，此时若只在属性id上添加注解@TableId，则抛出异常Unknown column ‘id’ in ‘field list’，即MyBatis-Plus仍然会将id作为表的主键操作，而表中表示主键的是字段uid此时需要通过@TableId注解的value属性，指定表中的主键字段，@TableId(“uid”)或@TableId(value=“uid”)；

d>@TableId的type属性：type属性用来定义主键策略。

常用的主键策略：

配置全局主键策略：

mybatis-plus: 
  configuration: 
    # 配置MyBatis日志 
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl 
  global-config: 
    db-config: 
      # 配置MyBatis-Plus操作表的默认前缀 
      table-prefix: t_ 
      # 配置MyBatis-Plus的主键策略 
      id-type: auto
1
2
3
4
5
6
7
8
9
10

e>雪花算法：雪花算法是由Twitter公布的分布式主键生成算法，它能够保证不同表的主键的不重复性，以及相同表的主键的有序性。

**背景：**需要选择合适的方案去应对数据规模的增长，以应对逐渐增长的访问压力和数据量。数据库的扩展方式主要包括：业务分库、主从复制，数据库分表。

**数据库分表：**将不同业务数据分散存储到不同的数据库服务器，能够支撑百万甚至千万用户规模的业务，但如果业务继续发展，同一业务的单表数据也会达到单台数据库服务器的处理瓶颈。例如，淘宝的几亿用户数据，如果全部存放在一台数据库服务器的一张表中，肯定是无法满足性能要求的，此时就需要对单表数据进行拆分。

**垂直分表：**假设我们是一个婚恋网站，用户在筛选其他用户的时候，主要是用 age 和 sex 两个字段进行查询，而 nickname 和 description 两个字段主要用于展示，一般不会在业务查询中用到。description 本身又比较长，因此我们可以将这两个字段独立到另外一张表中，这样在查询 age 和 sex 时，就能带来一定的性能提升。

**水平分表：**水平分表适合表行数特别大的表，有的公司要求单表行数超过 5000 万就必须进行分表，这个数字可以作为参考，但并不是绝对标准，关键还是要看表的访问性能。对于一些比较复杂的表，可能超过 1000万就要分表了；而对于一些简单的表，即使存储数据超过 1 亿行，也可以不分表。但不管怎样，当看到表的数据量达到千万级别时，作为架构师就要警觉起来，因为这很可能是架构的性能瓶颈或者隐患。

水平分表相比垂直分表，会引入更多的复杂性，例如要求全局唯一的数据id该如何处理？

主键自增：

①以最常见的用户 ID 为例，可以按照 1000000 的范围大小进行分段，1 ~ 999999 放到表 1中，

1000000 ~ 1999999 放到表2中，以此类推。

②复杂点：分段大小的选取。分段太小会导致切分后子表数量过多，增加维护复杂度；分段太大可能会

导致单表依然存在性能问题，一般建议分段大小在 100 万至 2000 万之间，具体需要根据业务选取合适

的分段大小。

③优点：可以随着数据的增加平滑地扩充新的表。例如，现在的用户是 100 万，如果增加到 1000 万，

只需要增加新的表就可以了，原有的数据不需要动。

④缺点：分布不均匀。假如按照 1000 万来进行分表，有可能某个分段实际存储的数据量只有 1 条，而

另外一个分段实际存储的数据量有 1000 万条。

3、@TableField(名不同时，属性指定对应的字段)

如果实体类中的属性名和字段名不一致的情况，会出现什么问题呢？

**a>情况1：**若实体类中的属性使用的是驼峰命名风格，而表中的字段使用的是下划线命名风格

• 例如实体类属性userName，表中字段user_name

• 此时MyBatis-Plus会自动将下划线命名风格转化为驼峰命名风格

• 相当于在MyBatis中配置

b>情况2：

• 若实体类中的属性和表中的字段不满足情况1
• 例如实体类属性name，表中字段username
• 此时需要在实体类属性上使用@TableField(“username”)设置属性所对应的字段名

4、TableLogic（逻辑删除）

• 物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据

• 逻辑删除：假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录

• 使用场景：可以进行数据恢复

四、条件构造器和常用接口

1、wapper介绍

• Wrapper ： 条件构造抽象类，最顶端父类

  • AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件

    • QueryWrapper ： 查询条件封装

    • UpdateWrapper ： Update 条件封装

    • AbstractLambdaWrapper ： 使用Lambda 语法

      • LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper

      • LambdaUpdateWrapper ： Lambda 更新封装Wrapper

2、QueryWrapper

a>列1：组装查询条件

@Test 
public void test01(){ 
    //查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息 
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (username LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL) 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    queryWrapper.like("username", "a") .between("age", 20, 30) 
                .isNotNull("email"); 
    List<User> list = userMapper.selectList(queryWrapper); 
    list.forEach(System.out::println); }
1
2
3
4
5
6
7
8
9

b>例2：组装排序条件

@Test 
public void test02(){ 
    //按年龄降序查询用户，如果年龄相同则按id升序排列 
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 ORDER BY age DESC,id ASC 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    queryWrapper .orderByDesc("age") .orderByAsc("id"); 
    List<User> users = userMapper.selectList(queryWrapper); 
    users.forEach(System.out::println); }
1
2
3
4
5
6
7
8

c>例3：组装删除条件

@Test 
public void test03(){ 
    //删除email为空的用户 
    //DELETE FROM t_user WHERE (email IS NULL) 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    queryWrapper.isNull("email"); 
    //条件构造器也可以构建删除语句的条件 
    int result = userMapper.delete(queryWrapper); 
    System.out.println("受影响的行数：" + result); }
1
2
3
4
5
6
7
8
9

d>例4：条件的优先级

@Test 
public void test04() { 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    //将（年龄大于20并且用户名中包含有a）或邮箱为null的用户信息修改 
    //UPDATE t_user SET age=?, email=? WHERE (username LIKE ? AND age > ? OR email IS NULL) 
    queryWrapper .like("username", "a") .gt("age", 20) .or() .isNull("email"); 
    User user = new User(); 
    user.setAge(18); 
    user.setEmail("user@atguigu.com"); 
    int result = userMapper.update(user, queryWrapper); 
    System.out.println("受影响的行数：" + result); }

@Test 
public void test04() { 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    //将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改 
    //UPDATE t_user SET age=?, email=? WHERE (username LIKE ? AND (age > ? OR email IS NULL)) 
    //lambda表达式内的逻辑优先运算 
    queryWrapper.like("username", "a") .and(i -> i.gt("age", 20).or().isNull("email"));
    User user = new User(); 
    user.setAge(18); 
    user.setEmail("user@atguigu.com"); 
    int result = userMapper.update(user, queryWrapper); 
    System.out.println("受影响的行数：" + 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

e>例5：组装select子句

@Test 
public void test05() { 
    //查询用户信息的username和age字段 
    //SELECT username,age FROM t_user 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    queryWrapper.select("username", "age"); 
    //selectMaps()返回Map集合列表，通常配合select()使用，避免User对象中没有被查询到的列值 为null
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper); 
    maps.forEach(System.out::println); }
1
2
3
4
5
6
7
8
9

f>例6：实现子查询

@Test 
public void test06() { 
    //查询id小于等于3的用户信息 
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (id IN (select id from t_user where id <= 3)) 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    queryWrapper.inSql("id", "select id from t_user where id <= 3"); 
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println); }
1
2
3
4
5
6
7
8

3、UpdateWrapper

@Test 
public void test07() { 
    //将（年龄大于20或邮箱为null）并且用户名中包含有a的用户信息修改 
    //组装set子句以及修改条件 UpdateWrapper updateWrapper = new UpdateWrapper<>(); 
    //lambda表达式内的逻辑优先运算 
    updateWrapper .set("age", 18) .set("email", "user@atguigu.com") .like("username", "a") .and(i -> i.gt("age", 20).or().isNull("email")); 
    //这里必须要创建User对象，否则无法应用自动填充。如果没有自动填充，可以设置为null 
    //UPDATE t_user SET username=?, age=?,email=? WHERE (username LIKE ? AND (age > ? OR email IS NULL))
    //User user = new User(); 
    //user.setName("张三");
    //int result = userMapper.update(user, updateWrapper); 
    //UPDATE t_user SET age=?,email=? WHERE (username LIKE ? AND (age > ? OR email IS NULL)) 
    int result = userMapper.update(null, updateWrapper); System.out.println(result); }
1
2
3
4
5
6
7
8
9
10
11
12
13

4、condition

//方式一
@Test 
public void test08() { 
    //定义查询条件，有可能为null（用户未输入或未选择） 
    String username = null; 
    Integer ageBegin = 10; 
    Integer ageEnd = 24; 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace) 构成 
    if(StringUtils.isNotBlank(username)){ 
        queryWrapper.like("username","a"); 
    }if(ageBegin != null){ 
        queryWrapper.ge("age", ageBegin); 
    }if(ageEnd != null){ 
        queryWrapper.le("age", ageEnd); }
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (age >= ? AND age <= ?) 
    List<User> users = userMapper.selectList(queryWrapper); 
    users.forEach(System.out::println); } 

//方式二
@Test 
public void test08UseCondition() { 
    //定义查询条件，有可能为null（用户未输入或未选择） 
    String username = null; 
    Integer ageBegin = 10; 
    Integer ageEnd = 24; 
    QueryWrapper<User> queryWrapper = new QueryWrapper<>(); 
    //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace) 构成 
    queryWrapper .like(StringUtils.isNotBlank(username), "username", "a")
        		.ge(ageBegin != null, "age", ageBegin) .le(ageEnd != null, "age", ageEnd); 
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (age >= ? AND age <= ?) 
    List<User> users = userMapper.selectList(queryWrapper); 
    users.forEach(System.out::println); }
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

5、LambdaQueryWrapper

@Test 
public void test09() { 
    //定义查询条件，有可能为null（用户未输入） 
    String username = "a"; 
    Integer ageBegin = 10; 
    Integer ageEnd = 24; 
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>(); 
    //避免使用字符串表示字段，防止运行时错误 
    queryWrapper .like(StringUtils.isNotBlank(username), User::getName, username) .ge(ageBegin != null, User::getAge, ageBegin) .le(ageEnd != null, User::getAge, ageEnd); 
    List<User> users = userMapper.selectList(queryWrapper); 
    users.forEach(System.out::println); }
1
2
3
4
5
6
7
8
9
10
11

6、LambdaUpdateWrapper

@Test 
public void test10() { 
    //组装set子句 
    LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>(); 
    updateWrapper .set(User::getAge, 18) .set(User::getEmail, "user@atguigu.com") .like(User::getName, "a") .and(i -> i.lt(User::getAge, 24).or().isNull(User::getEmail));
    //lambda 表达式内的逻辑优先运算 
    User user = new User(); int result = userMapper.update(user, updateWrapper); 
    System.out.println("受影响的行数：" + result); }
1
2
3
4
5
6
7
8

六、插件

1、分页插件 MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能

a>添加配置类

@Configuration 
@MapperScan("com.atguigu.mybatisplus.mapper") 
//可以将主类中的注解移到此处 
public class MybatisPlusConfig { 
    @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { 
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); 
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor; } 
}
1
2
3
4
5
6
7
8
9

b>测试

@Test 
public void testPage(){ 
    //设置分页参数 
    Page<User> page = new Page<>(1, 5); 
    userMapper.selectPage(page, null); 
    //获取分页数据 
    List<User> list = page.getRecords(); 
    list.forEach(System.out::println); 
    System.out.println("当前页："+page.getCurrent()); 
    System.out.println("每页显示的条数："+page.getSize());
    System.out.println("总记录数："+page.getTotal()); 
    System.out.println("总页数："+page.getPages()); 
    System.out.println("是否有上一页："+page.hasPrevious()); 
    System.out.println("是否有下一页："+page.hasNext()); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、xml自定义分页

a>UserMapper中定义接口方法

/**
* 根据年龄查询用户列表，分页显示 
* @param page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位 
* @param age 年龄 
* @return */ 
I Page<User> selectPageVo(@Param("page") Page<User> page, @Param("age") Integer age);
1
2
3
4
5
6

b>UserMapper.xml中编写SQL

 
    <sql id="BaseColumns">id,username,age,emailsql> 
     
    <select id="selectPageVo" resultType="User"> 
        SELECT <include refid="BaseColumns">include> 
        FROM t_user WHERE age > # {age} 
	select>
1
2
3
4
5
6
7