MyBatis Plus基础教程大全

id主键, mp默认对应的是雪花数字的字符串类型

mp字段默认的是驼峰

@TableName

指定表名和实体类名的关系(当表名为 xxx_user, 实体类的名为 user)，这时在实体类上使用注解@TableName(“xxx_user”) 指定表和实体类的对应关系

@TableId

指定主键与id的映射：当插入数据库时，mp的默认主键名为id，如果想换个主键名例如叫user_id，这时在实体类中主键的属性上使用@TableId注解，指定id主键

@TableField

指定字段与属性的映射：数据库表中有字段名为name，实体类中对应的属性为username，这时在实体类中的属性上使用注解@TableField(“name”)，指定两者之间的映射关系

排除实体类中的临时字段

方式一：给属性加上 transient 关键字，表明此属性不参与对象序列化。示例：private transient String name;

方式二：给属性加上 static关键字，表明此属性是所属对象的唯一。示例：private static String name;

方式三（推荐）：在属性上使用注解@TableField(exist = false)，表明这个属性是额外扩展的

根据一个id查询一个对象

// sql为: where id = 123

Object obj = mapper.selectById(123);

根据多个id查询对象list

// sql为: where id in (idList)

List<Object> objList = mapper.selectBatchIds(idList);

根据条件查询一个对象

// sql为: where id = 123

QueryWrapper<Object> wrapper = new QueryWrapper<>();

wrapper.eq(“id”, 123);//字段的方式

wrapper.lambda().eq(Objecte.getId, 123);//lambda表达式的方式

Object obj = mapper.selectOne(wrapper);

根据条件查询对象list

// sql为: where name = ‘zs’

QueryWrapper<Object> wrapper = new QueryWrapper<>();

wrapper.eq(“name”, zs);//字段的方式

wrapper.lambda().eq(Objecte.getName, zs);//lambda表达式的方式

List<Object> objList = mapper.selectList(wrapper);

根据map查询对象list

// sql为: where name = ‘zs’ and sex = 1

Map<String, Object> map = new HashMap<>();

map.put(“name”, “zs”);// name为数据库表中的字段名, 不是实体类中的属性名

map.put(“sex”, 1);

List<Object> objList = mapper.selectByMap(map);

v 3.4.3 版本新增 ActiveRecord 模式，更加强大的 CRUD 操作

// 实体类，继承 Model

public class User extends Model<User> {

private Long id;

}

// 插入 // 更多crud请查看Model类中提供的方法

boolean b = new User().setId(1L).insert();

条件构造器

QueryWrapper

QueryWrapper的两种创建方式:

1: QueryWrapper<User> queryWrapper= new QueryWrapper<>();

2: QueryWrapper<User> queryWrapper= Wrappers.<User>query();

like

// sql为: where 字段 like ‘%值%’

queryWrapper.like(“字段”, 值); //lambda表达式的方式: queryWrapper.lambda().like(类名.get属性, 值)

// sql为: where 字段 like ‘值%’

queryWrapper.likeRight(“字段”, 值);

// sql为: where 字段 like ‘%值’

queryWrapper.likeLeft(“字段”, 值);

queryWrapper.eq(“字段”, 值);

queryWrapper.lt(“字段”, 值);

queryWrapper.gt(“字段”, 值);

between 20 and 30 // 小于等于并且大于等于

queryWrapper.between(“age”, 20, 30);

字段 is not null

queryWrapper.isNotNull(“name”);

and

queryWrapper.eq(“字段1”, 值1).eq(“字段2”, “值2”);

queryWrapper.eq(“字段1”, “值1”).or().eq(“字段2”, “值2”);

queryWrapper.in(“字段”, objList);

order by 字段 asc

queryWrapper.orderByAsc(“字段”);

order by 字段 desc

queryWrapper.orderByDesc(“字段”);

limit 1

queryWrapper.last(“limit 1”); // 查询集合中返回第一条, last在条件最后使用

date_format(time, ‘%Y-%m-d’)

// sql为: where date_format(create_time, ‘%Y-%m-%d’) = ‘2020-06-13’ // %Y-%m-%d %H:%M:%S

queryWrapper.apply(“date_format(create_time, ‘%Y-%m-%d’) = {0}”, “2020-06-13”);

where user_id in (子查询语句)

queryWrapper.inSql(“user_id”, “子查询语句”)

where name like ‘%zs%’ and ( age < 30 or phone is not null)

queryWrapper.like(“name”, “zs”).and(wq -> wq.lt(“age”, 30).or().isNotNull(“phone”));

where name like ‘%zs%’ or (age > 20 and age < 40 and phone is not null)

queryWrapper.like(“name”, “zs”).or(wq -> wq.lt(“age”, 40).gt(“age”, 20).isNotNull(“phone”));

where (age < 40 or phone is not null) and name like ‘%zs%’

queryWrapper.nested(wq -> wq.lt(“age”, 40).or().isNotNull(“phone”)).like(“name”, “zs”);

条件构造器

UpdateWrapper

// 创建条件构造器

UpdateWrapper<User> updateWrapper= new UpdateWrapper<>();

