Mybatis-Flex实战
一，依赖引入
mysql
mysql-connector-java
8.0.12
org.projectlombok
lombok
com.mybatis-flex
mybatis-flex-spring-boot-starter
1.5.4
com.zaxxer
HikariCP
二，插件引入
这里的插件是为了，我们能在代码中直接引入Def类，进行操作，如果没有这个类，需要我们手动去target的generated-sources中，把代码设置为root根目录下才可以，为了方便，我们直接用插件即可
org.apache.maven.plugins
maven-compiler-plugin
3.8.1
1.8
1.8
org.projectlombok
lombok
com.mybatis-flex
mybatis-flex-processor
三，实际操作
在需要查询的类中引入：
import static com.mybatis.flex.entity.table.PersonTableDef.PERSON;
1.新增操作：
这里要注意的是，默认的新增方法，没有忽略null值，比如你的实体类没有设置createtime的值，那在插入语句中，就会把createtime设置为null，但是我们需要通过填充手段设置它的值，所以，这块建议使用insertSelective,会帮助我们自动忽略null值，当然也可以直接使用insert(entity,ignoreNulls)
insert(entity)：插入实体类数据，不忽略null值。insertSelective(entity)：插入实体类数据，但是忽略null的数据，只对有值的内容进行插入。这样的好处是数据库已经配置了一些默认值，这些默认值才会生效。insert(entity, ignoreNulls)：插入实体类数据。insertWithPk(entity)：插入带有主键的实体类，不忽略null值。insertSelectiveWithPk(entity)：插入带有主键的实体类，忽略null值。insertWithPk(entity, ignoreNulls)：带有主键的插入，此时实体类不会经过主键生成器生成主键。insertBatch(entities)：批量插入实体类数据，只会根据第一条数据来构建插入的字段内容。insertBatch(entities, size)：批量插入实体类数据，按 size 切分。
2.删除操作
deleteById(id)：根据主键删除数据。如果是多个主键的情况下，需要传入数组，例如：new Integer[]{100,101}。deleteBatchByIds(ids)：根据多个主键批量删除数据。deleteBatchByIds(ids, size)：根据多个主键批量删除数据。deleteByMap(whereConditions)：根据 Map 构建的条件来删除数据。deleteByCondition(whereConditions)：根据查询条件来删除数据。deleteByQuery(queryWrapper)：根据查询条件来删除数据。
3.修改操作
1.简单更新
update(entity)：根据主键来更新数据，若实体类属性数据为null，该属性不会新到数据库。update(entity, ignoreNulls)：根据主键来更新数据到数据库。updateByMap(entity, whereConditions)：根据 Map 构建的条件来更新数据。updateByMap(entity, ignoreNulls, whereConditions)：根据 Map 构建的条件来更新数据。updateByCondition(entity, whereConditions)：根据查询条件来更新数据。updateByCondition(entity, ignoreNulls, whereConditions)：根据查询条件来更新数据。updateByQuery(entity, queryWrapper)：根据查询条件来更新数据。updateByQuery(entity, ignoreNulls, queryWrapper)：根据查询条件来更新数据。- ~
updateNumberAddByQuery(fieldName, value, queryWrapper)：执行类似update table set field = field + 1 where ...的场景。~ - ~
updateNumberAddByQuery(column, value, queryWrapper)：执行类似update table set field = field + 1 where ...的场景。~ - ~
updateNumberAddByQuery(fn, value, queryWrapper)：执行类似update table set field = field + 1 where ...的场景。~
2.部分字段更新(比如希望吧某些字段的值设置为null)
Account account = UpdateEntity.of(Account.class, 100);
//Account account = UpdateEntity.of(Account.class);
//account.setId(100);
account.setUserName(null);
account.setAge(10);
accountMapper.update(account);3.部分字段更新增强，比如希望把某个字段在原来的基础上加一
//比如这样的sql:
update tb_account
set user_name = ?, age = age + 1 where id = ?
//那么我们需要这样写
Account account = UpdateEntity.of(Account.class, 100);
account.setUserName(null);
// 通过 UpdateWrapper 操作 account 数据
UpdateWrapper wrapper = UpdateWrapper.of(account);
wrapper.setRaw("age", "age + 1")
accountMapper.update(account);
//或者通过def类
Account account = UpdateEntity.of(Account.class, 100);
account.setUserName("Michael");
// 通过 UpdateWrapper 操作 account 数据
UpdateWrapper wrapper = UpdateWrapper.of(account);
wrapper.set(ACCOUNT.AGE, ACCOUNT.AGE.add(1))
accountMapper.update(account);
//或者
Account account = UpdateEntity.of(Account.class, 100);
account.setUserName("Michael");
// 通过 UpdateWrapper 操作 account 数据
UpdateWrapper wrapper = UpdateWrapper.of(account);
wrapper.set(ACCOUNT.AGE, select().from(...))
accountMapper.update(account);4.查询操作
1.简单查询
这几个就没啥说的了，操作很简单
selectOneById(id)：根据主键查询数据。selectOneByMap(whereConditions)：根据 Map 构建的条件来查询数据。selectOneByCondition(whereConditions)：根据查询条件查询数据。selectOneByQuery(queryWrapper)：根据查询条件来查询 1 条数据。selectListByIds(ids)：根据多个主键来查询多条数据。selectListByMap(whereConditions)：根据 Map 来构建查询条件，查询多条数据。selectListByMap(whereConditions, count)：根据 Map 来构建查询条件，查询多条数据。selectListByCondition(whereConditions)：根据查询条件查询多条数据。selectListByCondition(whereConditions, count)：根据查询条件查询多条数据。selectListByQuery(queryWrapper)：根据查询条件查询数据列表。selectListByQuery(queryWrapper, consumers)：根据查询条件查询数据列表。
2.游标查询
众所周知，当一次查询数据量太多时，如果一下把系统内存打满，会出现内存溢出的问题，例如在大数据量的excel导出时，就很有必要使用这个了
Cursor selectCursorByQuery(QueryWrapper queryWrapper);
使用实例如下：
Db.tx(() -> {
Cursor accounts = accountMapper.selectCursorByQuery(query);
for (Account account : accounts) {
System.out.println(account);
}
return true;
}); 以上的示例中，数据库并不是把所有的数据一次性返回给应用，而是每循环 1 次才会去数据库里拿 1 条数据，这样，就算有 100w 级数据，也不会导致我们应用内存溢出，同时，在 for 循环中， 我们可以随时终止数据读取。
但由于游标查询是在 for 循环的时候，才去数据库拿数据。因此必须保证 selectCursorByQuery 方法及其处理必须是在事务中进行，才能保证其链接并未与数据库断开。
3.分页查询
单表分页
paginate(pageNumber, pageSize, queryWrapper)：分页查询。paginate(pageNumber, pageSize, whereConditions)：分页查询。
多表联查
paginateAs(pageNumber, pageSize, queryWrapper, asType)：分页查询。paginateAs(page, queryWrapper, asType)：分页查询。
4.多表联查
其实有很多种方式，我这里只举例用join的方式，简单的场景可以用flex，我觉得复杂的sql，大家还是写xml来的比较快
1.字段一一对应
1、定义 ArticleDTO 类，ArticleDTO 里定义 tb_account 表的字段映射。
public class ArticleDTO {
private Long id;
private Long accountId;
private String title;
private String content;
//以下用户相关字段
private String userName;
private int age;
private Date birthday;
}2、使用 QueryWrapper 构建 left join 查询，查询结果通过 ArticleDTO 类型接收。
QueryWrapper query = QueryWrapper.create()
.select(ARTICLE.ALL_COLUMNS)
.select(ACCOUNT.USER_NAME,ACCOUNT.AGE,ACCOUNT.BIRTHDAY)
.from(ARTICLE)
.leftJoin(ACCOUNT).on(ARTICLE.ACCOUNT_ID.eq(ACCOUNT.ID))
.where(ACCOUNT.ID.ge(0));
List results = mapper.selectListByQueryAs(query, ArticleDTO.class);
System.out.println(results); 2.字段名不一致
public class ArticleDTO {
private Long id;
private Long accountId;
private String title;
private String content;
//以下用户字段 和 用户表定义的列不一致，表定义的列为 user_name
private String authorName;
private int authorAge;
private Date birthday;
}那么， QueryWrapper 需要添加 as，修改如下：
QueryWrapper query = QueryWrapper.create()
.select(ARTICLE.ALL_COLUMNS)
.select(ACCOUNT.USER_NAME.as(ArticleDTO::getAuthorName)
,ACCOUNT.AGE.as(ArticleDTO::getAuthorAge)
,ACCOUNT.BIRTHDAY
)
.from(ARTICLE)
.leftJoin(ACCOUNT).on(ARTICLE.ACCOUNT_ID.eq(ACCOUNT.ID))
.where(ACCOUNT.ID.ge(0));
List results = mapper.selectListByQueryAs(query, ArticleDTO.class);
System.out.println(results); 3.一对多自动映射
public class AccountVO {
private Long id;
private String userName;
private int age;
//账户拥有的 图书列表
private List books;
} List bookVos = QueryChain.of(accountMapper)
.select(
ACCOUNT.ID,
ACCOUNT.USER_NAME,
ACCOUNT.AGE,
BOOK.TITLE,
BOOK.CONTENT,
)
.from(ACCOUNT)
.leftJoin(BOOK).on(ACCOUNT.ID.eq(BOOK.ACCOUNT_ID))
.where(ACCOUNT.ID.ge(100))
.listAs(AccountVO.java); 如果外边的一层和里边的一层有的字段名相同，flex帮我们设置了别名，同样会帮我们自动映射
public class AccountVO {
private Long id;
private String name;
private int age;
//账户拥有的 图书列表
private List book;
} public class Book {
private Long id;
private Long accountId;
private String name;
}在以上的嵌套定义中， AccountVO 以及 Book 都包含了 id 和 name 的定义，假设我们查询的方法如下：
List bookVos = QueryChain.of(accountMapper)
.select(
ACCOUNT.ID,
ACCOUNT.NAME,
ACCOUNT.AGE,
BOOK.ID,
BOOK.NAME,
)
.from(ACCOUNT)
.leftJoin(BOOK).on(ACCOUNT.ID.eq(BOOK.ACCOUNT_ID))
.where(ACCOUNT.ID.ge(100))
.listAs(AccountVO.java); 其执行的 SQL 如下：
select tb_account.id, tb_account.name, tb_account.age,
tb_book.id as tb_book$id, -- Flex 发现有重名时，会自动添加上 as 别名
tb_book.name as tb_book$name -- Flex 发现有重名时，会自动添加上 as 别名
from tb_account
left join tb_book on tb_account.id = tb_book.account_id
where tb_account.id >= 100此时，查询的数据可以正常映射到 AccountVO 类。
注意，在 QueryWrapper 的
select(...)中，MyBatis-Flex 在 多表查询 的情况下，且有相同的字段名时，MyBatis-Flex 内部会主动帮助用户添加上 as 别名，默认为：表名$字段名
注：如果复杂的嵌套查询，有字段名是相同的，必须指定具体的查询字段，不可以使用*查询
5. 批量操作
在 MyBatis-Flex 中，提供了许多批量操作（批量插入、批量更新等）的方法，当有多个方法的时候，会经常导致误用的情况
BaseMapper.insertBatch 方法
通过 BaseMapper.insertBatch 执行时，会通过 accounts 去组装一个如下的 SQL：
insert into tb_account(id,nickname, .....) values
(100,"miachel100", ....),
(101,"miachel101", ....),
(102,"miachel102", ....),
(103,"miachel103", ....),
(104,"miachel104", ....),
(105,"miachel105", ....);这种有一个特点：在小批量数据执行插入的时候，效率是非常高；但是当数据列表过多时，其生成的 SQL 可能会非常大， 这个大的 SQL 在传输和执行的时候就会变得很慢了。
因此，BaseMapper.insertBatch 方法只适用于在小批量数据插入的场景，比如 100 条数据以内
Db.executeBatch 方法
Db.executeBatch 可以用于进行批量的插入、修改和删除，以下是使用 Db.executeBatch 进行批量插入的示例：
List accounts = ....
Db.executeBatch(accounts.size(), 1000, AccountMapper.class, (mapper, index) -> {
Account account = accounts.get(index);
mapper.insert(account);
}); 大概意思就是，如果使用basemapper中的insertbatch，那么就要用上边的方法，如果使用Iservice中的方法，就不需要自己包装方法了，直接使用即可，因为Iservice中的批量新增，Flex已经使用它，帮我们封装过了
6.链式操作(flex最值得推荐的写法)
1.查询列表
List articles = articleService.queryChain()
.select(ARTICLE.ALL_COLUMNS)
.from(ARTICLE)
.where(ARTICLE.ID.ge(100))
.list();
//或者如果不在service，可以通过mapper获取
List articles = QueryChain.of(mapper)
.select(ARTICLE.ALL_COLUMNS)
.from(ARTICLE)
.where(ARTICLE.ID.ge(100))
.list(); 2.查询单个
List articles = articleService.queryChain()
.select(ARTICLE.ALL_COLUMNS)
.from(ARTICLE)
.where(ARTICLE.ID.ge(100))
.one(); 3.修改
UpdateChain.of(Account.class)
.set(Account::getUserName, "张三")
.setRaw(Account::getAge, "age + 1")
.where(Account::getId).eq(1)
.update();
//或者
//更新数据
UpdateChain.of(Account.class)
.set(Account::getAge, ACCOUNT.AGE.add(1))
.where(Account::getId).ge(100)
.and(Account::getAge).eq(18)
.update();