Mybatis Plus 文档学习

前期准备

导入sql

/*
 Navicat Premium Data Transfer
 
 Source Server         : [mysql] localhost
 Source Server Type   : MySQL
 Source Server Version : 50724
 Source Host           : localhost:3306
 Source Schema         : mybatis_test
 
 Target Server Type   : MySQL
 Target Server Version : 50724
 File Encoding         : 65001
 
 Date: 02/09/2020 13:02:57
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
 
-- create database
CREATE DATABASE `mybatis_test`;
 
-- use database
USE `mybatis_test`;
 
-- ----------------------------
-- Table structure for book
-- ----------------------------
DROP TABLE IF EXISTS `book`;
CREATE TABLE `book`  (
  `book_id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '书编号',
  `book_name` varchar(400) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '书名称',
  `price` float NULL DEFAULT NULL COMMENT '书价格',
  `content` longtext CHARACTER SET utf8 COLLATE utf8_general_ci NULL COMMENT '书内容',
  PRIMARY KEY (`book_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
 
-- ----------------------------
-- Records of book
-- ----------------------------
INSERT INTO `book` VALUES (1, '《Java编程思想》', 87.5, 'Java编程圣经，每一位Java程序员必读');
INSERT INTO `book` VALUES (2, '《JavaScript高级程序设计》', 108.7, '学习JavaScript的经典书籍，非常畅销');
INSERT INTO `book` VALUES (3, '《Linux 菜鸟教程：基础篇》', 76.5, '学习Linux基础知识，Linux 入门级书籍');
INSERT INTO `book` VALUES (4, '《Linux 菜鸟教程：服务器篇》', 77, '教你在Linux中搭建各种服务器，如：Nginx、Tomcat、Apache等等');
 
-- ----------------------------
-- Table structure for book_ext
-- ----------------------------
DROP TABLE IF EXISTS `book_ext`;
CREATE TABLE `book_ext`  (
  `book_id` int(10) UNSIGNED NOT NULL COMMENT '书编号',
  `book_summary` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '书籍概述',
  `book_content` varchar(4000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '书籍内容',
  PRIMARY KEY (`book_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
 
-- ----------------------------
-- Records of book_ext
-- ----------------------------
INSERT INTO `book_ext` VALUES (1, 'Java编程思想是一本好书', '《Java编程思想(第4版)》书共22章，包括操作符、控制执行流程、访问权限控制、复用类、多态、接口、通过异常处理错误、字符串、泛型、数组、容器深入研究、Iava’UO系统、枚举类型、并发以及图形化用户界面等内容。这些丰富的内容，包含了Java语言基础语法以及不错特性，适合各个层次的Java程序员阅读，同时也是高等院校讲授面向对象程序设计语言以及Java语言的教材和参考书。\r\n从《Java编程思想(第4版)》一书获得的各项大奖以及来自世界各地的读者评论中，不难看出这是一本经典之作。本书的作者拥有多年教学经验，对c、c++以及Java语言都有独到、深入的见解，以通俗易懂及小而直接的示例解释了一个个晦涩抽象的概念');
INSERT INTO `book_ext` VALUES (2, 'JavaScript高级程序设计是一本好书', '《JavaScript高级程序设计(第3版)》是JavaScript超级畅销书的*版。ECMAScript 5和HTML5在标准之争中双双胜出，使大量专有实现和客户端扩展正式进入规范，同时也为JavaScript增添了很多适应未来发展的新特性。《JavaScript高级程序设计》这一版除增加5章全新内容外，其他章节也有较大幅度的增补和修订，新内容篇幅约占三分之一。全书从JavaScript语言实现的各个组成部分——语言核心、DOM、BOM、事件模型讲起，深入浅出地探讨了面向对象编程、Ajax与Comet服务器端通信，HTML5表单、媒体、Canvas(包括WebGL)及Web Workers、地理定位、跨文档传递消息、客户端存储(包括IndexedDB)等新API，还介绍了离线应用和与维护、性能、部署相关的*开发实践。《JavaScript高级程序设计(第3版)》附录展望了未来的API和ECMAScript Harmony规范。　');
INSERT INTO `book_ext` VALUES (3, 'Linux 菜鸟教程：基础篇是一本入门好书', '本书是*知名度的Linux入门书《鸟哥的Linux私房菜基础学习篇》的*版，全面而详细地介绍了Linux操作系统。全书分为5个部分：*部分着重说明Linux的起源及功能，如何规划和安装Linux主机；第二部分介绍Linux的文件系统、文件、目录与磁盘的管理；第三部分介绍文字模式接口shell和管理系统的好帮手shell脚本，另外还介绍了文字编辑器vi和vim的使用方法；第四部分介绍了对于系统安全重要的Linux账号的管理，以及主机系统与程序的管理，如查看进程、任务分配和作业管理；第五部分介绍了系统管理员(root)的管理事项，如了解系统运行状况、系统服务，针对登录文件进行解析，对系统进行备份以及核心的管理等。　　本书内容丰富全面，基本概念的讲解细致，深入浅出。各种功能和命令的介绍，都配以大量的实例操作和详尽的解析。本书是初学者学习Linux不可多得的一本入门好书。');
INSERT INTO `book_ext` VALUES (4, 'Linux 菜鸟教程：服务器篇是一本提升Linux的书籍', '本书是*知名度的Linux入门书《鸟哥的Linux私房菜基础学习篇》的*版，全面而详细地介绍了Linux操作系统。全书分为5个部分：*部分着重说明Linux的起源及功能，如何规划和安装Linux主机；第二部分介绍Linux的文件系统、文件、目录与磁盘的管理；第三部分介绍文字模式接口shell和管理系统的好帮手shell脚本，另外还介绍了文字编辑器vi和vim的使用方法；第四部分介绍了对于系统安全重要的Linux账号的管理，以及主机系统与程序的管理，如查看进程、任务分配和作业管理；第五部分介绍了系统管理员(root)的管理事项，如了解系统运行状况、系统服务，针对登录文件进行解析，对系统进行备份以及核心的管理等。　　本书内容丰富全面，基本概念的讲解细致，深入浅出。各种功能和命令的介绍，都配以大量的实例操作和详尽的解析。本书是初学者学习Linux不可多得的一本入门好书。');
 
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `user_id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '用户ID',
  `name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户名',
  `sex` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '性别',
  `age` int(11) UNSIGNED NULL DEFAULT NULL COMMENT '年龄',
  `face` blob NULL COMMENT '用户头像',
  `salary` double NULL DEFAULT NULL COMMENT '薪水',
  `borthday` date NULL DEFAULT NULL COMMENT '生日',
  PRIMARY KEY (`user_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
 
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'Tom', '男', 28, NULL, 7800, '1902-06-04');
INSERT INTO `user` VALUES (2, '张小凡', '男', 30, NULL, 8670, '1990-08-22');
INSERT INTO `user` VALUES (3, '叶星云', '女', 31, NULL, 6890, '1989-02-27');

-- ----------------------------
-- Table structure for user_book
-- ----------------------------
DROP TABLE IF EXISTS `user_book`;
CREATE TABLE `user_book`  (
  `user_id` int(11) NOT NULL COMMENT '用户编号',
  `book_id` int(11) NOT NULL COMMENT '书编号',
  `cjsj` datetime(0) NULL DEFAULT NULL COMMENT '插入日期',
  PRIMARY KEY (`user_id`, `book_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user_book
-- ----------------------------
INSERT INTO `user_book` VALUES (1, 1, '2020-09-02 12:53:59');
INSERT INTO `user_book` VALUES (1, 2, '2020-09-02 12:53:59');
INSERT INTO `user_book` VALUES (1, 4, '2020-09-02 12:53:59');
INSERT INTO `user_book` VALUES (2, 2, '2020-09-02 12:53:59');
INSERT INTO `user_book` VALUES (3, 3, '2020-09-02 12:53:59');
INSERT INTO `user_book` VALUES (3, 4, '2020-09-02 12:53:59');

-- ----------------------------
-- Table structure for user_contact
-- ----------------------------
DROP TABLE IF EXISTS `user_contact`;
CREATE TABLE `user_contact`  (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '联系方式ID',
  `user_id` int(11) NOT NULL COMMENT '用户编号',
  `usage` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用途描述',
  `number` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '电话号码',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user_contact
-- ----------------------------
INSERT INTO `user_contact` VALUES (1, 1, '手机号码', '15787782291');
INSERT INTO `user_contact` VALUES (2, 2, '家庭号码', '028-82234543');
INSERT INTO `user_contact` VALUES (3, 3, '工作号码', '028-78675599');

-- ----------------------------
-- Function structure for func_updateUserName
-- ----------------------------
DROP FUNCTION IF EXISTS `func_updateUserName`;
delimiter ;;
CREATE FUNCTION `func_updateUserName`(`userId` int,`userName` varchar(100))
RETURNS int(11)
BEGIN
declare tname varchar(100);
update `user` set `name`=userName where user_id=userId;
select `name` into tname from `user` where user_id=userId;
if tname=userName then
  return 1;
else
  return 0;
end if;
END
;;
delimiter ;

-- ----------------------------
-- Procedure structure for proc_getUserAge
-- ----------------------------
DROP PROCEDURE IF EXISTS `proc_getUserAge`;
delimiter ;;
CREATE PROCEDURE `proc_getUserAge`(INOUT `userId` int)
BEGIN
select age into userId from `user` where user_id=userId;
END
;;
delimiter ;

-- ----------------------------
-- Procedure structure for proc_getUserName
-- ----------------------------
DROP PROCEDURE IF EXISTS `proc_getUserName`;
delimiter ;;
CREATE PROCEDURE `proc_getUserName`(IN `userId` int,OUT `userName` varchar(100))
BEGIN
select `name` into userName from `user` where user_id=userId;
END
;;
delimiter ;

-- ----------------------------
-- Procedure structure for proc_updateUserName
-- ----------------------------
DROP PROCEDURE IF EXISTS `proc_updateUserName`;
delimiter ;;
CREATE PROCEDURE `proc_updateUserName`(IN `userId` int,IN `userName` varchar(100))
BEGIN
update `user` set `name`=userName where user_id=userId;
END
;;
delimiter ;

SET FOREIGN_KEY_CHECKS = 1;

项目初始化

group 包名

Artifact 项目

然后配置yml

server:
  port: 8080
spring:
 application:
    #应用的名称，可选
   name:
 datasource:
   druid:
     driver-class-name: com.mysql.cj.jdbc.Driver
     url: jdbc:mysql://localhost:3306/mybatis_test?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
     username: root
     password: aa123456
mybatis-plus:
 configuration:
    #在映射实体或者属性时，将数据库中表名和字段名中的下划线去掉，按照驼峰命名法映射
   map-underscore-to-camel-case: true
   log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
 global-config:
   db-config:
     id-type: ASSIGN_ID
​

测试配置的对不对

package com.shuang.learnplus;
​
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
​
import javax.sql.DataSource;
import java.sql.SQLException;
​
@SpringBootTest
class LearnplusApplicationTests {
​
    @Autowired
    private DataSource dataSource;
​
    @Test
    void contextLoads() throws SQLException {
        System.out.println(dataSource.getConnection());
   }
​
}
​

测试成功！！

一个demo

整体的文件分类

Book.java

@Data
public class Book {
​
    private int bookId;
    private String bookName;
    private int price;
    private String content;
​
}
​

BookMapper.java

​
@Mapper
public interface BookMapper extends BaseMapper<Book> {
}
​

BookService.java

public interface BookService extends IService<Book> {
}
​

BookServiceImpl.java

@Service
public class BookServiceImpl extends ServiceImpl<BookMapper, Book> implements BookService {
}

BookTest.java

@SpringBootTest
@RunWith(SpringRunner.class)
public class BookTest {
​
    @Autowired
    BookMapper bookMapper;
​
    @Test
    public void test()
   {
        bookMapper.insert(new Book(5,"",1,""));
   }
​
}
​

BaseMapper封装的CRUD

alt + 7 查看（ps，自己好好看一看感觉还行，没有难懂的）

insert

//T是泛型 entity就是实体
int insert(T entity);

select

//T 返回的一个类，通过id来查看
T selectById(Serializable id);
​
//返回List 因为ids是多个的
List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);
​
//不能new map，因为map是一个接口，用HashMap，HashMap继承AbstractMap，AbstractMap实现Map接口
List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);
​
//通过条件选择器查询一个数据
T selectOne(@Param("ew") Wrapper<T> queryWrapper);
​
//查询出个数
Integer selectCount(@Param("ew") Wrapper<T> queryWrapper);
​
//List
List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);
​
//通过map查返回List
List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);
​
//这个就不需要知道实体了，Object就可以
List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);

Select分页查询

//下面两个都是分页的操作了
<E extends IPage<T>> E selectPage(E page, @Param("ew") Wrapper<T> queryWrapper);
​
<E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param("ew") Wrapper<T> queryWrapper);

//首先要配置分页
@Configuration
public class MybatisPlusConfig {
​
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor()
   {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
   }
​
}

//测试代码
    @Test
    public void Page()
   {
        LambdaQueryWrapper<Book> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.ne(Book::getBookId,3);
​
        Page<Book> page = new Page<>(1,2);
​
        Page page1 = bookMapper.selectPage(page, queryWrapper);
        System.out.println( page1.getSize());
        System.out.println( page1.getTotal());
        System.out.println(page1);
​
   }

delect

//通过id删除
int deleteById(Serializable id);
​
//通过Map删除
int deleteByMap(@Param("cm") Map<String, Object> columnMap);
​
//Wrapper条件构造器删除
int delete(@Param("ew") Wrapper<T> queryWrapper);
​
//删除多个
int deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);

update

//直接传入实体就可以了
int updateById(@Param("et") T entity);
​
// 根据 whereEntity 条件，更新记录
int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

Service 封装的CRUD

MyBatis Plus 提供了通用的 Mapper 接口（即 BaseMapper 接口），该接口对应我们的 DAO 层。在该接口中，定义了我们常见的方法签名，这样就可以方便我们对表进行操作。例如：查询（select）、插入（insert）、更新（update）和删除（delete）操作。

除了 BaseMapper 接口，MyBatis Plus 还提供了 IService 接口，该接口对应 Service 层。MyBatis Plus 的通用 Service CRUD 实现了 IService 接口，进一步封装 CRUD。为了避免与 BaseMapper 中定义的方法混淆，该接口使用 get（查询单行）、remove（删除）、list（查询集合）和 page（分页）前缀命名的方式进行区别。

同样的方法 alt + 7 查看方法

save

参数说明

• entity：实体对象

• entityList：实体对象集合

• batchSize：插入批次数量，即每一个批次最大插入的数量

default boolean save(T entity)
//这个问一个问题，为什么方法前面有defalut？
​
//解答
default修饰方法只能在接口中使用，在接口中被default标记的方法为普通方法，可以直接写方法体。
在jdk1.8以前大多都是用abstract类来实现添加的方法，解决这个问题直接用default
​
​
boolean saveBatch(Collection<T> entityList, int batchSize);
 
​

测试方法

    @Test
    public void save()
   {
        //插入一个
        /*boolean save = bookService.save(new Book(6, "4", 123, "546"));
        System.out.println(save);*/
