MyBatis-Plus入门_学习笔记

首页免费课 MyBatis-Plus入门笔记

MyBatis-Plus入门

                
                老猿
            JAVA开发工程师

                    查看讲师更多课程 
                    老猿讲师的其他课程
                
MyBatis-Plus + SpringBoot实现简单权限管理
中级·12302
免费课程
                                
MyBatis-Plus进阶
高级·23037
免费课程
                                
                难度高级
            
                时长 4小时 0分
            
                学习人数
            
综合评分9.57
                            101人评价
                        查看评价
                                9.7
                                内容实用
                            
                                9.4
                                简洁易懂
                            
                                9.6
                                逻辑清晰

最热最新

霜花似雪 11:50

主键策略
1、MP支持的主键策略介绍
默认主键策略是基于雪花算法的自增ID
2、局部主键策略实现，IdType.class
定义六种：AUTO NONE INPUT(2) ID_WORKER(3)-雪花算法 UUID(4) ID_WORKER_STR(5)
@TableId(type=IdType.AUTO).......数据库主键改成自增/或者非自增

@TableId(type=IdType.UUID)
private String id;
数据库对应改成varchar类型32

注意：主键类型和主键策略类型要一致，如果设定了主键，那么不会自动填充主键策略
3、全局主键策略实现全局策略配置，全局用UUID ，局部策略优先于全局策略
属性文件配置：mybatis-plus.global-config.db-config.id-type:uuid

public class MybatisplusInsertTest{

@Autowired
private UserMapper userMapper;

@Test
public void insert(){
//这里的id是自增的
//@TableId(type=IdType.AUTO)
User user = new User();
user.setName("长江水");
user.setAge(28);
user.setEmail("9834273096@qq.com");
user.setManagerId(1000002);

int insert = userMapper.insert(user);
System.out.println("insert = " + insert);
System.out.println("主键：" + user.getId());
}

@Test
public void insert1(){
//这里的id是UUID
// @TableId(type=IdType.UUID)
User user = new User();
user.setName("大浪淘金");
user.setAge(28);
user.setEmail("9834273096@qq.com");
user.setManagerId(1000002);

int insert = userMapper.insert(user);
System.out.println("insert = " + insert);
System.out.println("主键：" + user.getId());
}

@Test
public void insert2(){
//这里的id是基于雪花算法生成
// @TableId(type=IdType.ID_WORKER_STR)
User user = new User();
user.setName("滔滔江水");
user.setAge(25);
user.setEmail("9234273096@qq.com");
user.setManagerId(1000002);

int insert = userMapper.insert(user);
System.out.println("insert = " + insert);
System.out.println("主键：" + user.getId());
}

}

查看全部

0 采集收起来源：主键策略
2022-09-04
霜花似雪 12:10

public class MybatisplusARTest{

@Test
public void insert(){
User user = new User();
user.setName("一点红");
user.setAge(27);
user.setEmail("877673096@qq.com");
user.setManagerId(1000001);

boolean insert = user.insert(user);
System.out.println("insert = " + insert);
}

@Test
public void selectById(){
User user = new User();
User userSelect = user.selectById(10005);
System.out.println(userSelect);
}

@Test
public void selectById2(){
User user = new User();
user.setId(10005);

User userSelect = user.selectById();
System.out.println(userSelect);
}

@Test
public void updateById(){
User user = new User();
user.setId(10005);
user.setName("雪花飘");

boolean userUpdate = user.updateById();
System.out.println(userUpdate);
}

@Test
public void deleteById(){
User user = new User();
user.setId(10005);

boolean userDelete = user.deleteById();
System.out.println(userDelete);
}

@Test
public void insertOrUpdate(){
User user = new User();
user.setName("花儿红");
user.setAge(27);
user.setEmail("877673096@qq.com");
user.setManagerId(1000001);

//如果不设置Id，就是insert，如果设置了Id，就会先查询，存在就update，不存在就insert
boolean insertOrUpdate = user.insertOrUpdate();
System.out.println(insertOrUpdate);
}

}

