MybatisPlus入门

MyBatis-Plus

MP是一个MyBatis的增强工具,只做增强不做改变。

文档及项目地址

官方地址：https://mybatis.plus/

github: https://github.com/baomidou/mybatis-plus

MP自带的CRUD操作是针对单表操作的，如果要操作多表，可以写自定义sql。

给你举个使用条件构造器的多表sql例子，可以写在xml中或注解中，下面的是用xml的写法：

<select id="mySelectList" resultType="User">     
    select u.*,r.role_name 
    from user u inner join role r 
    on u.role_id = r.role_id 
    ${ew.customSqlSegment}
</select>

对应的Mapper接口中的方法定义：

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

​ 返回值可以是VO。也可以是实体类，但要要记住，如果用实体类接返回值，实体中非该实体对应表的数据库字段的属性上要标注@TableField(exist = false)，如果使用了条件构造器，条件构造器的字段名别忘了带别名。

实体类

@Data
@TableName("mp_user")
public class User extends Model<User> {
    //主键
    //@TableId指定主键   plus 默认 查找 字段为id的作为主键 若主键不为id 需要设置
    @TableId(type = IdType.AUTO)
    private Integer id;
    //姓名
    @TableField(condition = SqlCondition.LIKE_RIGHT)
    private String name;
    //年龄
    private Integer age;
    //邮箱   @TableField   属性与数据库字段匹配
    @TableField(value = "mp_Email")
    private String email;
    //上级id
    private Integer managerId;
    //时间
    private LocalDateTime createTime;

    //场景：多于属性存在类中
    //1.transient 不参与序列化  不建议使用 private transient String remark;
    //2.设置为static静态
    //3.@TableField(exist=false) 默认为true
//    private static String remark;
//
//    public static String getRemark() {
//        return remark;
//    }
//
//    public static void setRemark(String remark) {
//        User.remark = remark;
//    }
    @TableField(exist = false)
    private String remark;
}

Mapper

@Mapper
public interface UserMapper extends BaseMapper<User> {

//    @Select("select name,age from mp_user ${ew.customSqlSegment}")
    List<User> selectAll(@Param(Constants.WRAPPER)Wrapper<User> wrapper);

    IPage<User> selectMyPageUser(IPage<User>page,@Param(Constants.WRAPPER)Wrapper<User> wrapper);

    IPage<User> selectPageUser(IPage<?>page);

    List<User>  selectPageUserList(IPage<User> page);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.mq.mybatis.mapper.UserMapper">

    <select id="selectAll" resultType="com.mq.mybatis.domain.dao.User">
        select name,age from mp_user ${ew.customSqlSegment}
    </select>

    <select id="selectMyPageUser" resultType="com.mq.mybatis.domain.dao.User">
        select name,age from mp_user ${ew.customSqlSegment}
    </select>

    <select id="selectPageUser" resultType="com.mq.mybatis.domain.dao.User">
        select * from mp_user
    </select>

    <select id="selectPageUserList" resultType="com.mq.mybatis.domain.dao.User">
        select * from mp_user
    </select>

</mapper>

Service

public interface UserService {

    ResponseEntity selectPageUser();

    ResponseEntity selectPageUserList();

    ResponseEntity selectMyPageUser(String  name);
}

@Service
public class UserServiceImpl implements UserService {
    private UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Override
    public ResponseEntity selectPageUser() {
        Page<User> page=new Page<>(1,5);
        IPage<User> userIPage = userMapper.selectPageUser(page);
        List<User> records = userIPage.getRecords();
        return ResponseEntity.ok(records);
    }

    @Override
    public ResponseEntity selectPageUserList() {
        Page<User> page=new Page<>(1,5);
        List<User> users = userMapper.selectPageUserList(page);
        return ResponseEntity.ok(users);
    }

    @Override
    public ResponseEntity selectMyPageUser(String name) {
        Page<User> page=new Page<>(1,5);
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.eq("name",name);
        IPage<User> userIPage = userMapper.selectPage(page,queryWrapper);
        List<User> records = userIPage.getRecords();
        return ResponseEntity.ok(records);
    }
}

Controller

@RestController
public class UserController {

    private UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/selectPageUser")
    public ResponseEntity<?> selectPageUser(){
        return  userService.selectPageUser();
    }