​
        //批量插入
        /*List<Book> books = new ArrayList<>();
        books.add(new Book(7,"45",7,"98"));
        books.add(new Book(8,"45",7,"98"));
        bookService.saveBatch(books);*/
​
        //批量插入
        /*List<Book> books = new ArrayList<>();
        books.add(new Book(11,"45",7,"98"));
        books.add(new Book(12,"45",7,"98"));
        books.add(new Book(13,"45",7,"98"));
        bookService.saveBatch(books,2);*/
​
   }

SaveOrUpdate

参数说明

• entity：实体对象

• updateWrapper：实体对象封装操作类 UpdateWrapper

• entityList：实体对象集合

• batchSize：插入批次数量

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

但是save和update不分开呢，其实是不方便的，save和update底层原理都是相同的，无非就是得先查一下如果有这个数据就调用update，没有的话就调用save方法

//伪代码
if(user.getId() == null)
{
 save(user);
}
else
{
 update(user);
}

Delect

参数说明

id：主键ID

queryWrapper：条件

Map<String, Object> columnMap：键值对查询

idList：List批量删除

// 根据 entity 条件，删除记录
default boolean remove(Wrapper<T> queryWrapper)
// 根据 ID 删除
default boolean removeById(Serializable id)
// 根据 columnMap 条件，删除记录
default boolean removeByMap(Map<String, Object> Map<String, Object> columnMap)
// 删除（根据ID 批量删除）
default boolean removeByIds(Collection<? extends Serializable> idList)

