Mybatis-plus

一，ORM思想

对象关系映射（英语：Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。

总结: 以面向对象的方式操作数据库.
知识升华:

1. 以对象的方式实现数据库CRUD操作.
2. 要求通过某种机制将对象动态的转化为Sql,之后实现数据库操作.(自己不写Sql)

二，Mybatis优缺点

优点:
1.Mybatis 内部整合了JDBC, 简化了持久层开发.
2.Mybatis可以自动的封装结果集的对象 满足ORM中的一个条件.所以将Mybatis称之为半自动化的ORM映射框架.
3.Mybatis有缓存机制 一级缓存/二级缓存.提高用户得查询效率.
4.Mybatis支持多种类型的数据库. 整合简单.

缺点:
1.实现数据的封装 resultMap 封装复杂!!!
2.针对于单表的CRUD的操作 不够便捷. Sql都需要手写!!!
3.个别的情况下二级缓存配置不生效!!!

三，Mybatis-Plus介绍

MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

特性:
无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

简言之就是不用写xxxMapper.xml文件了！

四，使用前设置

1.导入jar包

在pom.xml文件中，删除原本的mybatis包，添加mybatis-plus包

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.3</version>
</dependency>

2.实现映射

关键词: 对象 表 属性 字段 一一映射.
说明:
1.对象名称与表的名称一一对应.
2.对象的属性与表中的字段一一对应.
注意：如果表名与对象名一致 名称可以省略
如果字段名与属性名一致,则注解可以省略

@Data
@ToString
@Accessors(chain = true) //上述3个注解是lombok的使用
@TableName("demo_user")
/**
 * 序列化接口的作用: 保证对象网络传输的有效性！！！
 */
//1.将对象与表进行关联
//规则1: 如果表名与对象名一致 名称可以省略
//规则2: 如果字段名与属性名一致,则注解可以省略
public class User implements Serializable {
    //主键自增/非空/UUID 生成唯一编号
    @TableId(type= IdType.AUTO,value="id")
    private Integer id;
    @TableField("name")   //标识属性与字段的映射
    private String name;
    private Integer age;
    private String sex;
}

3.继承特定接口

说明: MP在内部准备一个BaseMapper的接口 BaseMapper内部几乎将单表的CURD操作 都进行了编辑. 用户自己的Mapper接口可以继承即可.
注意：自己要写自己的方法时，注意不要与BaseMapper接口中方法名相同！

/**
 * 1.规则1：继承BaseMapper时，必须添加泛型对象
 * 2.规则2；自己的方法不要与接口重名
 */
//@Mapper   //将接口交给Spring管理,spring创建对象
public interface UserMapper extends BaseMapper<User> {
    //查询所有的user的用户 自己的写的方法
    List<User> ListAll();
    //Integer insert(User user); 自己写的方法
    List<User> findList(Integer age,String sex);
}

4.编辑yml文件

就是把原来的mybatis改成mybatis-plus