    @GetMapping("/selectPageUserList")
    public ResponseEntity<?> selectPageUserList(){
        return  userService.selectPageUserList();
    }

    @GetMapping("/selectMyPageUser")
    public ResponseEntity<?> selectMyPageUser(@RequestParam("name") String name){
        return  userService.selectMyPageUser(name);
    }
}

MybatisPlus配置文件以及yml

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

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> configuration.setUseDeprecatedExecutor(false);
    }
}

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: hui999505
    url: jdbc:mysql://39.106.106.96:3306/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
  profiles:
    active:
mybatis-plus:
  mapper-locations: classpath:mapper/*Mapper.xml
  global-config: #全局配置
    db-config:
      id-type: auto #id自增
  type-aliases-package: com.mq.mybatis.domain.dao
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

CRUD

查询和新增

@SpringBootTest
@RunWith(SpringRunner.class)
class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void select(){
        List<User> users = userMapper.selectList(null);
        Assert.assertEquals(5,users.size());
        users.forEach(System.out::println);
    }

    @Test
    public void insert(){
        User user=new User();
        user.setName("库里");
        user.setAge(18);
        user.setEmail("1428538005@qq.com");
        user.setManagerId(3);
        user.setCreateTime(LocalDateTime.now());
        user.setRemark("我是一个备注");

        System.out.println(userMapper.insert(user));
    }

    @Test
    public void select2(){
        //selectById     * 根据 ID 查询  * @param id 主键ID
        User user = userMapper.selectById(1);
        System.out.println(user);
        //selectBatchIds      * 查询（根据ID 批量查询） * @param idList 主键ID列表(不能为 null 以及 empty)
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1,2));
        users.forEach(System.out::println);
        //selectByMap     * 查询（根据 columnMap 条件）* @param columnMap 表字段 map 对象
        HashMap<String,Object> map=new HashMap<>();
        map.put("age",18);
        map.put("name","库里");
//        map.put("mp_Email","1428538005@qq.com");   注意  key存的 是数据库表的字段名称  不是类属性名***
        List<User> userList = userMapper.selectByMap(map);
        userList.forEach(System.out::println);
    }

    /**
     * 名字中包含雨 并且年龄小于40
     *  name like '%雨%' and  age<40
     */
    @Test
    public void selectByWrapper(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
//        QueryWrapper<User> query = Wrappers.<User>query();
        queryWrapper.like("name","里").lt("age",40);
        List<User> users = userMapper.selectList(queryWrapper);
    }
    /**
     * 名字中包含雨 并且年龄大于20且小于40 并且email不为空
     */
    @Test
    public void selectByWrapper2(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.like("name","里").between("age",20,40).isNotNull("mp_Email");
        List<User> users = userMapper.selectList(queryWrapper);
    }
    /**
     * 名字为王姓或者年龄大于等于25，按照年龄降序排列，年龄相同按照id升序排列
     */
    @Test
    public void selectByWrapper3(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.likeRight("name","王").or().ge("age",30).orderByDesc("age").orderByAsc("id");
        List<User> users = userMapper.selectList(queryWrapper);
    }
    /**
     * 创建日期为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<>();
        queryWrapper.apply("date_format(create_time,'%Y-%m-%d')=2020-12-13");//存在sql注入的风险
        queryWrapper.apply("date_format(create_time,'%Y-%m-%d')={0}","2020-12-13").inSql("manager_id","select id from mp_user where name like '王%'");
        List<User> users = userMapper.selectList(queryWrapper);
    }
    /**
     * 5、名字为王姓并且(年龄小于40或邮箱不为空)
     * name like '王%' and (age<40 or email is not null)
     */
    @Test
    public void selectByWrapper5(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.likeRight("name","王").and(wq->wq.lt("age",35).or().isNotNull("mp_Email"));
        List<User> users = userMapper.selectList(queryWrapper);
    }
    /**
     * 6、名字为王姓或者（年龄小于40并且年龄大于20并且邮箱不为空)
     * name like '王%'or age<40 and age>20 and email is not null)
     */
    @Test
    public void selectByWrapper6(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.likeRight("name","王").or(wq->wq.lt("age",40).gt("age",20).isNotNull("mp_Email"));
        List<User> users = userMapper.selectList(queryWrapper);
    }
    /**
     * 7、(年龄小于40或邮箱不为空)并且名字为王姓
     * (age<40 or email is not null) and name like '王%1
     */
    @Test
    public void selectByWrapper7(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.nested(wq->wq.lt("age",40).or().isNotNull("mp_Email")).likeRight("name","王");
        List<User> users = userMapper.selectList(queryWrapper);
    }
    /**
     * 8、年龄为30,31,32,33,34,35
     * age in (30,31,32,33,34,35)
     */
    @Test
    public void selectByWrapper8(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.in("age",Arrays.asList(31,32,33,34,35));
        List<User> users = userMapper.selectList(queryWrapper);
    }
    /**
     * 9、查询满足条件的一条数据
     * limit 1
     */
    @Test
    public void selectByWrapper9(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.in("age",Arrays.asList(31,32,33,34,35)).last("limit 1");//last无视优化规则 只能调用一次，多次以最后一次为准，有sql注入风险
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }
    /**
     * 查询中字段不为全部的查询
     * 1.如果只查询部分字段 可以使用.select(字段名,字段名...)   效率不高，需要写很多次
     * 2.queryWrapper.select(entityClass,predicate)  predicate包含不需要查询的字段，使用Lambda表达式
     */
    @Test
    public void selectByWrapperSupper(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
//        queryWrapper.select("id","name","age","mp_Email").like("name","里").lt("age",40);
        queryWrapper.select(User.class,info->!info.getColumn().equals("create_time")&&!info.getColumn().equals("manager_id"));
        List<User> users = userMapper.selectList(queryWrapper);
    }

    /**
     * Condition
     * @Param condition 执行条件 true 执行 false 不执行
     * @Param column 字段
     * @Param val 值
     * @Param children
     */
    private void condition(String name,String email){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
//        if(StringUtils.isNotBlank(name)){
//            queryWrapper.likeRight("name",name);
//        }
//        if(StringUtils.isNotBlank(name)){
//            queryWrapper.eq("mp_Email",email);
//        }
        queryWrapper.like(StringUtils.isNotBlank(name),"name",name);
        queryWrapper.eq(StringUtils.isNotBlank(email),"mp_Email",email);
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

    @Test
    public void TestCondition(){
        String name="王";
        String email="1428538005@qq.com";
        condition(name,email);
    }

    /**
     * QueryWrapper添加entity都会执行  最好不要一起用    new QueryWrapper<>(Entity);
     * 如果使用new QueryWrapper<>(Entity);  entity实习类中可以设置@TableField()
     * @TableField(condition = SqlCondition.LIKE_RIGHT) SqlCondition.xxx
     * private id;
     */
    @Test
    public void selectByWrapperEntity(){
        User whereUser=new User();
        whereUser.setName("王毅辉");
        QueryWrapper<User> queryWrapper=new QueryWrapper<>(whereUser);
//        queryWrapper.eq("name","王");
        List<User> users = userMapper.selectList(queryWrapper);
    }

    /**
     * allEq
     *  allEq(Map<R,V> params)
     *  allEq(Map<R,V> params,boolean null2IsNull)
     *  allEq(boolean condition,Map<R,V> params,boolean null2IsNull)
     *
     *  个别参数说明：
     *  params： key为数据库字段名,value为字段值
     *  null2IsNull: 为true则在map的value为null时调用isNull方法,为false则不调用
     *  例1: allEq({id: 1 ,name:"老王" , age:null}) ---> id = 1 and name = '老王'and age is null
     */
    @Test
    public void selectByWrapperAllEq(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        HashMap<String,Object> map=new HashMap<>();
        map.put("name","库里");
        queryWrapper.allEq(map);// null2IsNull  默认为true
        List<User> users = userMapper.selectList(queryWrapper);
    }
    /**
     /**
     * 查询（根据 columnMap 条件）
     *
     * @param columnMap 表字段 map 对象
     */
    @Test
    public void selectByWrapperMap(){
        HashMap<String,Object> map=new HashMap<>();
        map.put("name","库里");
        List<User> users = userMapper.selectByMap(map);
    }
    /**
     * 按照直属上级分组，查询每组的平均年龄、最大年龄、最小年龄。并且只取年龄总和小于50的组。
     * select avg(age) avg_age,min(age) min_age,max(age) max_age from user
     * group by manager_id having sum(age)<500
     */
    @Test
    public void selectByWrapperMap2(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
//        QueryWrapper<User> query = Wrappers.<User>query();
        queryWrapper.select("avg(age) avg_age","min(age) min_age","max(age) max_age")
                .groupBy("manager_id").having("sum(age)<{0}",50);
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    }
    /**
     * 根据 Wrapper 条件，查询全部记录
     * <p>注意： 只返回第一个字段的值</p>
     * List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    @Test
    public void selectObjs(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.select("avg(age) avg_age","min(age) min_age","max(age) max_age")
                .groupBy("manager_id").having("sum(age)<{0}",50);
        List<Object> objects = userMapper.selectObjs(queryWrapper);
    }
    /**
     * 根据 Wrapper 条件，查询总记录数
     * Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    @Test
    public void selectCount(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.likeRight("name","王");
        Integer count = userMapper.selectCount(queryWrapper);
    }
    /**
     * 根据 entity 条件，查询一条记录
     * T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     * 查询出多条数据会报错 查询0条出去不会报错
     */
    @Test
    public void selectOne(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.likeRight("name","无敌").last("limit 1");
        User user = userMapper.selectOne(queryWrapper);
    }

    @Test
    public void selectLambda(){
//        LambdaQueryWrapper<Object> lambda = new QueryWrapper<>().lambda();
//        LambdaQueryWrapper<User>lambda=new LambdaQueryWrapper<>();
        LambdaQueryWrapper<User> lambda=Wrappers.<User>lambdaQuery();
        lambda.like(User::getName,"里").lt(User::getAge,40);
        //where name like '%里%' and age<40
        List<User> users = userMapper.selectList(lambda);
    }

    @Test
    public void selectLambda2(){
//        LambdaQueryWrapper<Object> lambda = new QueryWrapper<>().lambda();
//        LambdaQueryWrapper<User>lambda=new LambdaQueryWrapper<>();
        LambdaQueryWrapper<User> lambda=Wrappers.<User>lambdaQuery();
        lambda.like(User::getName,"里").
                and(wq->wq.lt(User::getAge,40).or().isNotNull(User::getEmail));
        //where name like '%里%' and (age<40 or email is not null)
        List<User> users = userMapper.selectList(lambda);
        users.forEach(System.out::println);
    }

    /**
     * new LambdaQueryChainWrapper<Entity>(***Mapper).like.toList()  等等
     */
    @Test
    public void selectLambda3(){
        List<User> list = new LambdaQueryChainWrapper<User>(userMapper).like(User::getName, "王荒年").list();
        list.forEach(System.out::println);
    }

    /**
     * 自定义sql  可以在Mapper接口中 用注解使用  也可以 在xml中使用
     * ${ew.customSqlSegment}
     */
    @Test
    public void selectLambda4(){
        LambdaQueryWrapper<User> lambda=Wrappers.<User>lambdaQuery();
        lambda.like(User::getName,"里").
                and(wq->wq.lt(User::getAge,40).or().isNotNull(User::getEmail));
        //where name like '%里%' and (age<40 or email is not null)
        List<User> users = userMapper.selectAll(lambda);
        //select name,age from mp_user WHERE (name LIKE ? AND (age < ? OR mp_Email IS NOT NULL))
    }

    /**
     * 分页查询
     */
    @Test
    public void selectPage(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
//        queryWrapper.like("name","里");
        //new Page<>(current当前页数,size每页行数,isSearchCount是否查询总数)
//        Page<User> page = new Page<User>(1, 5,true);
        //selectPage(page,queryWrapper)
//        Page<User> userPage = userMapper.selectPage(page, queryWrapper);
//        System.out.println("总记录数"+userPage.getTotal());
//        System.out.println("总页数"+userPage.getPages());
//        List<User> records = userPage.getRecords();
         Page<Map<String,Object>> page = new Page<Map<String,Object>>(1, 5);
        IPage<Map<String,Object>> page1  = userMapper.selectMapsPage(page, queryWrapper);
    }
    /**
     * 分页查询自定义查询
     */
    @Test
    public void selectMyPage(){
        QueryWrapper<User> queryWrapper=new QueryWrapper<>();
        queryWrapper.like("name","里");
        Page<User> page = new Page<User>(1, 5,true);
        IPage<User> userIPage = userMapper.selectMyPageUser(page, queryWrapper);
        userIPage.getRecords().forEach(System.out::println);
    }
    
}

