//根据 ID 修改//entity：实体对象intupdateById(@Param("et")T entity);
测试：
继续到LagouMpSpringbootApplicationTests类里面加上对应的方法：
/*
测试根据id进行修改
*/@TestpublicvoidtestUpdateById(){User user =newUser();
user.setId(6l);//主键，这里是where后面的条件
user.setAge(30);//更新的字段，这里是set后面的条件//上面针对于更新（update）//将id为6的age修改成30int i = userMapper.updateById(user);System.out.println(i);//符合不设置，不加字段}//注意：这里有个细节，我们是怎么确定，对应的where后面的字段的，答：根据顺序来//顺序是：策略设置者-id数-null//后面大多数都是这个顺序，除了特别的会使得报错外（如AR的添加和更新并存的insertOrUpdate方法）//即我们给那个字段操作了策略，那么后面的就是那个字段，比如这里就是id//那么同样的，如果给name设置该策略（该策略是自增策略，所以只会第一个生效），那么后面的就是name//如果都没有设置，那么默认为id变量，没有id变量，默认是null字段，而默认是null时，那么自然的，是必定失败的//因为我们虽然设置了值，但是获得值时，一般需要对应的get方法或者赋值，具体看对应的61章博客介绍的#{}//而没有null这个变量，因为不能创建，自然报错
/*
根据wrapper进行删除
*/@TestpublicvoidtestDelete(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();//操作where后面的条件
objectQueryWrapper.eq("name","33").eq("age",18);// User user = new User();// user.setName("33");// user.setAge(18);// QueryWrapper<User> objectQueryWrapper = new QueryWrapper<>(user);// //这样也可，相当于objectQueryWrapper.eq("name","33").eq("age",18); //执行类似的eq方法或者gt方法，通常会返回调用者objectQueryWrapper，使得可以继续操作// //只是对应的字段会操作特殊小写，因为是类int i = userMapper.delete(objectQueryWrapper);System.out.println(i);}//我们可以发现，为什么明明是调用方法，为什么会使得对应的MappedStatement类信息发生了改变（字段变化）//可能是方法也会在执行之前，修改MappedStatement类信息吧
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPEmapperPUBLIC"-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mappernamespace="com.lagou.mapper.UserMapper"><selectid="findById"resultType="com.lagou.pojo.User">
select * from user where id = #{id}
</select></mapper>
注意：entity 生成的 where 条件与 使用各个 api 生成的 where 条件没有任何关联行为
官网文档地址：https://mybatis.plus/guide/wrapper.html
可能是访问不了的，但并不需要在意，我们访问https://mp.baomidou.com/即可
allEq（基本是AbstractWrapper父类里面的操作）：
说明：
allEq(Map<R,V> params)allEq(Map<R,V> params,boolean null2IsNull)allEq(boolean condition,Map<R,V> params,boolean null2IsNull)/*
参数说明：
params：key为数据库字段名，value为字段值
null2IsNull：为true则在map的value为null时调⽤isNull的显示⽅法，为false时则忽略value为null的
不写默认为true
例1：allEq({id:1,name:"⽼王",age:null})--->id = 1 and name = '⽼王' and age is null
例2：allEq({id:1,name:"⽼王",age:null}, false)--->id = 1 and name = '⽼王'
condition：代表是否加入最后生成的sql中
*/
/*
测试条件构建器，allEq
map当条件
*/@TestpublicvoidtestAllEq(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();//构建mapHashMap<String,Object> map =newHashMap<>();
map.put("name","Jack");
map.put("age",null);//sql语句的where部分是：WHERE name = ? AND age IS NULL
objectQueryWrapper.allEq(map);//加入后，相当于之前操作的eq，变成了操作map集合，这也就使得可以操作IS NULL//使得之前我们基本只能可以使用selectByMap方法操作IS NULL，变成了都可以操作IS NULL了//即都可以操作map了List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);//注意：一个不进行任何操作的QueryWrapper<User> objectQueryWrapper = new QueryWrapper<>();//那么相当于null作为参数，其他可以操作null的基本也是如此(可能也不一定是该对象），注意即可}/*
测试条件构建器，allEq
多次添加
*/@TestpublicvoidtestAllEq2(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();//构建mapHashMap<String,Object> map =newHashMap<>();
map.put("name","Jack");
map.put("age",null);//多次执行
objectQueryWrapper.allEq(map);
map.put("agee",null);
objectQueryWrapper.allEq(map);//sql语句的where部分是：//WHERE name = ? AND age IS NULL AND name = ? AND agee IS NULL AND age IS NULL//即全部往后添加List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);}/*
测试条件构建器，allEq
是否忽略null
*/@TestpublicvoidtestAllEq3(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();//构建mapHashMap<String,Object> map =newHashMap<>();
map.put("name","Jack");
map.put("age",null);//sql语句的where部分是：WHERE name = ?，IS NULL被忽略，true则不会
objectQueryWrapper.allEq(map,false);List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);}/*
测试条件构建器，allEq
是否添加
*/@TestpublicvoidtestAllEq4(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();//构建mapHashMap<String,Object> map =newHashMap<>();
map.put("name","Jack");
map.put("age",null);
objectQueryWrapper.allEq(map);
map.put("agee",null);
objectQueryWrapper.allEq(false,map,true);//sql语句的where部分是：WHERE name = ? AND age IS NULL //后面的没有再加入了，注意：必须是三个参数的，两个的该参数好像没有，即allEq(false,map)没有//所以后面我指定true，当然，false也可以List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);}/*
测试条件构建器，allEq
是否添加（操作都不添加）
*/@TestpublicvoidtestAllEq5(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();//构建mapHashMap<String,Object> map =newHashMap<>();
map.put("name","Jack");
map.put("age",null);
objectQueryWrapper.allEq(false,map,true);//由于没有条件了，那么//sql语句是：SELECT id,age,eMail AS mail FROM user//没有where了（这里就给出全部，当然，对应的字段是我的设置），也就是没有条件，这是自然的List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);}
至此，三个参数测试完毕
继续说明：
allEq(BiPredicate<R,V> filter,Map<R,V> params)allEq(BiPredicate<R,V> filter,Map<R,V> params,boolean null2IsNull)allEq(boolean condition,BiPredicate<R,V> filter,Map<R,V> params,boolean null2IsNull)/*
参数说明：
filter：过滤函数，是否允许字段传⼊⽐对条件中
例1: allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"⽼王",age:null})--->
name = '⽼王' and age is null
例2: allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"⽼王",age:null}, false)--->
name = '⽼王'
使得key有a这个字母，那么就添加对应条件
params 与 null2IsNull 与 condition：同上，即与前面一样
*/
测试用例：
继续到LagouMpSpringbootApplicationTests类里面加上对应的方法：
/*
测试条件构建器，allEq
过滤操作
*/@TestpublicvoidtestAllEq6(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();//构建mapHashMap<String,Object> map =newHashMap<>();
map.put("name","Jack");
map.put("age",null);
objectQueryWrapper.allEq((k,v)->!k.equals("name"),map,true);//我们将k看成map集合的key值，过滤所有的map数据//只要对应的返回是false，那么不会加上对应的key-value条件//即这里就是，如果对应的key是name，那么返回false，即不加上条件//所以这里sql语句的where部分是：：WHERE age IS NULL //没有name的对应条件了List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);}
至此，过滤参数测试完毕
基本比较操作（基本是AbstractWrapper父类里面的操作）：
eq：等于 =
ne：不等于 <>
gt：⼤于 >
ge：大于等于 >=
lt：小于 <
le：小于等于 <=
between：BETWEEN 值1 AND 值2
notBetween：NOT BETWEEN 值1 AND 值2
in：字段 IN (value.get(0), value.get(1 ), …)
notIn：字段 NOT IN (v0, v1 , …)
测试用例：
继续到LagouMpSpringbootApplicationTests类里面加上对应的方法：
/*
基本比较操作
*/@TestpublicvoidtestWrapper(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();
objectQueryWrapper.eq("name","哈哈").ge("age","20")//这个就算是20，不是"20"，那么最终都会变成字符串，即是一样的.in("name","解决","拒绝");List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);//sql语句的where部分是：//WHERE name = ? AND age >= ? AND name IN (?,?) //很明显是根据调用的方法顺序来进行的操作，所以是先name，然后age，再然后就是in方法的name操作}
至此大致操作完毕，剩余的就不进行测试了，因为并没有意义，但为了看结果，那么看如下：
测试用例：
继续到LagouMpSpringbootApplicationTests类里面加上对应的方法：
/*
基本比较操作
总的合并
*/@TestpublicvoidtestWrapper2(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();
objectQueryWrapper
.eq("name","1").ne("name","2").gt("name","3").ge("name","4").lt("name","5").le("name","6").between("name","7","8").notBetween("name","9","10").in("name","11","12").notIn("name","13","14");//返回自身是可以分开写的，如
objectQueryWrapper
.eq("name","1");
objectQueryWrapper
.eq("name2","2")//因为你是返回自身的//注意：对应的范围若使用String类型（最好使用Integer类型），那么最好不要是特殊的，比如"100"//特殊有很多，这里只给出一个，具体看35章博客的说明//因为在sql里面会导致失败，所以mybatis-plus会使得改变sql语句（有前提，看后面的前提）//将select 和from中间的字段，全部删除，加上COUNT(1)，与COUNT(*)一样，查询有多少记录，一般是查询所有//因为会过滤不与他相关的（列名的操作）//其中改变sql语句的前提是，操作分页（一般是对应的方法操作的）//且存在分页插件（其他的插件可能也可以），否则不会改变sql语句//即该前提没有满足，那么就算你操作了特殊的，也不会改变sql语句，所以要改变sql语句//首先，先操作到特殊，然后满足前提，否则只要有一个没有满足，那么就不会改变List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);//sql语句的where部分是：/*
WHERE name = ? AND name <> ? AND name > ? AND name >= ? AND name < ?
AND name <= ? AND name BETWEEN ? AND ? AND name NOT BETWEEN ? AND ?
AND name IN (?,?) AND name NOT IN (?,?)
*///从这里，应该很清楚，正是因为对应的是字段，所以不能随便写//如a，b，等等，需要是表里面有的字段，即name//所以也并不是什么条件都可以操作，前提是字段正确，当然，map也是一样的}
至此，总的合并操作完毕
模糊查询：
like：LIKE ‘%值%’
例：like(“name”, “王”)—>name like ‘%王%’
notLike：NOT LIKE ‘%值%’
例：notLike(“name”, “王”)—>name not like ‘%王%’
likeLef：LIKE ‘%值’
例：likeLeft(“name”, “王”)—>name like ‘%王’
likeRight：LIKE ‘值%’
例：likeRight(“name”, “王”)—>name like ‘王%’
测试用例：
继续到LagouMpSpringbootApplicationTests类里面加上对应的方法：
/*
模糊查询
*/@TestpublicvoidtestWrapper3(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();
objectQueryWrapper
.like("name","jaja").notLike("name","jj").likeLeft("name","aa").likeRight("name","bb");List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);//sql语句的where部分是：//WHERE name LIKE ? AND name NOT LIKE ? AND name LIKE ? AND name LIKE ? //值：Parameters: %jaja%(String), %jj%(String), %aa(String), bb%(String)//那么为什么没有操作单独的值呢，的确没有，因为，eq不就可以了吗//为什么要加一个相同操作呢，所以就没有了//最后注意：当没有加上任何方法，时，那么自然，也就是没有where后面的操作//也就是相当于没有条件，到表名就结束了，即 SELECT id,age,eMail AS mail FROM user （我这里是）}
至此操作完毕
排序：
orderBy：ORDER BY 字段, …
例：orderBy(true, true, “id”, “name”)—>order by id ASC,name ASC
orderByAsc：ORDER BY 字段, … ASC
例：orderByAsc(“id”, “name”)—>order by id ASC,name ASC
orderByDesc：ORDER BY 字段, … DESC
例：orderByDesc(“id”, “name”)—>order by id DESC,name DESC
测试用例：
继续到LagouMpSpringbootApplicationTests类里面加上对应的方法：
/*
排序查询
*/@TestpublicvoidtestWrapper4(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();
objectQueryWrapper.orderBy(true,false,"name","name");List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);//sql语句的order by部分是：//ORDER BY name DESC , name DESC//orderBy的参数：参数1，是否添加，参数2，是否排序，若是true，则是ASC，升序，false，则是DESC，降序//升序（对于表来看，就是从上到下，依次提升），降序（对于表来看，就是从上到下，依次降低）//参数3到参数n是可变长的参数，所以可以多写，注意：若这里是相同的参数，那么自然是优先考虑靠前的//若有其他的方法，那么不会加上order by了，而是直接的相连接，若有不是排序的方法//那么自然是再order by前面的，因为默认防止后面，也使得符合sql语法}
总体操作：
测试用例：
继续到LagouMpSpringbootApplicationTests类里面加上对应的方法：
/*
排序查询
总的操作
*/@TestpublicvoidtestWrapper5(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();
objectQueryWrapper
.orderBy(true,false,"name","name").orderByAsc("name").orderByDesc("name");List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);//sql语句的order by部分是：//ORDER BY name DESC , name DESC , name ASC , name DESC//当然，对应的条件（不是条件属性，他包括基本所有的属性设置，比如eq，orderByDesc等等属性设置）执行不分先后，也就是说，如果中间出现了eq，那么实际上eq也不会写在对应后面//只是在对应的地方，所以，执行先后并没有很重要（相同的才会在对应地方后面，但是不会占用其他地方）//可以试着将eq防止中间/*
比如：
.orderBy(true,false,"name","name")
.eq("a",1)
.orderByAsc("name")
.eq("a",1)
.orderByDesc("name")
.eq("b",1);
来测试就知道了
那么一般是这样
WHERE a = ? AND a = ? AND b = ? ORDER BY name DESC , name DESC , name ASC , name DESC
即的确没有占位置，相同的会在后面
所以要注意：对应的先后并不是很重要，他们只会在对应的位置上进行添加，具体为什么不在后面添加
是由判断的，所以会加在对应位置，比如判断到了ORDER BY
那么eq就认为在他的前面，而不是后面，没有
那么就在where（eq会添加的，条件属性的设置通常都会添加，ORDER BY不会，他并不需要操作where，所以他不是条件属性的设置，所以不会添加）后面
*/}
至此操作完毕
逻辑查询：
or：拼接 OR
主动调用or表示紧接着下⼀个方法不是用and连接（不调用or则默认为使用and连接）
and：AND 嵌套
例：and（i -> i.eq(“name”, “李白”）.ne（“status”, “活着”））—>and （name = ‘李白’ and status <> ‘活着’）
/*
逻辑查询
*/@TestpublicvoidtestWrapper6(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();
objectQueryWrapper
.eq("name","jack").or().eq("name","jj");List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);//sql语句的where部分是：//WHERE name = ? OR name = ?//一般情况下，我们之前的操作都默认是and连接的，我们再条件之间//加上or（）那么就会使得默认的and，变成or}/*
逻辑查询
*/@TestpublicvoidtestWrapper7(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();
objectQueryWrapper
.eq("name","jack").and(i->i.eq("name","j"));List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);//sql语句的where部分是：//WHERE name = ? AND ( name = ? )//手动的加上括号}
至此操作完毕
select：
在MP查询中，默认查询所有的字段，如果有需要也可以通过select方法进行指定字段
测试用例：
继续到LagouMpSpringbootApplicationTests类里面加上对应的方法：
/*
select
*/@TestpublicvoidtestWrapper8(){QueryWrapper<User> objectQueryWrapper =newQueryWrapper<>();
objectQueryWrapper
.eq("name","jack").select("namee");List<User> users = userMapper.selectList(objectQueryWrapper);System.out.println(users);//sql语句的select部分是：//SELECT namee FROM user WHERE name = ?//加上select使得，不会默认使用操作类的所有字段来查询，而是使用select里面的字段来查询（select方法里面可以写多个，具体可以看里面的参数），要注意：对应的select只是在对应位置加上信息，所以写上*可行，并且*err也可行，因为他只是添加上，而没有什么判断（如eq的字段判断）//自然这里调用方法，会修改MappedStatement类信息的，使得改变，当然大多数的改变//基本都是修改MappedStatement类信息，方法也是一样，实际上mybatis也是一样，如输入数据等等//因为我们需要生成一个真正的sql，然后执行他，获得数据//所以说方法的操作，通常都会改变MappedStatement类信息，或者说改变sql语句//所以说，前面说的可能，一般是操作的，注意即可}
/*
我这里这样
根据id进行查询
@Test
void testSelect() {
System.out.println(44);
List<User> all = userMapper.selectList(null);
System.out.println(all);
}
Time：20 ms - ID：com.lagou.mapper.UserMapper.selectList
Execute SQL：
SELECT
id,
age,
eMail AS mail
FROM
user
这是我们的显示，对应的执行时间是20ms，当然，多次的运行一般是不同的
也发现sql语句进行了格式化，我们将最大的执行时间
修改成10ms（虽然可能也会成功，如运行好执行时间更短了）
再次看看运行结果
我们可以很明显的发现，报错了，使得对应的结果没有打印
我们可以知道，对于sql的执行时间，在开发中，这个插件也就能够看看优化的sql是否是被优化还是被劣化了
没有格式化的就是如下
Execute SQL：SELECT id,age,eMail AS mail FROM user
*/
/*
测试根据id进行修改
*/@TestpublicvoidtestUpdateById(){User user =newUser();
user.setId(6l);
user.setAge(30);
user.setName(null);int i = userMapper.updateById(user);System.out.println(i);}
将该方法进行修改，修改成如下：
/*
测试根据id进行修改
*/@TestpublicvoidtestUpdateById(){User user =newUser();User user1 = userMapper.selectById(3);
user.setId(3l);
user.setName("哈哈哈");
user.setVersion(user1.getVersion());int i = userMapper.updateById(user);System.out.println(i);System.out.println(user);//对应的version是新的值（加上1的）}
我们执行一下，看看对应的sql语句，我们发现执行成功，sql语句如下：
/*
UPDATE
user
SET
name='哈哈哈',
age=0, age类型是int，所以不会省略
version=2
WHERE
id=3
AND version=1
其中 version=2 ，即表示自动的加上了1，实际上是因为由于注解@Version的存在
我们在操作值时，会默认加上AND version=对应的原值，且原来的set值变成了原值加1
所以我们没有条件，也会出现AND version=1，再次执行时，也是如此，即变成了如下：
UPDATE
user
SET
name='哈哈哈',
age=0,
version=3
WHERE
id=3
AND version=2
我们可以将@Version注解删除，看看结果
UPDATE
user
SET
name='哈哈哈',
age=0,
version=3
WHERE
id=3
继续将@Version注解加回来
UPDATE
user
SET
name='哈哈哈',
age=0,
version=4
WHERE
id=3
AND version=3
所以说，将原值进行操作的就是@Version注解的作用，以及也会加上条件
当然，需要放入对应的位置，即需要赋值才可，因为null也会导致不会加上字段
而正是因为会加上条件，使得基本不会出现操作同一个数据，即避免了大多数的拿到同一个数据问题
虽然可能存在不唯一性（基本不会），或者更新失败的问题
为了测试更新失败，我们可以在如下
@Test
public void testUpdateById() {
User user = new User();
User user1 = userMapper.selectById(3);
user.setId(3l);
user.setName("哈哈哈");
user.setVersion(user1.getVersion());
这里打上断点 int i = userMapper.updateById(user);
System.out.println(i);
}
debug执行后（只要我们不放行，那么基本就算一直在运行中，而不执行sql语句）
这时我们去数据库修改对应的version，然后放行，会发现，返回0，即没有进行操作
所以的确没有进行更新，即更新失败
*/
/*
找到 public abstract List<AbstractMethod> getMethodList();方法
看看有谁实现了他，可以发现是DefaultSqlInjector
如下：
public class DefaultSqlInjector extends AbstractSqlInjector {
public DefaultSqlInjector() {
}
public List<AbstractMethod> getMethodList() {
return (List)Stream.of(new Insert(), new Delete(), new DeleteByMap(), new DeleteById(), new
DeleteBatchByIds(), new Update(), new UpdateById(), new SelectById(), new SelectBatchByIds(),
new SelectByMap(), new SelectOne(), new SelectCount(), new SelectMaps(), new
SelectMapsPage(), new SelectObjs(), new SelectList(), new
SelectPage()).collect(Collectors.toList());
}
}
我们随便点击一个，如点击new SelectById()进去，发现包含了之前的初始化的操作
也就是说，实际上之前的初始化的操作（前面源码分析中，得到了17个数据的那个方法）
就是创建了这些对象（一般都继承AbstractMethod类，因为我们通常需要他里面的内容）
然后执行injectMappedStatement方法
所以我们也知道，要想操作自己的，我们需要也创建对象才可，且创建的对象也要有injectMappedStatement方法
*/
@TestpublicvoidtestFindAll(){List<User> all = userMapper.findAll();System.out.println(all);}//运行，发现，执行了//那么有个问题，为什么可以执行findAll方法，在前面我们知道//有个 /*
return this.addSelectMappedStatement(
mapperClass, "findAll", sqlSource, modelClass, tableInfo);
其中findAll就代码方法名称（必须一样，即没有大小写忽略，否则报错，即找不到方法）
只要是BaseMapper的子类（这样可以操作泛型）中
有他这个方法，那么执行该方法，就会执行，该sql语句
所以之前的17个中，才会出现语句的执行，只是这里进行了注入，所以只有该一个方法了
有注入的则使用注入的，否则使用默认的17个，当然，我们可以将那17个写上，那么也能执行
如：
return (List)Stream.of(new FindAll(),new Insert(), new Delete(), new DeleteByMap(), new
DeleteById(), new DeleteBatchByIds(), new Update(), new UpdateById(), new SelectById(),
new SelectBatchByIds(), new SelectByMap(), new SelectOne(), new SelectCount(), new
SelectMaps(), new SelectMapsPage(), new SelectObjs(), new SelectList(), new
SelectPage()).collect(Collectors.toList());
多出了new FindAll()，这样才是真正的扩展
至此，实际上FindAll类和MySqlInjector类是进行sql语句的操作，然后通过注入，使得方法与sql语句连接
至此当我们有继承了BaseMapper接口的接口时
那么该接口的方法可以与注入sql语句对应的方法进行对应，然后可以执行sql
因为我们需要BaseMapper接口来操作放入位置（特别是泛型的操作），即初始化
当然，因为继承的关系，我们只需要将MyBaseMapper的泛型写上即可，BaseMapper的泛型可以不写
那么自然，MyBaseMapper里面的都是该泛型
因为子类关系，那么我们的初始化，自然会操作对应的父类泛型，虽然并不是BaseMapper接口
只要是BaseMapper的子类即可，无论多少层级，即一路查找
所以虽然单纯的返回类可能需要强转，但集合不需要（自动的会变，因为对方并没有泛型）
因为他只是在操作时，会提示
*/
//// Source code recreated from a .class file by IntelliJ IDEA// (powered by FernFlower decompiler)//packagecom.baomidou.mybatisplus.annotation;publicenumFieldFill{//默认不处理DEFAULT,//插⼊时填充字段INSERT,//更新时填充字段UPDATE,//插⼊或更新时填充字段INSERT_UPDATE;privateFieldFill(){}}//注意：现在好像，只要你有对应的注入，那么无论你是否加上对应的注解，都会执行填充，但一般不会的，必须存在对应的注解（如@TableField(fill = FieldFill.INSERT)），后面会说明，注意即可
1470
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
