Bootstrap

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");

or

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

in

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);

;