mybatisplus 使用Demo大全

最新推荐文章于 2024-01-06 22:29:17 发布
最新推荐文章于 2024-01-06 22:29:17 发布
阅读量527 收藏
点赞数
分类专栏： mybatis源码框架思路分析 文章标签： mybatis mp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39715061/article/details/114387760
版权

mybatisplus 使用实例

一些基本的配置与用法

global-config:
    db-config:
      #ID_WORKER是默认的全局主键策略
      id-type: ID_WORKER

      #NOT_NULL:默认，当实体类字段为null时，不引入到where
      #IGNORED:当实体类字段为null时，仍然引入到where，即where field=null
      #NOT_EMPTY：当实体类字段为null或为空串时，不引入到where
      insert-strategy: NOT_NULL
      updateStrategy: NOT_NULL
      select-strategy: NOT_NULL

      #表前缀+实体类名(驼峰转下划线) = 要操作的表
#      table-prefix: mp_

一、修改的用法

package com.dsf.mp.service.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsf.mp.service.ServiceApp;
import com.dsf.mp.service.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.List;
import java.util.Map;

@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ServiceApp.class)
public class UserServiceTest {
    @Autowired
    IUserService userService;

    @Test
    public void getOne() {
        User one = userService.getOne(Wrappers.<User>lambdaQuery().gt(User::getAge, 25), false);//如果查出多条不抛异常
        System.out.println(one);
    }

    /**
     * 批量插入
     */
    @Test
    public void saveBatch() {
        User user1 = new User();
        user1.setName("徐丽1");
        user1.setAge(28);

        User user2 = new User();
        user2.setName("徐丽2");
        user2.setAge(29);

        List<User> list = Arrays.asList(user1, user2);

        boolean success = userService.saveBatch(list);

        System.out.println("是否批量插入成功：" + success);
    }

    /**
     * 批量插入或更新
     */
    @Test
    public void saveOrUpdateBatch() {
        User user1 = new User();
        user1.setName("age相同11");
        user1.setAge(59);

        User user2 = new User();
        user2.setName("贺高健");
        user2.setAge(85);
        user2.setId(1170823840919412738L);

        List<User> list = Arrays.asList(user1, user2);
//        boolean success = userService.saveOrUpdateBatch(list,1000);

//        System.out.println("是否批量插入或更新成功："+success);
    }

    /**
     * lambdaQuery
     */
    @Test
    public void lambdaQuery() {
    /*    List<User> list = userService.lambdaQuery().gt(User::getAge, 25).like(User::getName, "雨").list();
        list.forEach(System.out::println);*/
//        Wrappers.<User>lambdaQuery().
        User user = new User();
        user.setAge(59);
//        Wrappers.lambdaQuery(user);
        List<User> list = userService.list(Wrappers.<User>lambdaQuery(user));
//        User one = userService.getOne(Wrappers.<User>lambdaQuery(user));
        System.out.println(list);

    }

    /**
     * lambdaUpdate
     */
    @Test
    public void lambdaUpdate() {
        boolean success = userService.lambdaUpdate()
                .eq(User::getAge, 25)
                .set(User::getAge, 26)
                .update();
        System.out.println("是否更新成功：" + success);
    }

    /**
     * lambdaUpdate_remove
     */
    @Test
    public void lambdaUpdate_remove() {
        //查询
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
         /* queryWrapper.select("出现的字段", ",").eq("name", "");
        queryWrapper.eq("name", "")
                .select(User.class, info -> !info.getColumn().equals("") && info.getColumn().equals("不出现的字段"));*/
//        分组,聚合,返回map
//        queryWrapper.select("avg(age) avg_age", "min(age) min_age", "max(age) max_age").groupBy("manager_id").having("sum(age) <{0}", 500);
//        userService.getBaseMapper().selectMaps(queryWrapper);

        // condition 的作用赋值之后直接查询
//        List<User> list = userService.list(Wrappers.<User>lambdaQuery(user));
        //默认的 根据User里面的参数来确定的
//        QueryWrapper<User> wrapper = new QueryWrapper<>(new User());
        //AllEQ的用法
       /* QueryWrapper<User> wrapper = new QueryWrapper<>();
        Map<String, Object> allEq = new HashMap<>();
        allEq.put("name", "age相同11");
        allEq.put("age", null);
        wrapper.allEq(allEq);
        //过滤值 去掉这个字段的条件
        queryWrapper.allEq((k,v)->!k.equals("aa"),allEq);*/

       /* boolean success = userService.lambdaUpdate()
                .gt(User::getAge, 50)
                .remove();

        System.out.println("是否更新_删除成功：" + success);*/
        //selectObjects返回第一列数据
        queryWrapper.select("id", "name").like("name", "健").gt("age", 40);
        List<Object> objects = userService.getBaseMapper().selectObjs(queryWrapper);
        //返回多条数据里面用map包装
        List<Map<String, Object>> list = userService.getBaseMapper().selectMaps(queryWrapper);
        lambdaUpdate();
//        //lambda 三种构造方法
//        LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();
//        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
//        LambdaQueryWrapper<User> wrapper1 = Wrappers.<User>lambdaQuery();
//        加上Chain的参数
//        new LambdaQueryChainWrapper<>(userService.getBaseMapper()).like(User::getAge,"").list();

        objects.forEach(System.out::print);
    }


}