#Spring整合Mybatis
mybatis-plus:
  #导入映射文件
  mapper-locations: classpath:mappers/*.xml
  #开启驼峰模式
  configuration:
    map-underscore-to-camel-case: true
    #定义别名包
  type-aliases-package: com.jt.pojo

五，入门案例

1.插入数据

将数据封装成对象，调用insert实现插入效果

	@Test
    public void test01() {
        User user = new User();
        user.setName("阿富汗").setAge(40).setSex("男");
        //以对象的方式操作数据！！！
        userMapper.insert(user);
        System.out.println("入库成功");
    }

2.根据某个id查询（主键查询）

//1.查询ID查询数据库id=231 主键查询
    @Test
    public void selectById() {
        User user = userMapper.selectById(231);
        System.out.println(user);
    }

3.条件查询

数据封装成对象，构建条件构造器QueryWrapper

 	@Test
    public void select01() {
        //1.通过对象封装数据
        User user = new User();
        user.setName("小乔").setSex("女");
        //2.构建条件构造器 根据对象中不为null的属性充当where条件!
        QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);
        //3.根据条件构造器 实现数据查询
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }

逻辑运算符的使用
逻辑运算符： = eq,> gt,< lt
>= ge,<= le
!= ne
注意，只有定义构造器的类型，才可以使用链式结构

	@Test
    public void select02() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //只有在<>中指定类型，才可以使用链式结构
        queryWrapper.eq("name", "小乔")
                .eq("sex", "女");
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }
    //查询age<18 sex = 女
    @Test
    public void select03() {
        List<User> userList = userMapper.findList(18, "女");
        System.out.println(userList);
        //2.mp写法
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.lt("age", 18)
                    .eq("sex", "女");
        List<User> list = userMapper.selectList(queryWrapper);
        System.out.println(list);
    }

4.like模糊查询

select 查询 name包含 ‘君’ 字的数据
关键字：like ‘%xxx%’
left与right是指%的位置

 	@Test
    public void select04() {
        QueryWrapper queryWrapper = new QueryWrapper();
//        queryWrapper.like("name", "君");
//        List<User> userList = userMapper.selectList(queryWrapper);
        queryWrapper.likeLeft("name", "王"); 
        //[User(id=3, name=金角大王, age=3000, sex=男), User(id=4, name=银角大王, age=4000, sex=男)]
        List<User> list = userMapper.selectList(queryWrapper);
        //System.out.println(userList);
        System.out.println(list);
    }

5.排序orderby

	@Test
    public void select05() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("sex", "女")
                    .orderByDesc("age");
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }

6.拼接条件

需求:动态SQL查询，如果数据有值 则拼接where条件
如果数据为null 则不拼接where条件
语法：condition：true 则拼接where条件 false 不拼接where条件
根据name/sex 不为null的数据查询
说明：name/sex 可能有值
动态sql

	@Test
    public void select06() {
        String name = "貂蝉";
        int age = 0;
        boolean nameFlag = name == null ? false : true;
        boolean ageFlag = age == 0 ? false : true;
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(nameFlag,"name", name)
                    .eq(ageFlag,"age", age);
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }

7.批量查询

selectBatchIds只能填入列表

@Test
    public void selectIn() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("id",1,4,5,6);
        List<User> list = userMapper.selectList(queryWrapper);
        System.out.println(list);
//        List<Integer> ids = new ArrayList<>();
//        ids.add(1);
//        ids.add(4);
//        ids.add(5);
//        ids.add(6);
        Integer[] array = new Integer[]{1,4,5,6};
        //数组转化为list
        List<Integer> ids = Arrays.asList(array);
        List<User> userList = userMapper.selectBatchIds(ids);
        System.out.println(userList);
    }

8.只查询主键

查询性别为男的用户，只查询ID字段
selectObjs();只查询第一个字段(主键)
实际用途：根据业务只需要主键的查询

	@Test
    public void selectObjs() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("sex", "男");
        List<Object> ids = userMapper.selectObjs(queryWrapper);
        System.out.println(ids);
    }

9.修改数据

构建条件构造器
update(arg1,arg2)
arg1: 实体对象 set条件的数据
arg2: updateWrapper 动态拼接where条件

 	@Test
    public void testUpdate() {
        User user = new User();
        user.setId(231).setName("车臣").setAge(10).setSex("男");
        //byId 表示ID只当作where的条件
        //其他不为null的属性 当作set属性
        userMapper.updateById(user);
    }
    /**
     * 2.将name="阿富汗" 改为 name=“塔利班” age=40 sex="9/11"
     * update(arg1,arg2)
     * arg1: 实体对象 set条件的数据
     * arg2: updateWrapper 动态拼接where条件
     */
    @Test
    public void testUpdate2() {
        User user = new User();
        user.setName("塔利班").setAge(40).setSex("911");
        UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
        userUpdateWrapper.eq("name", "阿富汗");
        userMapper.update(user,userUpdateWrapper);
        System.out.println("更新成功！！！");
    }

10.删除操作同上

更多进阶操作见官网