查看全部

0 采集收起来源：AR模式
2022-09-04
霜花似雪 09:56

删除操作
public class MyBatisPlusDeleteTest{

@Autowired
private UserMapper userMapper;

@Test
public void deleteById(){
Integer rows = userMapper.deleteById(10001);
System.out.println("删除条数：" + rows);
}

@Test
public void deleteByMap(){
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("name", "张无忌");
columnMap.put("age", 31);

//DELETE FROM user WHERE name = '张无忌' AND age = 31
Integer rows = userMapper.deleteByMap(columnMap);
System.out.println("删除条数：" + rows);
}

//带条件构造器的删除方法
@Test
public void deleteByWrapper(){
LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();
wrapper.eq(User::getAge, 27).or().gt(User::getAge, 41);

//删除多条
//DELETE FROM user WHERE age = 27 or age > 41
Integer rows = userMapper.delete(deleteByWrapper);
System.out.println("删除条数：" + rows);
}

}

查看全部

0 采集收起来源：删除方法
2022-09-04
霜花似雪 15:10

MyBatisPlus 的更新方法

public class MyBatisPlusUpdateTest{

@Autowired
private UserMapper userMapper;

//根据updateById方法进行更新
@Test
public void updateByIds(){
User user = new User();
user.setId(10001);
user.setAge(23);
user.setName("龙在天涯");
user.setEmail("37635636756@163.com");

Integer rows = userMapper.updateById(user);
System.out.println("影响记录数：" + rows);
}

@Test
public void updateByWrapper(){
UpdateWrapper<User> updateWrapper = new UpdateWrapper<User>();
updateWrapper.eq("name", "张无忌").eq("age", 28); //where 表达式

// UPDATE user SET age = 25 , email = 'uyddhjdhgg@163.com' WHERE name = '张无忌' and age = 28
User user = new User();
user.setEmail("uyddhjdhgg@163.com");
user.setAge(25);

Integer rows = userMapper.update(user, updateWrapper);

System.out.println("影响记录数：" + rows);
}

@Test
public void updateByWrapper1(){
User whereUser = new User();
whereUser.setId(10002);

UpdateWrapper<User> updateWrapper = new UpdateWrapper<User>(whereUser); //将实体传递给条件构造器
updateWrapper.eq("name", "张无忌").eq("age", 28); //where 表达式

// UPDATE user SET age = 25 , email = 'uyddhjdhgg@163.com' WHERE name = '张无忌' and age = 28
User user = new User();
user.setEmail("uyddhjdhgg@163.com");
user.setAge(25);

Integer rows = userMapper.update(user, updateWrapper);

System.out.println("影响记录数：" + rows);
}

@Test
public void updateByWrapper2(){
UpdateWrapper<User> updateWrapper = new UpdateWrapper<User>();
updateWrapper.eq("name", "张无忌").eq("age", 28).set("age", 30); //UPDATE user SET age = 30 WHERE name = '张无忌' and age 28

Integer rows = userMapper.update(null, updateWrapper); //省略实体，设置为null

System.out.println("影响记录数：" + rows);
}

@Test
public void updateByWrapperLambda(){
LambdaUpdateWrapper<User> lambdaUpdate = Wrappers.<User>lambdaUpdate();
//UPDATE user SET age = 31 , email = 'uywyeiu@126.com' WHERE name = '张无忌' and age = 30
lambdaUpdate.eq(User::getName, "张无忌").eq(User::getAge, 30)
.set(User::getAge, 31).set(User::getEmail, "uywyeiu@126.com");

Integer rows = userMapper.update(null, lambdaUpdate);

System.out.println("影响记录数：" + rows);
}

@Test
public void updateByWrapperLambdaChain(){
boolean updateBool = new LambdaUpdateChainWrapper<User>(userMapper)
.eq(User::getName, "张无忌").eq(User::getAge, 31)
.set(User::getAge, 34).set(User::getEmail, "434444322@qq.com")
.update();

System.out.println(updateBool); //成功：true 失败：false

}
}