二、查询用法记录

package com.dsf.mp.pagination.dao;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.dsf.mp.pagination.PaginationApp;
import com.dsf.mp.pagination.entity.User;
import com.dsf.mp.pagination.vo.UserVo;
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.List;
import java.util.Map;

@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
@RunWith(SpringRunner.class)
@SpringBootTest(classes = PaginationApp.class)
public class UserMapperTest {
    @Autowired
    UserMapper userMapper;

    /**
     * 自定义Sql:
     * 1.注解形式：com.dsf.mp.demo4.dao.UserMapper
     * 2.xml文件形式：/resources/mapper/UserMapper.xml
     */
    @Test
    public void mySelect() {
        LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
        query.likeRight(User::getName, "王")
            .and(q -> q.lt(User::getAge, 40).or().isNotNull(User::getEmail));
        List<User> list = userMapper.selectAll(query);
        list.forEach(System.out::println);
    }

    /**
     * 单表分页:selectPage
     * 返回实体类列表
     */
    @Test
    public void selectPage() {
        LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
        query.ge(User::getAge,26).orderByDesc(User::getCreateTime);

        Page<User> page = new Page<> (1,2);
        userMapper.selectPage(page,query);

        System.out.println("总页数："+page.getPages());
        System.out.println("总记录数："+page.getTotal());
        List<User> list = page.getRecords();//分页返回的对象与传入的对象是同一个
        list.forEach(System.out::println);
    }

    /**
     * 单表分页:selectPage
     * 不查记录数
     */
    @Test
    public void selectPage_notSearchCount() {
        LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
        query.ge(User::getAge,26).orderByDesc(User::getCreateTime);

        Page<User> page = new Page<> (1,2,false);//不查记录数
        IPage<User>  iPage = userMapper.selectPage(page,query);//也可以用新Page对象接收返回的数据

        System.out.println("总页数："+iPage.getPages());
        System.out.println("总记录数："+iPage.getTotal());
        List<User> list = iPage.getRecords();
        list.forEach(System.out::println);
    }

    /**
     * 单表分页:selectMapsPage
     * 返回Map列表
     */
    @Test
    public void selectMapsPage() {
        LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
        query.ge(User::getAge,26).orderByDesc(User::getCreateTime);

        Page<User> page = new Page<> (1,2);
        IPage<Map<String,Object>>  iPage = userMapper.selectMapsPage(page,query);

        System.out.println("总页数："+page.getPages());
        System.out.println("总记录数："+iPage.getTotal());
        List<Map<String,Object>> list = iPage.getRecords();
        list.forEach(System.out::println);
    }

    /**
     * 自定义多表联查并分页
     *
     * ps: 本人认为，多表联查使用exists比使用join效率较高、通用性更强、sql语句更简单，
     * 虽然只查出单个主表的数据，但是业务层中可以根据需要，通过主表id再次查询出关联子表的对应页数据
     * 当然也可以在web端做异步访问查询，以防止一次查询出数据太多、耗时过长降低用户体验
     */
    @Test
    public void selectUserPage() {
        UserVo userVo = new UserVo();
        userVo.setAgeStart(25);
        userVo.setHobby("学");

        Page<User> page = new Page<> (1,2);
        userMapper.selectUserPage(page,userVo);

        System.out.println("总页数："+page.getPages());
        System.out.println("总记录数："+page.getTotal());
        List<User> list = page.getRecords();
        list.forEach(System.out::println);
    }


}