//测试类

    @Test   
    public void delect()
   {
        List<Integer> list = Arrays.asList(2,3,4);
        bookService.removeByIds(list);
   }

Update

参数说明：

• updateWrapper：实体对象封装操作类 UpdateWrapper

• entity：实体对象

• entityList：实体对象集合

• batchSize：更新批次数量

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereEntity 条件，更新记录
boolean update(T entity, Wrapper<T> updateWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

其实都差不多，不赘述了

获取单条数据

参数说明：

• id：数据库主键 ID

• queryWrapper：实体对象封装操作类 QueryWrapper

• throwEx：有多个 result 是否抛出异常

• entity：实体对象

• mapper：转换函数

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, ``boolean` `throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? ``super` `Object, V> mapper);

    @Test
    public void selectOne()
   {
        System.out.println("========id=======");
        Book byId = bookService.getById(8);
        System.out.println(byId);
​
        System.out.println("==========wapper=========");
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("book_id",8);
        Book one = bookService.getOne(queryWrapper);
        System.out.println(one);
​
        System.out.println("========getMap==========");
        Map map = bookService.getMap(queryWrapper);
        System.out.println(JSONObject.toJSONString(map));
​
        System.out.println("========getObj ========");
        bookService.getObj(queryWrapper, new Function<Object, Book>() {
            @Override
            public Book apply(Object o) {
                System.out.println(JSON.toJSONString(o));
                return null;
           }
       });
   }