修改

class UserMapperTest {
/**
     * 根据 ID 修改
     * updateById
     * @param entity 实体对象
     */
    @Test
    public void updateById(){
        User user=new User();
        user.setId(1);
        user.setName("王毅辉");
        user.setAge(26);
        int count = userMapper.updateById(user);
        System.out.println(count);
    }
    /**
     * 根据 ID 修改
     * updateById
     * @param entity 实体对象
     */
    @Test
    void updateById(){
        User user=new User();
        user.setId(1);
        user.setName("王毅辉");
        user.setAge(26);
        userMapper.updateById(user);
    }
    /**
     * 根据 whereEntity 条件，更新记录
     * int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
     * @param entity        实体对象 (set 条件值,可以为 null)
     * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    @Test
    void update(){
        User userWhere=new User();
        userWhere.setName("王科比");
        UpdateWrapper<User> updateWrapper=new UpdateWrapper<>(userWhere);
        //如果在UpdateWrapper中加入entity 相当于在where条件中加入语句
        updateWrapper.eq("age",28);
        User user=new User();
        user.setName("王库里");
        user.setEmail("13407145006@163.com");
        int count = userMapper.update(user, updateWrapper);
    }

    /**
     * userMapper.update(null, updateWrapper);//不传user  null,  可以直接在updateWrapper后面set
     */
    @Test
    void update2(){
        UpdateWrapper<User> updateWrapper=new UpdateWrapper<>();
//        User user=new User();
//        user.setName("王库里");
//        user.setEmail("13407145006@163.com");
        updateWrapper.eq("age",28).set("name","王库里").set("mp_Email","13407145006@163.com");
        int count = userMapper.update(null, updateWrapper);//不传user  null,  可以直接在updateWrapper后面set
    }