查看全部

0 采集收起来源：更新方法
2022-09-04
霜花似雪 02:32

分页的方法

查看全部

0 采集收起来源：分页查询
2022-09-04
霜花似雪 07:07

public interface UserMapper extends BaseMapper<User> {

//注解的方式实现自定义SQL
@Select("select * from user ${ew.customeSqlSegment}")
List<User> selectAll(@Param(Constants.WRAPPER) Wrapper<User> wrapper);

/**
//对应的XML写法
<select id="selectAll" resultType="com.entity.User">
select * from user ${ew.customeSqlSegment}
</select>

*/

}

查看全部

0 采集收起来源：自定义sql
2022-09-04
霜花似雪 07:32

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
* @Description
* @auther mohuani
* @create 2019-12-25 11:37
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class RetrieveTest {

@Autowired
private UserMapper userMapper;

@Test
public void selectById() {
User user = userMapper.selectById(1088250446457389058L);
System.out.println(user);
}

@Test
public void selectBatchIds() {
List<Long> list = Arrays.asList(1088248166370832385L, 1094590409767661570L, 1209509417456001025L);
List<User> userList = userMapper.selectBatchIds(list);
userList.forEach(System.out::println);
}

@Test
public void selectByMap() {
//where name='李艺伟' and age = 28
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("name", "李艺伟");
columnMap.put("age", 28);
List<User> userList = userMapper.selectByMap(columnMap);
userList.forEach(System.out::println);
}

/**
* 1、名字中包含雨并且年龄小于40
* name like '%雨%' and age<40
*/
@Test
public void selectByWrapper() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//QueryWrapper<User> queryWrapper = Wrappers.<User>query();
queryWrapper.like("name", "雨").lt("age", 40);

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/**
* 2、名字中包含雨年并且龄大于等于20且小于等于40并且email不为空
* name like '%雨%' and age between 20 and 40 and email is not null
*/
@Test
public void selectByWrapper2() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "雨").between("age" ,20 ,40).isNotNull("email");

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/**
* 3、名字为王姓或者年龄大于等于25，按照年龄降序排列，年龄相同按照id升序排列
* name like '王%' or age>=25 order by age desc,id asc
*/
@Test
public void selectByWrapper3() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.likeRight("name", "王").or().gt("age", 25).orderByDesc("age").orderByAsc("id");

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/**
*
* 创建时间为2019年2月14日并且直属上级为名字为王姓:
* date_format(create_time,'%Y-%m-%d') and manager_id in (select id from user where name like '王%')
*
*/
@Test
public void selectByWrapper4(){
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

//动态条件构造器：apply。范围条件构造器：insql。
//注意：如果{0}替换为实际值，可能会造成sql注入。
queryWrapper.apply("date_format(create_time,'%Y-%m-%d') = {0}","2019-02-14").inSql("manager_id","select id from user where name like '王%' ");
//queryWrapper.apply("date_format(create_time,'%Y-%m-%d') = '2019-02-14'").inSql("manager_id","select id from user where name like '王%' "); //此种写法存在SQL注入的风险

List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);
}