根据id更新

User user = new User();

user.setId(123); // where条件

user.setName(“张三”); // set

userMapper.updateById(user);

根据字段更新

方式一：

// where 条件

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();

updateWrapper.eq(“name”, “张三”);

// set

User user = new User();

user.setAge(18);

userMapper.update(user, updateWrapper);

方式二：

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();

updateWrapper.eq(“name”, “张三”).set(“age”, 18);

userMapper.update(null, updateWrapper);

// sql语句为：update user set age = 18 where name = ‘张三’

只查询指定字段、不查询指定字段

只查询指定字段

queryWrapper.select(“id”, “name”);

不查询指定字段

// 不查询 user表中的 password和phone字段

queryWrapper.select(User.class, info -> !info.getColumn().equals(“password”) && !info.getColumn().equals(“phone”));

condition

条件不为空时sql带上查询条件，条件为空时sql不带查询条件

queryWrapper.eq(StringUtils.isNotBlank(nickName), “nick_name”, nickName);

实体类做为条件构造器的查询条件

// sql为: where name = ‘zs’

User user = new User();

user.setName(“zs”);

QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);

// sql为: where name like ‘%zs%’

在实体对象的name属性上加上 @TableField(condition = SqlCondition.LIKE) 注解

使用函数（最大值、最小值、平均值等）

queryWrapper.select(“avg(字段) 别名”，”min(字段) 别名”， “max(字段) 别名”)；

只查询表中的首列，其他列舍弃

queryWrapper.select(“字段”);

List<Object> list = mapper.selectObjs(queryWrapper);

lambda

//查询

//创建lambda的三种方式

LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();

LambdaQueryWrapper<User> lambda = new LambdaQueryWrapper<>();

LambdaQueryWrapper<User> lambda = Wrappers.<User>lambdaQuery();

lambda.eq(User::getId, “123”);

// 更新

LambdaUpdateWrapper<User> updateWrapper = Wrappers.lambdaUpdate();

updateWrapper.eq(User::getId, 123).set(User::getAge, 18);

userMapper.update(null, updateWrapper);

链式调用lambda

List<User> list = new LambdaQueryChainWrapper<User>(userMapper).eq(User::getId, “123”).ge(User::getSex, 18).list();

IPage<User> list = new LambdaQueryChainWrapper<>(userMapper).eq(User::getId, “123”).ge(User::getAge, 18).page(page); // 分页

boolean res = new LambdaUpdateChainWrapper<User>(userMapper).eq(User::getId, 123).set(User::getAge, 18).update(); // 更新，返回是否更新成功

自定义sql语句（一般用于多表查询）

//在mapper接口类中定义接口方法(UserMapper.java)

List<User> selectAll(@Param(Constants.WRAPPER) Wrapper<User> wrapper);

//sql语句(UserMapper.xml)

<select id=”selectAll” resultType=”com.User”>

select * from user ${ew.customSqlSegment}

</select>

//使用

List<User> list = userMapper.selectAll(wrapper);

分页

// 使用mybatis plus需要先配置分页插件，配置如下：（物理分页）

@Configuration
public class MybatisPlusConfig {
   	@Bean
	public MybatisPlusInterceptor proMybatisPlusInterceptor() {
		MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();

        /*
		 * 分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
		 */
		interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));

		return interceptor;
	}
}

// 使用分页

Page<User> page = new Page<>(1, 10); // Page<User> page = new Page<>(1, 10, false); 不查询总记录数

Wrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.eq(“id”, “123”);

IPage<User> list= userMapper.selectPage(page, queryWrapper);

list.getPages(); //总页数

list.getTotal(); //总记录数

list.getRecords(); //数据

自定义分页sql语句 Join的方式（一般用于多表查询）

//在mapper接口类中定义接口方法(UserMapper.java)

IPage<User> selectUserPage(Page<User> page, @Param(Constants.WRAPPER) Wrapper<User> wrapper)

//sql语句(UserMapper.xml)

<select id=”selectUserPage” resultType=”com.User”>

select u.*, i.* from user u left join info i on u.id = i.u_id ${ew.customSqlSegment}

</select>

//使用

Page<User> page = new Page<>(1, 10);

Wrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.eq(“u.id”, “123”);

IPage<User> list = userMapper.selectUserPage(page, wrapper);

自定义分页sql语句，逗号的方式

//在mapper接口类中定义接口方法(UserMapper.java)

IPage<User> selectUserPage(Page<User> page, @Param(Constants.WRAPPER) Wrapper<User> wrapper)

//sql语句(UserMapper.xml)

<select id=”selectUserPage” resultType=”com.User”>

        select

                # 这里也可以使用

# ${ew.sqlSelect}

                u.*, i.*

        from

                user u,

                info i

        ${ew.customSqlSegment}

</select>

//使用

Page<User> page = new Page<>(1, 10);

Wrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper

// 使用 ${ew.sqlSelect}的方式

//.select(“u.*”, “i.*”)

        .apply(“u.id = i.u_id”)

.eq(“u.id”, “123”);

IPage<User> list = userMapper.selectUserPage(page, wrapper);