mybatisplus的使用

导入jar包

<!--spring整合mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>

编辑POJO

@Data   //生成get/set/toString/equals
@Accessors(chain=true)  //表示链式加载  重写set方法,将对象返回
@NoArgsConstructor      //添加无参构造   为以后框架的使用做准备
@AllArgsConstructor     //全部参数的构造方法.
@TableName      //(value="user")//定义对象与表映射关系 编辑表名
                        //如果表名与对象的名称一致,则可以省略不写.
public class User {
    @TableId(type=IdType.AUTO)  //标识主键 主键自增.
    private Integer id;
    //@TableField(value="name") //如果字段的名称与属性名称一致(包含驼峰规则),则可以省略
    private String name;        //字段与属性一一映射
    private Integer age;        //user_name  userName
    private String sex;
    
}

继承公共的接口

//该接口需要交给Spring容器管理
//BaseMapper中的泛型标识操作的具体的表 千万不要写错.
public interface UserMapper extends BaseMapper<User>{
    
    //准备查询全部用户信息的方法
    List<User> findAll();
}

MybatisPlusAPI

@Test
    public void test01() {
        //一般都是用对象类型进行定义
        Integer[] ids = {1,3,5,9};
        //数组怎么转化为集合??
        List idList =  Arrays.asList(ids);
        //List idList =  org.assertj.core.util.Arrays.asList(ids);
        /*List<Integer> idList = new ArrayList<>();
        idList.add(1);
        idList.add(3);
        idList.add(5);
        idList.add(9);*/
        List<User> userList = userMapper.selectBatchIds(idList);
        System.out.println(userList);
    }
    
    /**
     * 根据指定的条件查询
     * 查询name="王昭君" sex=女的用户 默认使用and方式进行关联
     * 需要将查询的字段与值封装到MAP中
     * SELECT id,name,age,sex FROM user WHERE sex = ? AND name = ?
     */
    @Test
    public void test02() {
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("name", "王昭君");   //默认使用=号
        columnMap.put("sex", "女");
        List<User> userList = userMapper.selectByMap(columnMap);
        System.out.println(userList);
    }
    
    /**
     * 查询age>18  and sex=男
     *逻辑运算符   > gt,  < lt, = eq,  >= ge, <= le
     */
    @Test
    public void test03() {
        //定义条件构造器  负责拼接where条件的
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age", 18)
                    .eq("sex", "男");
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }
    
    
    /**
     * name like %精% and sex="女"
     *   以精字结尾
     * name like %精
     *             精%
     */
    @Test
    public void test04() {
        //定义条件构造器  负责拼接where条件的
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.likeLeft("name", "精")
                    .eq("sex", "女");
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }
    
    
    /**
     * 条件:查询年龄在18-35之间的女性用户.
     * sql: select * from user where age > 18 and age < 35
     */
    @Test
    public void test05() {
        //定义条件构造器  负责拼接where条件的
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.between("age", 18, 35)
                    .eq("sex", "女");
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }
    
    
    /**
     * 条件:查询年龄大于100岁的,并且按照年龄降序排列,如果年龄相同按照Id降序排列.
     *sql中的排序默认根据id升序排列
     *SELECT id,name,age,sex FROM user WHERE (age > ?) ORDER BY age DESC,id DESC 
     */
    @Test
    public void test06() {
        //定义条件构造器  负责拼接where条件的
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age",100)
                    .orderByDesc("age","id");
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }
    
    
    /**
     * 子查询: insql
     * 条件: 查询age < 100岁的用户,并且性别与name="孙尚香"的性别相同的的用户数据.
     *sql: SELECT * FROM USER WHERE age < 100 AND 
     *     sex IN(SELECT sex FROM USER WHERE NAME="孙尚香")
        
     */
    @Test
    public void test07() {
        //定义条件构造器  负责拼接where条件的
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        String name = "'孙尚香'";
        queryWrapper.lt("age", 100)
                .inSql("sex", "select sex from user where name="+name);
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }
    
    
    /**
     * 需求:有时查询可能不需要查询全部字段,会挑选其中几个进行查询.
     *1.指定字段进行查询
     * 查询age>100岁 只查询Id,name字段
     *
     *2.只返回查询的字段
     */
    @Test
    public void test08() {
        //定义条件构造器  负责拼接where条件的
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("id","name").gt("age", 100);
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
        
        //只想返回特定的字段
        List<Map<String,Object>> mapList = userMapper.selectMaps(queryWrapper);
        System.out.println(mapList);
        
        //只返回第一列字段的值  主键值
        List<Object> list = userMapper.selectObjs(queryWrapper);
        System.out.println(list);
    }
    
    /**
     *   根据属性中不为null的元素查询数据
     * condition:布尔类型的判断 只有当判断为true时,条件生效
     */
    @Test
    public void test09() {
        String name = "黑熊精";
        String sex = "男";
        //定义条件构造器  负责拼接where条件的
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //当name属性不为null的时候会动态的拼接name属性值
        queryWrapper.eq(!StringUtils.isEmpty(name), "name", name)
                    .eq(!StringUtils.isEmpty(sex), "sex", sex);
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }
    
    /**
     * 根据对象中不为null的属性进行查询
     */
    @Test
    public void test10() {
        User user = new User();
        user.setName("黑熊精")
            .setSex("男");
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>(user);
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }
    
    //根据主键查询
    @Test
    public void test11() {
        
        User user = userMapper.selectById(1111);
        //根据条件返回一个对象信息
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id", "3");
        User user2 = userMapper.selectOne(queryWrapper);
        System.out.println(user);
        System.out.println(user2);
    }
    
    
    /**
     * MP的删除用法
     *  案例:
     *      1.将name字段值为null的数据进行 
     *      2.将name字段信息 无名英雄永垂不朽删除
     *  
     */
    @Test
    public void test12() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        //queryWrapper.isNull("name");
        queryWrapper.eq("name", "无名英雄永垂不朽");
        userMapper.delete(queryWrapper);
        System.out.println("数据库删除成功!!!!");
    }
    
    
    /**
     * 数据库更新操作
     * 
     * 1.将大日如来的年龄改为10001 性别 改为男
     * entity: 数据修改后的值使用对象封装
     * updateWrapper: 修改的条件构造器
     * 
     * 
     */
    @Test
    public void test13() {
        User user = new User();
        user.setAge(10001).setSex("男");
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("name","大日如来");
        userMapper.update(user, updateWrapper);
    }
    
    
    //2.根据主键1915 将name改为"人民英雄" age=100   性别=男/女
    //对象中只有主键充当where条件,其他的字段信息充当set条件
    @Test
    public void test14() {
        User user = new User();
        user.setId(1915)
            .setName("人民英雄")
            .setAge(100)
            .setSex("男/女");
        
        userMapper.updateById(user);
    }
}