获取多条数据

参数说明：

• queryWrapper：实体对象封装操作类 QueryWrapper

• idList：主键ID列表

• columnMap：表字段 map 对象

• mapper：转换函数

// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

分页

default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper) {
        return this.getBaseMapper().selectPage(page, queryWrapper);
   }
​
    default <E extends IPage<T>> E page(E page) {
        return this.page(page, Wrappers.emptyWrapper());
   }
​

计数

default int count() {
        return this.count(Wrappers.emptyWrapper());
   }
​
    default int count(Wrapper<T> queryWrapper) {
        return SqlHelper.retCount(this.getBaseMapper().selectCount(queryWrapper));
   }

分页计数没啥好说的，就是直接调的BaseMapper的方法

链式查询

default QueryChainWrapper<T> query()

就是简化了，不用QueryMapper就可以了

    @Test
    public void chain()
   {
        String book_name = "45";
        List<Book> list = bookService.query()
               .eq("book_name", book_name)
               .gt("book_id", 5)
               .lt("book_id", 8)
               .list();
        System.out.println(list);
​
   }

条件构造器学习

QueryWrapper其实可以理解成一个放查询条件的盒子，我们把查询条件放在里面，他就会自动按照对应的条件进行查询数据，回想我们学sql的时候查询的分类，可以分为简单查询，条件查询，模糊查询，分组查询，排序查询。