    /**
     * LambdaUpdateWrapper<User> lambda = new UpdateWrapper<User>().lambda();
     */
    @Test
    void updateLambda3(){
        LambdaUpdateWrapper<User> lambda = new UpdateWrapper<User>().lambda();
//        LambdaUpdateWrapper<User> lambda = Wrappers.lambdaUpdate();
        lambda.eq(User::getName,"王毅辉").set(User::getName,"王荒念念");
        int count = userMapper.update(null, lambda);//不传user  null,  可以直接在updateWrapper后面set
    }
    /**
     * LambdaUpdateWrapper<User> lambda = new UpdateWrapper<User>().lambda();
     */
    @Test
    void updateLambda4(){
        boolean update = new LambdaUpdateChainWrapper<User>(userMapper)
                .eq(User::getName, "王荒念念")
                .set(User::getName, "王毅辉").update();//update(entity)不传user  null,  可以直接在updateWrapper后面set
        System.out.println(update);
    }
}

删除

class UserMapperTest {
/**
 * 删除根据id
 */
@Test
void deleteById(){
    int count = userMapper.deleteById(14);
    System.out.println("删除条数为："+count);
}

/**
 * 删除根据ids 批量删除
 */
@Test
void deleteByIds(){
    int count = userMapper.deleteBatchIds(Arrays.asList(1,2,3,4,5));
    System.out.println("删除条数为："+count);
}

/**
 * 删除根据map  where xxx=xxx,xxx=xxx
 */
@Test
void deleteByMap(){
    HashMap<String,Object> map=new HashMap<>();
    map.put("name","库里");
    int count = userMapper.deleteByMap(map);
    System.out.println("删除条数为："+count);
}

/**
 * 根据 entity 条件，删除记录
 * int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 * @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
 */
@Test
void delete(){
    QueryWrapper<User> queryWrapper=new QueryWrapper<>();
    queryWrapper.eq("name","王毅辉");
    int count = userMapper.delete(queryWrapper);
    System.out.println("删除条数为："+count);
}
//根据lambda表达式删除
@Test
void deleteByLambda(){
    LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.lambdaQuery();
    lambdaQueryWrapper.eq(User::getAge,27).or().gt(User::getAge,40);
    int count = userMapper.delete(lambdaQueryWrapper);
    System.out.println("删除条数为："+count);
}
}

AR模式

1. 是实体需要继承Model类。
2. 是必须存在对应的原始mapper并继承BaseMapper并且可以使用的前提下，才能使用此 AR 模式。

可以直接使用Entity进行,insert(),update,delete