Mybatis Plus语法+示例

一、Mybatis plus环境搭建
创建数据库表：

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` bigint(20) NOT NULL,
`NAME` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`age` int(11) NULL DEFAULT NULL,
`email` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`create_time` datetime(0) NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (123456, '张无忌', 32, 'zwj@qq.com', NULL);
INSERT INTO `user` VALUES (11223213, '乔峰', 34, 'qf@qq.com', NULL);
INSERT INTO `user` VALUES (235146516, '杨过', 23, 'yg@qq.com', NULL);

SET FOREIGN_KEY_CHECKS = 1;

引入maven依赖(其他和数据库以及spring boot等相关依赖省略)：

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

配置数据库（这里以8.x版本的mysql为例）：

spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: 123
url: jdbc:mysql://localhost:3306/mp?serverTimezone=GMT%2B8&useSSL=false

创建和表相对应的java实体类

@Data
public class User {

//主键
private Integer id;

//用户名
private String name;

//年龄
private Integer age;

//邮箱号
private String email;

//创建时间
private LocalDateTime createTime;
}

创建操作该表的Mapper接口（这里要继承MP的接口，相当于使用它的通用Mapper）:

public interface UserMapper extends BaseMapper<User> {

}

由于是自定义的Mapper，也就是自己定义的组件，自然就要加入到spring容器中，这里用注解：

@SpringBootApplication
//使用该注解扫描Mapper所在的包，将包中的Mapper全部注入到容器中
@MapperScan("com.kyg.mp.dao")
public class MpApplication {
public static void main(String[] args) {
SpringApplication.run(MpApplication.class, args);
}
}

测试（这里就简单的测试了其通用mapper中一个查询方法）

@SpringBootTest
public class UserMapperTest {

//这里自动注入时，使用idea可能会报错，解决方法之一就是设置idea对spring的检查等级
@Autowired
UserMapper userMapper;

@Test
public void test() {
//该方法查询表中内容，返回一个list，并且这里没有用到条件选择器，所以用null
List<User> userList = userMapper.selectList(null);
//用lambda表达式遍历list集合，打印在控制台
userList.forEach(System.out::println);
}
}

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BDTx0BIF-1590288158539)(C:\Users\PC\Desktop\结果.jpg)]

二、Mybatis plus的条件构造器
1、条件构造器的理解
条件选择器就是基于mybatis plus 这些通用的mapper来使用的，顾名思义，它是用来构造条件的，浅显一点的理解就是，动态的填写sql中的where后面的条件。

2、条件构造器的分类
条件构造器有一个抽象构造器AbstractWrapper，它里面包含了很多有关条件逻辑判断的方法。另外AbstractWrapper有两个重要子类QueryWrapper和UpdateWrapper，与查询和更新相关。还有其他和lambda表达式配合使用的子类。详细如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FOK5tAsH-1590288158541)(C:\Users\PC\Desktop\wrapper.jpg)]

3、AbstractWrapper的主要方法
注意：下面重载方法中的condition参数，是填一个布尔值，满足相应的条件，后面的参数有效

eq
eq(R column, Object val)
eq(boolean condition, R column, Object val)
//相当于=

ne
ne(R column, Object val)
ne(boolean condition, R column, Object val)
//相当于<> 不等于

gt
gt(R column, Object val)
gt(boolean condition, R column, Object val)
//相当于>

ge
ge(R column, Object val)
ge(boolean condition, R column, Object val)
//相当于>=

It
lt(R column, Object val)
lt(boolean condition, R column, Object val)
//相当于<

Ie
le(R column, Object val)
le(boolean condition, R column, Object val)
//相当于<=

between
between(R column, Object val1, Object val2)
between(boolean condition, R column, Object val1, Object val2)
//相当于between..and..

notbetween
notBetween(R column, Object val1, Object val2)
notBetween(boolean condition, R column, Object val1, Object val2)
//相当于not between..and..

like
like(R column, Object val)
like(boolean condition, R column, Object val)
//相当于模糊查询的like %val%

notlike
notLike(R column, Object val)
notLike(boolean condition, R column, Object val)
//相当于 not like %val%

likeLeft
likeLeft(R column, Object val)
likeLeft(boolean condition, R column, Object val)
//相当于like %val

likeRight
likeRight(R column, Object val)
likeRight(boolean condition, R column, Object val)
//相当于like val%

isNull
isNull(R column)
isNull(boolean condition, R column)
//相当于is not

isNotNull
isNotNull(R column)
isNotNull(boolean condition, R column)
//相当于not null

in
in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)
//相当于sql中的in

in(R column, Object... values)
in(boolean condition, R column, Object... values)

notIn
//第二个参数是一个集合
notIn(R column, Collection<?> value)
notIn(boolean condition, R column, Collection<?> value)

//第二个参数是可变参数
notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)

inSql
inSql(R column, String inValue)
inSql(boolean condition, R column, String inValue)
//相当于in的集合是通过一个子查询得到
例: inSql("age", "1,2,3,4,5,6")--->age in (1,2,3,4,5,6)
例: inSql("id", "select id from table where id < 3")--->id in (select id from table where id < 3)

notInSql
notInSql(R column, String inValue)
notInSql(boolean condition, R column, String inValue)
//inSql的否定

group by
groupBy(R... columns)
groupBy(boolean condition, R... columns)
//分组，可以填多个类名

orderByAsc
orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)
排序：ORDER BY 字段, ... ASC

orderByDesc
orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)
//降序排序

orderBy
orderBy(boolean condition, boolean isAsc, R... columns)
//加了判断是否升序排序，同样可以填多个列名

having
having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)
//相当于having子句

or
注意：如果两个方法之间没有用or连接，默认是and连接

or()
or(boolean condition)
拼接 OR

OR 嵌套
例: or(i -> i.eq("name", "李白").ne("status", "活着"))—>or (name = '李白' and status <> '活着')
and
and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)

AND 嵌套
例: and(i -> i.eq("name", "李白").ne("status", "活着"))—>and (name = '李白' and status <> '活着')
nested
nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)

正常嵌套不带 AND 或者 OR
例: nested(i -> i.eq("name", "李白").ne("status", "活着"))—>(name = '李白' and status <> '活着')
apply
apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)

该方法作用是拼接sql
例: apply("id = 1")—>id = 1
例: apply("date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")—>date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")
例: apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2008-08-08")—>date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")
last
last(String lastSql)
last(boolean condition, String lastSql)
//无视优化规则直接拼接到 sql 的最后

exists
exists(String existsSql)
exists(boolean condition, String existsSql)
//相当于exists

notExists
notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)
//exists的否定

3、QueryWrapper
QueryWrapper继承自AbstractWrapper,所以它的对象也能调用上述方法，另外，它也拥有自己特有的一些方法

select
//可以选择多个字段查询
select(String... sqlSelect)
//下面两个都是可以过滤掉某些字段的
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)

除了自己的方法外，还可以通过QueryWrapper去构造LambdaWrapper,通过new QueryWrapper().lambda()获取。

4、UpdateWrapper
UpdateWrapper和QueryWrapper类似，它也有自己的方法：

set
set(String column, Object val)
set(boolean condition, String column, Object val)
//相当update语句中的set部分

同样，和QueryWrapper一样，可以构造LambdaWrapper。

三、Mybatis Plus的CRUD接口（通用的Mapper）
Mapper（dao）层的CRUD
自定义UserMapper:

//定义一个关于user类的mapper，要想使用mp为我们提供好的（白嫖）方法，要继承BaseMapper<T>接口，同时我们
//也可以定义一些自己的方法。
public interface UserMapper extends BaseMapper<User> {
}

select相关方法：

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意：只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

使用mp为我们提供select的方法（存在重载方法）：

@SpringBootTest
public class UserMapperTest {

@Autowired
UserMapper userMapper;

//查询所用
@Test
public void testList() {
List<User> userList = userMapper.selectList(null);
userList.forEach(System.out::println);
}

@Test
public void testSelectListWrapper() {
//加入条件构造器的查询
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.eq("id",123456);
List<User> userList = userMapper.selectList(userQueryWrapper);
userList.forEach(System.out::println);
}

//根据id查询
@Test
public void testSelectById() {
User user = userMapper.selectById(123456);
System.out.println(user);
}

@Test
public void testSelectOne() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.eq("id",123456);
//传入一个条件构造器，引入查询的条件，这里是根据id查询一个
User user = userMapper.selectOne(userQueryWrapper);
System.out.println(user);

}

@Test
public void testSelectBatchIds() {
List<Integer> integerList = Arrays.asList(123456, 1234567);
//按id批量查询，传入的参数是一个id组成的集合，得到一个结果集合
List<User> userList = userMapper.selectBatchIds(integerList);
userList.forEach(System.out::println);
}

@Test
public void testSelectList() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.gt("age",29);
//根据条件查询出满足条件的结果集,这里也可以不带条件，将全部查出
List<User> userList = userMapper.selectList(userQueryWrapper);
userList.forEach(System.out::println);
}

@Test
public void testSelectByMap() {
Map<String,Object> map = new HashMap<>();
map.put("email","yg@qq.com");
/* map.put("age",32);*/
//根据map中的元素查询，map中的每一组键值对，都是查询条件，用and连接
List<User> userList = userMapper.selectByMap(map);
userList.forEach(System.out::println);
}

@Test
public void testSelectMaps() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.gt("age",30);
List<Map<String, Object>> maps = userMapper.selectMaps(userQueryWrapper);
maps.forEach(System.out::println);
}

@Test
public void testSelectObjs() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.gt("age",30);
//根据条件查询，查询所有满足条件的结果，但是每一个结果都只返回第一个字段
List<Object> objects = userMapper.selectObjs(userQueryWrapper);
objects.forEach(System.out::println);
}

@Test
public void testSelectCount() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.gt("age",30);
Integer count = userMapper.selectCount(userQueryWrapper);
System.out.println(count);
}

delete相关方法：

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

使用上述部分方法：

@Test
public void testDelete() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.eq("name","杨过");
int delete = userMapper.delete(userQueryWrapper);
System.out.println(delete);
}

@Test
public void testDeleteBatchByids() {
List<Integer> integerList = Arrays.asList(111111, 123456);
//按id批量的删除
int deleteBatchIds = userMapper.deleteBatchIds(integerList);
System.out.println(deleteBatchIds);
}

@Test
public void testDeleteByMap() {
Map<String,Object> map = new HashMap<>();
map.put("name","杨过");
//根据map中的条件删除
List<User> userList = userMapper.selectByMap(map);
userList.forEach(System.out::println);
}
}

insert相关方法：

// 插入一条记录
int insert(T entity);

使用：

@Test
public void testInster() {
User user = new User();
user.setId(1111111);
user.setName("段誉");
user.setAge(24);
user.setEmail("dy@qq.com");
user.setCreateTime(LocalDateTime.now());
//插入新的数据
int i = userMapper.insert(user);
}

update相关方法：

// 根据 whereEntity 条件，更新记录
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

使用：

@Test
public void testUpdae() {
User user = new User();
user.setName("欧阳锋");
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.eq("name","段誉");
//根据查询条件更新指定的对象，返回被更新记录的条数
int update = userMapper.update(user,userQueryWrapper);
System.out.println(update);
}

@Test
public void testUpdaeById() {
User user = new User();
user.setId(111111);
user.setName("段誉");
//根据id更新指定的字段
int update = userMapper.updateById(user);
System.out.println(update);
}

service层的CRUD
在开发中service层往往需要调用dao层的方法，然后构造自己的方法供controller调用，这样有一些重复的工作，因此mp为我们写好了一些通用的service层的方法。需要注意的是：这些方法可能实现的功能和mapper层的一样，为了做区别，即使功能一样，名字还是有区别。

说明：

通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页前缀命名方式区分 Mapper 层避免混淆，

构造自己的service:

//必须要继承mp提供的IService<T>,同样也可以在这里面写自定义的service方法
public interface UserService extends IService<User> {
}

编写service的实现类

@Service
//实现类也要继承ServiceImpl，这样才能白嫖
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

save：

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);
1
2
3
4
5
6
使用：

@Test
public void testSave() {
User user = new User();
user.setId(1111111);
user.setName("段誉");
user.setAge(24);
user.setEmail("dy@qq.com");
user.setCreateTime(LocalDateTime.now());
boolean save = userService.save(user);
}

@Test
public void testSaveBatch() {
User user1 = new User();
user1.setId(222222);
user1.setName("一灯大师");
user1.setAge(70);
user1.setEmail("yd@qq.com");
user1.setCreateTime(LocalDateTime.now());
User user2 = new User();
user2.setId(333333);
user2.setName("张三丰");
user2.setAge(80);
user2.setEmail("zsf@qq.com");
user2.setCreateTime(LocalDateTime.now());
List<User> userList = Arrays.asList(user1, user2);
//批量保存数据
boolean saveBatch = userService.saveBatch(userList);
System.out.println(saveBatch);
}

@Test
public void testSaveBatch2() {
User user1 = new User();
user1.setId(444444);
user1.setName("周伯通");
user1.setAge(65);
user1.setEmail("zbt@qq.com");
user1.setCreateTime(LocalDateTime.now());
User user2 = new User();
user2.setId(555555);
user2.setName("梅超风");
user2.setAge(35);
user2.setEmail("ycf@qq.com");
user2.setCreateTime(LocalDateTime.now());
List<User> userList = Arrays.asList(user1, user2);
User user3 = new User();
user3.setId(666666);
user3.setName("郭靖");
user3.setAge(40);
user3.setEmail("gj@qq.com");
user3.setCreateTime(LocalDateTime.now());
List<User> userLists = Arrays.asList(user1, user2,user3);
//批量保存数据,另外限制了每次插入的数量
boolean saveBatch = userService.saveBatch(userLists,2);
System.out.println(saveBatch);
}

List:

// 查询所有
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);

使用：

@Test
public void testList() {
List<User> list = userService.list();
list.forEach(System.out::println);
}

@Test
/*
default List<T> list(Wrapper<T> queryWrapper) {
return this.getBaseMapper().selectList(queryWrapper);
}

* */
public void testList1() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.gt("age",25);
//将根据条件查询结果封装到list中
List<User> list = userService.list();
list.forEach(System.out::println);
}

@Test
public void testList2() {
List<Integer> integerList = Arrays.asList(111111, 222222, 333333);
//批量id查询
List<User> userList = userService.listByIds(integerList);
userList.forEach(System.out::println);
}

@Test
public void testList3() {
Map<String,Object> map = new HashMap<>();
map.put("age",24);
List<User> userList = userService.listByMap(map);
userList.forEach(System.out::println);
}

@Test
/*
*List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
* */
public void testList4(){
//返回一个存储多个map的list
List<Map<String, Object>> maps = userService.listMaps();
maps.forEach(System.out::println);
}

Get:

// 根据 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);

使用：

public void testGetOne() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.eq("name","段誉").or().eq("name","乔峰");
User user = userService.getOne(userQueryWrapper,false);
System.out.println(user);
}

@Test
public void testGetMap() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.eq("name","段誉").or().eq("name","乔峰");
Map<String, Object> map = userService.getMap(userQueryWrapper);
map.forEach((e1,e2)-> System.out.println(e1+"="+e2));
}

@Test
public void testGetObj() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.eq("age",35);
Function<Object,User> function = this::transform;
User user =userService.getObj(userQueryWrapper, function);
}

//数据转换方法
public User transform(Object o) {
User user = (User) o;
return user;
}

remove：

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

使用：

@Test
public void testRemove() {
QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.eq("id",111111);
//根据条件删除记录
boolean b = userService.remove(userQueryWrapper);
System.out.println(b);
}

@Test
public void testRemoveById() {
boolean b = userService.removeById(222222);
System.out.println(b);
}

@Test
public void testRemoveByMap() {
Map<String,Object> map = new HashMap<>();
map.put("email","zbt@qq.com");
//根据map中的条件查询
boolean b = userService.removeByMap(map);
System.out.println(b);
}

Update:

// 根据 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);

还有诸多方法，可以在官方文档中查看，这里就不一一描述（主要是有点多），使用时可以对照官方文档。

我们只需要知道mp能为我们做这些是（厉害）。

四、注解
@TableName(表名注解)
public @interface TableName {
//数据库表的名称，一般用在数据库表名和实体类名称不一致的情况
String value() default "";
   //模式名
String schema() default "";
   //是否设置全局的的前缀，例如表名都带上公司前缀等
boolean keepGlobalPrefix() default false;
   //设置xml文件中resultMap的id值，相当于别名
String resultMap() default "";
   //是否自动构建resultMap并使用
boolean autoResultMap() default false;

String[] excludeProperty() default {};
}

@TableId(主键注解)
public @interface TableId {
//设置主键的值，当主键名不是默认的id是，相关操作会报错，这是可以为他设定一个值，数据库的字段也与其相关
String value() default "";
//设置专的生成类型，里面的填的是一个枚举类IdType
IdType type() default IdType.NONE;
}

IdType类：

public enum IdType {
//主键自增长
AUTO(0),
//不设置主键类型
NONE(1),
//自己设置主键值
INPUT(2),
//系统自动分配id（根据雪花算法）
ASSIGN_ID(3),
//分配UUID
ASSIGN_UUID(4),
//下面几个类型基本弃用
/** @deprecated */
@Deprecated
ID_WORKER(3),
/** @deprecated */
@Deprecated
ID_WORKER_STR(3),
/** @deprecated */
@Deprecated
UUID(4);

@TableField(普通属性注解)
public @interface TableField {
//同表名和主键一样，设置属性的名称
String value() default "";
   //设置是否将这个属性参与到数据库的字段
boolean exist() default true;
   //和条件构造器中的condition的功能一样
String condition() default "";

String update() default "";
   //下面都是属性策略，和主键策略类似，是关于属性的的一些设置，也是填一个枚举类型FieldStrategy
FieldStrategy insertStrategy() default FieldStrategy.DEFAULT;

FieldStrategy updateStrategy() default FieldStrategy.DEFAULT;

FieldStrategy whereStrategy() default FieldStrategy.DEFAULT;
//设置字段自动填充的策略，同样也是一个枚举类
FieldFill fill() default FieldFill.DEFAULT;
//设置是否能进行select查询
boolean select() default true;

boolean keepGlobalFormat() default false;
   //设置jdbc类型
JdbcType jdbcType() default JdbcType.UNDEFINED;
   //指定类型处理器
Class<? extends TypeHandler> typeHandler() default UnknownTypeHandler.class;
   //指定小数点后保持的位数
String numericScale() default "";
}

FieldStrategy

public enum FieldStrategy {
//忽略判断
IGNORED,
//不能为空
NOT_NULL,
//针对字符串的非空判断
NOT_EMPTY,
//默认和全局变量一致
DEFAULT,
NEVER;
private FieldStrategy() {
}
}

FieldFill

啰嗦一句，所谓的自动填充策略，就是在生成sql时，是否将这个属性对应的字段自动的加入进去，以及加入的场景

public enum FieldFill {
//默认不处理
DEFAULT,
//插入是自动填充
INSERT,
//更新时自动填充
UPDATE,
//更新和插入时自动填充
INSERT_UPDATE;

private FieldFill() {
}
}

总结
mp为我们简化了很多繁琐（重复性）的工作，它很强大，但是绝不仅仅如此，这些知识基本使用，供入门使用，

还要很多更高级的使用，可以参见官方文档（那里啥都有），这里可能没有那么详细，所以奉上官网地址。

dStrategy.DEFAULT;

boolean keepGlobalFormat() default false;
//设置jdbc类型
JdbcType jdbcType() default JdbcType.UNDEFINED;
//指定类型处理器
Class<? extends TypeHandler> typeHandler() default UnknownTypeHandler.class;
//指定小数点后保持的位数
String numericScale() default "";

}

FieldStrategy

public enum FieldStrategy {
//忽略判断
IGNORED,
//不能为空
NOT_NULL,
//针对字符串的非空判断
NOT_EMPTY,
//默认和全局变量一致
DEFAULT,
NEVER;
private FieldStrategy() {
}
}

FieldFill

啰嗦一句，所谓的自动填充策略，就是在生成sql时，是否将这个属性对应的字段自动的加入进去，以及加入的场景

public enum FieldFill {
//默认不处理
DEFAULT,
//插入是自动填充
INSERT,
//更新时自动填充
UPDATE,
//更新和插入时自动填充
INSERT_UPDATE;

private FieldFill() {

##### 总结

mp为我们简化了很多繁琐（重复性）的工作，它很强大，但是绝不仅仅如此，这些知识基本使用，供入门使用，

还要很多更高级的使用，可以参见官方文档（那里啥都有），这里可能没有那么详细，所以奉上官网地址。

[https://mp.baomidou.com/](Mybatis-Plus官网)

Mybatis Plus语法+示例相关推荐

【计算理论】上下文无关语法 ( 语法组成 | 规则 | 语法 | 语法示例 | 约定的简写形式 | 语法分析树 )
文章目录 I . 语法组成 II . 规则 III . 语法 IV . 语法示例 V . 语法简写形式 VI . 语法分析树 VII . 代数表达式语法 I . 语法组成上下文无关语法组成 : ...
c fun函数求n个整数的平均值_Python语法示例——函数
12_Python语法示例(函数) 1.写一个函数mysum,此函数带有两个参数x,y打印出两个参数x,y的和 def mysum(x, y): print(x + y)mysum(3, 2) 2.写 ...
sql avg函数使用格式_SQL AVG-SQL平均函数用语法示例解释
sql avg函数使用格式什么是SQL平均(AVG)函数? (What is the SQL Average (AVG) Function?) "Average" is an A ...
sql语句语法多表关联_SQL Delete语句-如何删除行或表，语法示例
sql语句语法多表关联 To delete a record in a table you use the DELETE statement. 要删除表中的记录,请使用DELETE语句. Be c ...
postgres语法_SQL Create Table解释了MySQL和Postgres的语法示例
postgres语法 A table is a group of data stored in a database. 表是存储在数据库中的一组数据. To create a table in a d ...
MySQL几个特别语法示例
简单介绍MySQL中几种特殊语法的用法: 1.创建示例用表和数据: 创建employees表[注:与SQL Server示例数据库Northwind中的表employees相同的表结构]: CREAT ...
MyBatis增删改示例——MyBatis学习笔记之二
上篇博文介绍了MyBatis的一个入门示例,今天介绍如何实现数据库的增加.删除和修改记录的操作.为简洁起见,与上个示例重复的注释将被删除(少数重要的除外).若影响了您的理解,可参考上篇博文. 本示例的 ...
【Mybatis框架】从零开始学Mybatis框架——使用示例
一.数据库SQL 命令 1.创建数据库,并指定编码 Create database ssm default character set utf8 2.创建表 Create table 表名(列名类型约 ...
MyBatis的association示例
今天学会的association的用法,就是一例,现写出来和大家分享(为简洁起见,ant工程中各文件.目录的布局,以及其它与前面的例子重复的内容,将不再赘述.以后博文亦将如此). 假设每个学生都有一名 ...

Mybatis Plus语法+示例

Mybatis Plus语法+示例相关推荐

最新文章

热门文章