/**
* 5.名字为王姓并且（年龄小于40或邮箱不为空）
* name like '王%' and (age < 40 or email is not null)
*
*/
@Test
public void selectByWrapper5(){
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.likeRight("name","王").and(wq->wq.lt("age", 40).or().isNotNull("email"));

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/**
* 6. 名字为王姓或者(年龄小于40并且年龄大于20并且邮箱不为空)
* name like '王%' or (age < 40 and ang > 20 and email is not null)
*
*/
@Test
public void selectByWrapper6(){
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.likeRight("name", "王").or(wq -> wq.lt("age", 40).gt("age", 20).isNotNull("email"));

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}



/**
* 7. (年龄小于40或邮箱不为空)并且名字为王姓
* (age < 40 or email is not null) and name like '王%'
*
*/
@Test
public void selectByWrapper7(){
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.nested(wq -> wq.lt("age", 40).or().isNotNull("email")).likeRight("name", "王");

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/**
* 8. 年龄为30,31,34,35
* age in (30,31,34,35)
*
*/
@Test
public void selectByWrapper8(){
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.in("age". Arrays.asList(30,31,34,35));

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/**
* 9. 值返回满足条件的其中一条语句即可
* limit 1
*
*/
@Test
public void selectByWrapper9(){
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
//last函数无视优化规则直接拼接到sql的最后，只能调用一次，调用多次以最后一次为准，有sql注入风险
queryWrapper.in("age". Arrays.asList(30,31,34,35)).last("limit 1");

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/**
* select中字段不全部出现的查询
* 10. 名字中包含雨且年龄小于40
* （1）select id,name from user where name like '%雨%' and age < 40
* （2）select id,name,age, email from user where name like '%雨%' and age < 40
*/
@Test
public void selectByWrapper10(){
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
//在select函数中指定需要查询的字段
//select id,name from user where name like '%雨%' and age < 40
//queryWrapper.select("id", "name").like("name", "雨")lt("age", 40);

//在select函数中排除不需要的字段
//select id,name,age, email from user where name like '%雨%' and age < 40
queryWrapper.like("name", "雨")lt("age", 40).select(User.class, info -> !info.getColumn().equals("create_time") && !info.getColumn().equals("manager_id"));

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/**
* 实体对象作为条件构造器方法的参数
*/
@Test
public void selectByWrapperEntity(){
User user = new User();
user.setName("李艺伟");
user.setAge(28)

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

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/*
* condition 条件判断，当条件为true则查询条件加入where
* 作用：该条件是否加入最后生成的sql中。
* 使用方法：如果为true就加入，如果false就不加入。
* 使用场景：类似于动态的sql拼接。
*/
@Test
public void testCondition(){
String name = "王";
String email = "";
condition(name, email);
}

private void condition(String name, String email){
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
//第一种写法
/*if(StringUtils.isNotEmpty(name)){
queryWrapper.like("name", name);
}
if(StringUtils.isNotEmpty(email)){
queryWrapper.like("email", email);
}*/

//第二种写法
queryWrapper.like(StringUtils.isNotEmpty(name), "name", name)
.like(StringUtils.isNotEmpty(email), "email", email);

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/**
* allEq函数用法
*/
@Test
public void selectByWrapperAllEq(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("name", "李艺伟");
columnMap.put("age", 28);

//columnMap.put("age", null);
//queryWrapper.allEq(columnMap, false); //忽略一个值

//queryWrapper.allEq(columnMap);

queryWrapper.allEq((k,v) -> !k.equals("name"), columnMap); //不等于name值的就加入条件

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}


/**
* selectMaps()用法
* selectMap：List集合的泛型不再是实体，而是map集合。其中key表示字段名，value表示字段值。
*
* 使用场景1：当实体类属性非常多时，不易查看。如果返回的是一个实体类，那么即使我们设定了返回字段，那么它的值为null，但是属性仍然存在。如果返回的是Map类型，当指定了返回字段时，那么没返回的就不会存在。

* 使用场景2：当返回的不是一条一条记录时，也就是返回的字段不在实体类属性中，比如一些统计，像平均值，最大值，最小值这样的。
*/
@Test
public void selectByWrapperMaps(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
//queryWrapper.like("name","雨").lt("age", 40);
queryWrapper.select("id", "name").like("name", "雨").lt("age", 40);

List<Map<String, Object>> userList = userMapper.selectMaps(queryWrapper);
userList.forEach(System.out::println);
}

/**
selectMaps用于返回自定义字段和查询特定字段时避免其他字段为null

selectObjs用于返回结果的第一个字段

selectCount不能带select，因为它查询的时记录数量，对应于sql中的count(1)

selectOne用于输出一条结果，如果多与一条报错
*/

/**
按照直属上级分组，查询每组的平均年龄，最大年龄，最小年龄并且只取年龄总和小于500的组

select avg(age) AS avg_age, min(age) AS min_age,max(age) AS max_age
from user group by manager_id
having sum(age) < 500
*/
@Test
public void selectByWrapperMaps2(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.select("avg(age) avg_age", "min(age) min_age", "max(age) max_age")
.groupBy("manager_id").having("sum(age) < {0}", 500);

List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}

/**
selectObject：List集合的泛型不再是实体，而是Object，只返回第一个字段的值。其他的会被舍弃。
使用场景：只返回一列时可以使用它。
*/
@Test
public void selectByWrapperObjs(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.select("id", "name").like("name", "雨").lt("age", 40);

List<Object> userList = userMapper.selectObjs(queryWrapper);
userList.forEach(System.out::println);
}

/**
selectCount：查询符合条件的总记录数的。
注意：使用它时，就不能指定返回的列了，因为它会在后面拼接COUNT(1)。
*/
@Test
public void selectByWrapperCount(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.like("name", "雨").lt("age", 40);

Integer count = userMapper.selectCount(queryWrapper);
System.out.println("总记录数 = " + count);
}



/**
selectOne：查询符合条件的数据，只会返回一条数据。
注意：查询的结果必须是一条或者查不到（多于1条就会报错）。
*/
@Test
public void selectByWrapperOne(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.like("name", "雨").lt("age", 40);

User user = userMapper.selectOne(queryWrapper);

System.out.println(user);

}

/**
lambda条件构造器
lambda条件构造器的创建有3种方式

1、通过查询构造器QueryWrapper创建

2、通过new直接创建lambda条件构造器

3、通过构造器工具类Wrappers创建（此时需要泛型）
*/
@Test
public void selectLambda(){
//方式1
//LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();
//方式二
//LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();
//方式三
LambdaQueryWrapper<User> lambdaQuery = Wrappers.<User>lambdaQuery();
//where name like '%雨%' and age < 40
lambdaQuery.like(User::getName, "雨").lt(User::getAge, 40);

List<User> userList = userMapper.selectList(lambdaQuery);
userList.forEach(System.out::println);

}


/**
* 5.名字为王姓并且（年龄小于40或邮箱不为空）
* name like '王%' and (age < 40 or email is not null)
*/
@Test
public void selectLambda2(){
//方式1
//LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();
//方式二
//LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();
//方式三
LambdaQueryWrapper<User> lambdaQuery = Wrappers.<User>lambdaQuery();
//where name like '%雨%' and age < 40
lambdaQuery.likeRight(User::getName, "王").and(lqw -> lqw.lt(User::getAge, 40)
.or().isNotNull(User::getEmail));

List<User> userList = userMapper.selectList(lambdaQuery);
userList.forEach(System.out::println);

}

@Test
public void selectLambda3(){
//新版本
List<User> userList = new LambdaQueryChainWrapper<User>(userMapper).like(User::getName, "雨")
.ge(User::getAge, 20).list();

userList.forEach(System.out::println);

}

}

查看全部

0 采集收起来源：lambda条件构造器
2022-09-03
霜花似雪 08:48

lambda条件构造器

查看全部

0 采集收起来源：lambda条件构造器
2022-08-29
霜花似雪 05:58

通用Mapper
Map<String,Object> params = new HashMap<String,Object>();
params.put("name","王天风")；
params.put("age",null);
queryWrapper.allEq((k,v)->!k.equals("name"),params);
List<User> userList = userMapper.selectList(queryWrapper);

查看全部

0 采集收起来源：AllEq用法
2022-08-28
霜花似雪 05:59

这样查询条件即为传入实体中的属性值。
若查询条件需要模糊查询，可在实体字段上加注解：@TableFiled(condition=SqlCondition.LIKE) 表示该字段使用模糊查询

若查询条件要求不等值，可在实体字段上加注解：例如在age上加注解@TableFiled(condition="%s<#{%s}"),表示age<#{age}

查看全部

0 采集收起来源：实体作为条件构造器构造方法的参数
2022-08-28
霜花似雪 00:09

通用Mapper

查看全部

0 采集收起来源：select不列出全部字段
2022-08-28

霜花似雪 08:28

代码

package com.mp;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
 * @Description
 * @auther mohuani
 * @create 2019-12-25 11:37
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class RetrieveTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void selectById() {
        User user = userMapper.selectById(1088250446457389058L);
        System.out.println(user);
    }

    @Test
    public void selectBatchIds() {
        List<Long> list = Arrays.asList(1088248166370832385L, 1094590409767661570L, 1209509417456001025L);
        List<User> userList = userMapper.selectBatchIds(list);
        userList.forEach(System.out::println);
    }

    @Test
    public void selectByMap() {
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("name", "李艺伟");
        columnMap.put("age", 28);
        List<User> userList = userMapper.selectByMap(columnMap);
        userList.forEach(System.out::println);
    }

    /**
     * 1、名字中包含雨并且年龄小于40
     *     name like '%雨%' and age<40
     */
    @Test
    public void selectByWrapper() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name", "雨").lt("age", 40);

        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

    /**
     * 2、名字中包含雨年并且龄大于等于20且小于等于40并且email不为空
     *    name like '%雨%' and age between 20 and 40 and email is not null
     */
    @Test
    public void selectByWrapper2() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name", "雨").between("age" ,20 ,40).isNotNull("email");

        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

    /**
     * 3、名字为王姓或者年龄大于等于25，按照年龄降序排列，年龄相同按照id升序排列
     *    name like '王%' or age>=25 order by age desc,id asc
     */
    @Test
    public void selectByWrapper3() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.likeRight("name", "王").or().gt("age", 25).orderByDesc("age").orderByAsc("id");

        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }
}

查看全部

0 采集收起来源：条件构造器查询（1）

2022-08-27

霜花似雪 05:41

QueryWrapper<User> queryWrapper=new QueryWrapper<User>();
//QueryWrapper<User> query=Wrappers<User>query();
queryWrapper.like("name","雨").lt("age",40);

查看全部

0 采集收起来源：条件构造器查询（1）
2022-08-27
霜花似雪 07:27

mapper查询用法

查看全部

0 采集收起来源：普通查询
2022-08-27
霜花似雪 04:05
普通查询：使用方式为实现BaseMapper<T>接口对象调用该方法。
1. T selectById(Serializable id)：使用场景为通过主键查询，只要该主键类型实现了Serialzable接口即可。
2. List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList)：使用场景为通过主键的集合去批量查询，前提主键的类型实现了Serializable接口。传入array
3. List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String,Object> columnMap)：使用场景为传入一个Map集合，key为表字段，value为表字段值。注意：Map的key为数据表的字段名，不是实体类属性名。
查看全部

0 采集收起来源：普通查询
2022-08-27

首页上一页 3 4 5 6 7 8 9 下一页尾页

0/150

提交

取消

开始学习

课程须知: 1、有Java开发基础，了解Lambda表达式； 2、至少会使用一种关系型数据库； 3、熟悉Maven; 4、熟悉SpringBoot； 5、最好熟悉MyBatis。

老师告诉你能学到什么？: 1、了解MP的基本原理及框架特点； 2、掌握MP通用Mapper的使用； 3、掌握MP常用注解的使用； 4、掌握ActiveRecord模式的使用； 5、掌握MP多种主键策略的使用； 6、掌握MP常用配置的使用； 7、掌握MP通用Service的使用； 8、掌握MP在某些应用场景下的具体使用方式。

微信扫码，参与3人拼团

热搜

最近搜索清空

MyBatis-Plus入门