2.CRUD的基本操作

@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
@RunWith(SpringRunner.class)
@SpringBootTest(classes = CrudApp.class)
public class DeleteTest {
    @Autowired
    UserMapper userMapper;

    @Test
    public void deleteById() {
        int rows = userMapper.deleteById(1170243901535006722L);

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

    @Test
    public void deleteByMap(){
        Map<String,Object> map = new HashMap<>();
        map.put("name","刘明强");
        map.put("age",31);

        int rows = userMapper.deleteByMap(map);

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

    @Test
    public void deleteBatchIds(){
        List<Long> ids = Arrays.asList(
            1170735636174278657L,
            1170735727241048065L
        );

        int rows = userMapper.deleteBatchIds(ids);

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

    @Test
    public void delete(){
        LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
        query.eq(User::getName,"刘明强").or().gt(User::getAge,50);

        int rows = userMapper.delete(query);

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

    @Test
    public void delete_entity(){
        User whereUser = new User();
        whereUser.setName("明强");//实体类中 @TableField(condition= SqlCondition.LIKE)仍然起作用

        LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>(whereUser);
        query.lt(User::getAge,50);

        int rows = userMapper.delete(query);

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

}
 @Test
    public void insert() {
        User user = new User();
        user.setName("刘明强");
        user.setAge(31);
        user.setManagerId(1088248166370832385L);
//        user.setEmail("lmq@baomidou.com");
        user.setCreateTime(LocalDateTime.now());
        int row = userMapper.insert(user);
        System.out.println("影响记录数："+row);
        System.out.println("自增id: "+user.getId());
    }

查询的N种用法

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

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

    @Test
    public void selectByMap() {
        Map<String, Object> map = new HashMap<>();
        //map的key指代的是mysql表中的列名，并非java实体的属性名
        map.put("name", "张雨琪");
        map.put("manager_id", 1088248166370832385L);
        List<User> list = userMapper.selectByMap(map);
        list.forEach(System.out::println);
    }

    @Test
    public void selectList_all() {
        List<User> list = userMapper.selectList(null);
        list.forEach(System.out::println);
    }

    /**
     * 名字中包含雨，并且年龄小于40
     * SELECT * FROM `user`
     * WHERE `name` LIKE '%雨%' AND `age`< 40
     */
    @Test
    public void selectList_like_lt() {
//        QueryWrapper<User> query = Wrappers.<User>query();
        QueryWrapper<User> query = new QueryWrapper<>();
        query.like("name", "雨").lt("age", 40);
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 名字中包含雨，并且年龄大于等于20且小于等于40，并且email不为空
     * SELECT * FROM `user`
     * WHERE `name` LIKE '%雨%' AND `age` <= 40 AND `age` >= 20 AND `email` IS NOT NULL
     */
    @Test
    public void selectList_between_isNotNull() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.like("name", "雨").between("age", 20, 40).isNotNull("email");
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 姓赵或者年龄大于等于25，按照年龄降序排列，年龄相同则按照id升序排列
     * SELECT * FROM `user`
     * WHERE `name` LIKE '赵%' OR `age` >= 25 ORDER BY `age` DESC , `id` ASC;
     */
    @Test
    public void selectList_or_orderByDesc_orderByAsc() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.likeRight("name", "赵").or().ge("age", 20)
            .orderByDesc("age").orderByAsc("id");
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 创建日期为2019年2月14日，且直属上级姓王
     * SELECT * FROM `user`
     * WHERE DATE_FORMAT(create_time,'%Y-%m-%d')='2019-02-14'
     * AND manager_id IN (SELECT id FROM `user` WHERE `name` LIKE '王%')
     */
    @Test
    public void selectList_apply_inSql() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.apply("DATE_FORMAT(create_time,'%Y-%m-%d')={0}", "2019-02-14")
            .inSql("manager_id", "SELECT id FROM `user` WHERE `name` LIKE '王%'");
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 姓王且（年龄小于40或邮箱不为空）
     * SELECT * FROM `user`
     * WHERE `name` LIKE '王%' AND (`age`< 40 OR `email` IS NOT NULL)
     */
    @Test
    public void selectList_and_lambda() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.likeRight("name", "王")
            .and(q -> q.lt("age", 40).or().isNotNull("email"));
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 姓王且或者（年龄小于40且年龄大于20且邮箱不为空）
     * SELECT * FROM `user`
     * WHERE `name` LIKE '王%' OR (`age`< 40 AND `age` > 20  AND `email` IS NOT NULL)
     */
    @Test
    public void selectList_or_lambda() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.likeRight("name", "王")
            .or(q -> q.lt("age", 40).gt("age", 20).isNotNull("email"));
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * （年龄小于40或邮箱不为空）且姓王
     * SELECT * FROM `user`
     * WHERE (`age`< 40 OR `email` IS NOT NULL) AND `name` LIKE '王%'
     */
    @Test
    public void selectList_nested() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.nested(q -> q.lt("age", 40).or().isNotNull("email"))
            .likeRight("name", "王");
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 年龄为30,31,34,35
     * SELECT * FROM `user` WHERE `age` IN (30,31,34,35);
     */
    @Test
    public void selectList_in() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.in("age", Arrays.asList(30, 31, 34, 35));
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 返回只满足条件的一条（只调用最后一次，有sql注入的风险）
     * SELECT * FROM `user` WHERE `age` IN (30,31,34,35) LIMIT 1;
     */
    @Test
    public void selectList_last() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.in("age", Arrays.asList(30, 31, 34, 35)).last("limit 1");
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 只查询指定字段
     * SELECT `name`,`age` FROM `user` WHERE `age` IN (30,31,34,35) LIMIT 1;
     */
    @Test
    public void selectList_select_include() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.select("name", "age").in("age", Arrays.asList(30, 31, 34, 35)).last("limit 1");
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 排除指定字段
     */
    @Test
    public void selectList_select_exclude() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.in("age", Arrays.asList(30, 31, 34, 35)).last("limit 1")
            .select(
                User.class,
                info -> !info.getColumn().equals("create_time") && !info.getColumn().equals("manager_id")
            );
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 条件判断
     */
    @Test
    public void selectList_condition() {
        String name = "刘";
        String email = "";
        QueryWrapper<User> query = new QueryWrapper<>();
        query.like(StringUtils.isNotEmpty(name), "name", name)
            .like(StringUtils.isNotEmpty(email), "email", email);
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 实体类作为条件构造器
     * 默认是等值查询，可以在实体类属性中设置自定义条件
     */
    @Test
    public void selectList_entity() {
        User whereUser = new User();
        whereUser.setName("刘");//name like "刘"
        whereUser.setAge(32);//age<30
        QueryWrapper<User> query = new QueryWrapper<>(whereUser);
        query.eq("manager_id", "1088248166370832385");

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

    /**
     * allEq
     */
    @Test
    public void selectList_allEq() {
        QueryWrapper<User> query = new QueryWrapper<>();
        Map<String, Object> params = new HashMap<>();
        params.put("name", "刘明强");
        params.put("age", 31);
        params.put("email", null);
//        query.allEq(params,false);//第二个参数表示如果列值为null是否按IS NULL查询，false则忽略null列的查询
        query.allEq((k, v) -> !k.equals("name"), params, false);//第一个参数是过滤器
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * selectMaps的应用场景1：当表中的列特别多，但实际只需要几个列时，这时返回一个实体类有些不必要
     */
    @Test
    public void selectMaps() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.like("name", "雨").lt("age", 40).select("name", "age");
        List<Map<String, Object>> maps = userMapper.selectMaps(query);
        maps.forEach(System.out::println);
    }

    /**
     * selectMaps的应用场景2：查询统计结果
     * 按照直属上级分组，查询每组的平均年龄、最大年龄、最小年龄，并且只取年龄总和小于100的组
     * SELECT AVG(age) avg_age,MIN(age) min_age,MAX(age) max_age
     * FROM `user`
     * GROUP BY `manager_id`
     * HAVING SUM(age)<100;
     */
    @Test
    public void selectMaps2() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.select("AVG(age) avg_age", "MIN(age) min_age", "MAX(age) max_age")
            .groupBy("manager_id")
            .having("SUM(age)<{0}", 100);
        List<Map<String, Object>> maps = userMapper.selectMaps(query);
        maps.forEach(System.out::println);
    }


    /**
     * selectObjs只返回第一列，其它列被遗弃
     * 应用场景：只需返回一列的时候
     */
    @Test
    public void selectObjs() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.like("name", "雨").lt("age", 40).select("name", "age");
        List<Object> list = userMapper.selectObjs(query);
        list.forEach(System.out::println);
    }

    /**
     * 返回总记录数
     */
    @Test
    public void selectCount() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.like("name", "雨").lt("age", 40);
        Integer count = userMapper.selectCount(query);
        System.out.println("总记录数：" + count);
    }

    /**
     * selectOne：只能查询一条记录，查询到多条会报错
     */
    @Test
    public void selectOne() {
        QueryWrapper<User> query = new QueryWrapper<>();
        query.like("name", "刘红雨").lt("age", 40);
        User user = userMapper.selectOne(query);
        System.out.println(user);
    }

    /**
     * lambda条件构造器
     */
    @Test
    public void lambdaQueryWrapper1() {
//        LambdaQueryWrapper<User> lambdaQ = new QueryWrapper<User>().lambda();
//        LambdaQueryWrapper<User> lambdaQ = new LambdaQueryWrapper<>();
        LambdaQueryWrapper<User> lambdaQ = Wrappers.<User>lambdaQuery();

        lambdaQ.like(User::getName, "雨").lt(User::getAge, 40);
        List<User> list = userMapper.selectList(lambdaQ);
        list.forEach(System.out::println);
    }

    /**
     * lambda条件构造器:防误写（例如列名"name"可能被误写）
     */
    @Test
    public void lambdaQueryWrapper2() {
        LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
        query.likeRight(User::getName, "王")
            .and(q -> q.lt(User::getAge, 40).or().isNotNull(User::getEmail));
        List<User> list = userMapper.selectList(query);
        list.forEach(System.out::println);
    }

    /**
     * 链式lambda条件构造器：更优雅的书写方式
     */
    @Test
    public void lambdaQueryChainWrapper() {
        List<User> list = new LambdaQueryChainWrapper<User>(userMapper)
            .likeRight(User::getName, "王")
            .and(
                q -> q
                    .lt(User::getAge, 40)
                    .or()
                    .isNotNull(User::getEmail)
            )
            .list();
        list.forEach(System.out::println);
    }

更新与删除的N种用法

/**
     * 更新:updateById
     */
    @Test
    public void updateById() {
        User user = new User();
        user.setId(1088248166370832385L);
        user.setAge(26);
        user.setEmail("wtf2@baomidou.com");
        int rows = userMapper.updateById(user);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 更新: 通过wrapper
     */
    @Test
    public void update() {
        UpdateWrapper<User> update = new UpdateWrapper<>();
        update.eq("name", "李艺伟").eq("age", 28);

        User user = new User();
        user.setAge(29);
        user.setEmail("lyw2@baomidou.com");
        int rows = userMapper.update(user, update);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 更新: 通过entity(或和wrapper)
     */
    @Test
    public void update_entity() {
        User whereUser = new User();
        whereUser.setName("李艺伟");//实体类中 @TableField(condition= SqlCondition.LIKE)仍然起作用

        UpdateWrapper<User> update = new UpdateWrapper<>(whereUser);
        update.eq("age", 29);

        User user = new User();
        user.setAge(30);
        user.setEmail("lyw3@baomidou.com");

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

    /**
     * 更新:
     * 如果只更新1个或少量的几列，用set更简洁
     */
    @Test
    public void update_set() {
        UpdateWrapper<User> update = new UpdateWrapper<>();
        update.eq("name", "李艺伟")
            .eq("age", 30)
            .set("age", 31)
            .set("email", "lyw4@baomidou.com");

        int rows = userMapper.update(null, update);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 更新:
     * 使用LambdaUpdateWrapper可以防止列名被误写
     */
    @Test
    public void update_lambda() {
        LambdaUpdateWrapper<User> update = new LambdaUpdateWrapper<>();

        update.eq(User::getName, "李艺伟")
            .eq(User::getAge, 31)
            .set(User::getAge, 32)
            .set(User::getEmail, "lyw5@baomidou.com");

        int rows = userMapper.update(null, update);
        System.out.println("影响记录数：" + rows);
    }

    /**
     * 更新:
     * 使用LambdaUpdateChainWrapper可以使代码更简洁
     */
    @Test
    public void update_lambdaChain() {
        User user = new User();
        user.setAge(33);
        user.setEmail("lyw6@baomidou.com");

        boolean success = new LambdaUpdateChainWrapper<User>(userMapper)
            .eq(User::getName, "李艺伟")
            .eq(User::getAge, 32)
            .update(user);

        System.out.println("更新是否成功：" + success);
    }

    /**
     * 删除
     */
    @Test
    public void delete() {
        int rows = userMapper.deleteById(1170243901535006722L);

        System.out.println("影响记录数：" + rows);
    }
    @Test
    public void mySelect() {
        LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
        query.likeRight(User::getName, "王")
            .and(q -> q.lt(User::getAge, 40).or().isNotNull(User::getEmail));
        List<User> list = userMapper.selectAll(query);
        list.forEach(System.out::println);
    }

    @Test
    public void selectList_entity() {
        User whereUser = new User();
        whereUser.setName("刘");
        whereUser.setAge(32);
        whereUser.setEmail("");
        QueryWrapper<User> query = new QueryWrapper<>(whereUser);

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

更多的用法

 @Test
    public void insert(){
        User user = new User();
        user.setName("刘花");
        user.setAge(31);
        user.setManagerId(1088248166370832385L);
//        user.setEmail("lh@baomidou.com");
        user.setCreateTime(LocalDateTime.now());
        boolean success = user.insert();
        System.out.println("是否插入成功："+success);
    }

    @Test
    public void selectById(){
        User user = new User();
        User userSelect = user.selectById(1088248166370832385L);
        System.out.println("返回的是同一个User对象吗："+(userSelect==user));
        System.out.println(userSelect);
    }

    @Test
    public void selectById2(){
        User user = new User();
        user.setId(1088248166370832385L);
        User userSelect = user.selectById();
        System.out.println("返回的是同一个User对象吗："+(userSelect==user));
        System.out.println(userSelect);
    }

    @Test
    public void updateById(){
        User user = new User();
        user.setId(1170760467657715713L);
        user.setName("张草草");
        boolean success = user.updateById();
        System.out.println("是否更新成功："+success);
    }

    /**
     * 删除：
     * 如果没有指定的id，受影响的行数是0，也视为删除成功
     */
    @Test
    public void deleteById(){
        User user = new User();
        user.setId(1170760467657715766L);
        boolean success = user.deleteById();
        System.out.println("是否删除成功："+success);
    }

    /**
     * 添加或更新：
     * 如果没有设置id，则直接视为insert
     */
    @Test
    public void insertOrUpdate(){
        User user = new User();
        user.setName("张强");
        user.setAge(24);
        user.setEmail("zq@baomidou.com");
        user.setCreateTime(LocalDateTime.now());
        boolean success = user.insertOrUpdate();
        System.out.println("是否添加或更新成功（添加）："+success);
    }

    /**
     * 添加或更新：
     * 如果设置id，则先查询是否有此id的记录，如果有此id记录，则视为update,如果没有则视为insert
     */
    @Test
    public void insertOrUpdate2(){
        User user = new User();
        user.setId(1170767968797159426L);
        user.setAge(25);
        user.setCreateTime(LocalDateTime.now());
        boolean success = user.insertOrUpdate();
        System.out.println("是否添加或更新成功（更新）："+success);
    }

总结

以上是写了一些demo 方便闲暇之余过来看一看,或者不知道怎么用的时候过来写一下看一下

一只想飞的猪猪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis-plus练习Demo
05-17
mybatis-plus 对mbatis升级版本。引入它不会对现有工程产生影响，如丝般顺滑，只需简单配置，即可快速进行 CRUD 操作，从而节省大量时间。代码生成、分页、性能分析等功能一应俱全
【Springboot+MyBatis Plus demo】
爱喝阔落的猫的博客
07-06 202
【代码】【Springboot+MyBatis Plus demo】
mybatis-plus的demo
小徐不会秃
11-21 1546
一、创建工程 generator：存放代码生成器 service：demo代码 二、POM文件配置 2.1 父POM <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://mav
Mybatis Plus 入门Demo
weixin_61058262的博客
03-02 576
MybatisPlus是一个方便的操作数据库功能的代码工具。mybatis的技术框架因为经常要自己配置各种文件，进行很多次重复操作，常常会不小心出错，这时把经常重复的东西直接封装起来，甚至可以设置属性生成代码,能让工作量减少很多，就在原来mybatis基础上整合诞生了一个工具，叫mybatis-plus。(A|B法则)
MybatisPlus入门demo（从创建maven说起）
最新发布
qq_42865931的博客
01-06 428
demo之Mybatisplus_demo实现最简单的Mybatisplus入门demo。
Mybatis-Plus：Mybatis-Plus简单demo及其核心功能
记录，记录，记录
06-19 8810
一： 简单demo 第一步：打开Mybatis-Plus官网：mybatis-plus官网，点击快速开始选择springboot版本，于是我们就愉快地开始了。 官网pom文件： 官网yml文件配置： 那就是搞定这两个，我们就等于搞定了mybatis-plus入门了。 第二部：建立demo 首先得有数据库还有数据 数据库：这是我的库，我的表，还有我的数据 引入依赖，项目是springboot...
MyBatis-Plus整合Spring Demo
热门推荐
CBeann的博客
07-02 1万+
简介官方文档：苞米豆MyBatis-Plus（简称MP）是一个 MyBatis的增强工具，在 Mybatis 的基础上只做增强不做改变，为简化开发、提高效率而生。特性无侵入：Mybatis-Plus 在 Mybatis 的基础上进行扩展，只做增强不做改变，引入 Mybatis-Plus 不会对您现有的 Mybatis 构架产生任何影响，而且 MP 支持所有 Mybatis 原生的特性依赖少：仅仅...
mybatis-plus的各种实战demo
qq_38132995的博客
02-22 1133
mybatis-plus的使用详情 一、简介 MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化 开发、提高效率而生。 二、创建并初始化数据库 1、创建数据库 mybatis_plus_db 2、创建User表结构如下 id name age email 1 Jone 18 [email protected] 三、新建一个springboot项目 1、引入依赖 <!--mybatis-plus--> &
SpringBoot整合Mybatis-plus[超详细版]
wang20000102的博客
09-01 7317
SpringBoot整合Mybatis-plus[超详细版]Mybatis-Plus(简称MP)是一个Mybatis的增强工具，只是在Mybatis的基础上做了增强却不做改变，MyBatis-Plus支持所有Mybatis原生的特性，所以引入Mybatis-Plus不会对现有的Mybatis构架产生任何影响。MyBatis 增强工具包，简化 CRUD 操作。启动加载 XML 配置时注入单表 SQL 操作 ，为简化开发工作、提高生产率而生。
Mybatis-plus基本使用（demo）
weixin_53636376的博客
10-12 157
最后说一下：比较简单的增删改查，Mybatis-plus都帮我们写好了，所以mapper和映射不用写就可以了，如果后面有比较难的业务，sql还是要自己写，但是对于程序员来说这已经帮我们减少很多工作量了。记得去创建对应的数据库和对应实体类的表，然后去调用对应的路径就可以了。以前没用过mybatis-plus，最近用到了就稍微记录一下。3.application.yml文件。
mybatis-plus使用心得，内附demo案例源码
g200000的博客
11-10 1503
概述，前言 MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。简化JDBC操作。 需要一定基础：mybatis、spring、springmvc。 同类型工具：JPA、tk-mapper、mybatis-plus 特性 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作 强大的 CRUD 操作：内置通用 Mapper、通用
mybatis-plus-demo
07-10
mybatis-plus-demo 学习
springboot+druid+mybatis plus整合demo
12-13
springboot（1.5.9） + druid（1.0.2） + mybatis plus（2.1.4） 来自我的文章--springBoot整合druid+MyBatis Plus文章的附件代码
MyBatis-PlusDemo
10-01
Maven-MyBatis_PLUS+Spring
使用MybatisPlus+SpringMBVC完成的CUID以及分页查询实现Demo
04-08
使用MyBatisPlus的逆向工程自动生成Mapper接口,xml文件,service接口,service实现以及controller并整合Spring框架完成单表CUID和分页操作，代码讲解请参看：https://blog.csdn.net/u010158540/article/details/79833011
springboot与mybatisplus整合demo
11-24
springboot与mybatisplus整合demo，最简单的整合方式，供大家参考学习，
mybatisPlus_demo.zip
11-01
mybatisPlus_demomybatisPlus_demomybatisPlus_demomybatisPlus_demo
springboot-shiro-demo_mybatisplus_DEMO_shiro权限管理_
10-02
实现shiro权限管理，mysql
springboot-mybatisplus-demo.zip
03-10
springboot整合mybatisplus
mybatisplus 分页demo
07-14
当使用 MyBatis-Plus 进行分页查询时，你可以按照以下步骤进行操作： 1. 首先，确保你已经引入了 MyBatis-Plus 的依赖。可以在项目的 `pom.xml` 文件中添加以下依赖： ```xml <groupId>com.baomidou</groupId> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值