condition 写条件

allEq

在 MyBatis Plus 中定义了多个 allEq 方法，该方法将把参数 Map 中的参数使用 and 进行连接。假如我们传递如下 Map 参数给 allEq 方法：

eq ，ne

相同，不相同

gt、ge、lt 和 le

大于，大于等于，小于，小于等于

between(``boolean` `condition, R column, Object val1, Object val2)

like

like(``boolean` `condition, R column, Object val)
notLike(boolean condition, R column, Object val)
likeLeft(boolean condition, R column, Object val)
wrapper.likeRight(boolean condition, R column, Object val)

isNull,isNotNull 字段在，字段不在

in 和 notIn

inSql 和 notInSql （子查询）

@Test
public void query1()
{
LambdaQueryWrapper<Book> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.inSql(Book::getBookId,"select book_id from book_ext where book_content like '%java%'");
​
List<Book> list = bookService.list(queryWrapper);
System.out.println(list);
}

这个可以链接表查询了

排序 order by

last 查询数据限制多少条

nested 嵌套SQL

@Test
public void query2()
{
LambdaQueryWrapper<Book> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(Book::getBookId,"1");
queryWrapper.nested(new Consumer<LambdaQueryWrapper<Book>>() {
  @Override
  public void accept(LambdaQueryWrapper<Book> bookLambdaQueryWrapper) {
      bookLambdaQueryWrapper.gt(Book::getBookId,3);
 }
});
​
List<Book> list = bookService.list(queryWrapper);
System.out.println(list);
}

group by

QueryWrapper<Ticket> queryWrapper = new QueryWrapper<>();
queryWrapper.select("day_id","sum(cnt) as cnt","sum(round) as round");
queryWrapper.groupBy("day_id");

QueryWrapper 的列名匹配使用的是 “数据库中的字段名(一般是下划线规则)” LambdaQueryWrapper 的列名匹配使用的是“[Lambda](https://so.csdn.net/so/search?q=Lambda&spm=1001.2101.3001.7020的语法，偏向于对象”

注解

@TableName

实体类和表名是一一对应的，如果对应不上了，那就用TableName

@TableId

标识主键

Value = “”

指定对应的属性

Type

@TableField

是注解非主键，跟表一一对应

@TableLogic

逻辑删除，如果是0，删除后变为1，能在数据库找到，假删除

原文地址：http://www.cnblogs.com/shuangshuangzi/p/16796548.html