MyBatis-Plus（二）_mybatis-plus binary-CSDN博客

本文链接：https://blog.csdn.net/jc_hook/article/details/122618200

一、代码生成器

MyBatis-Plus提供了基于数据表生成对应的实体类和相关基础代码的功能（本人使用的是3.4.3.1版本）

1.1 引入依赖

增加以下依赖

<!--代码生成:MP-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!--代码生成:MP-->
        <!-- 代码生成:模板引擎 -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.1</version>
        </dependency>
        <!-- 代码生成:模板引擎 -->

1.2 代码生成类

//代码生成类
public class CodeGenerator {

	@Test
    public void generate(){
        //代码生成器
        AutoGenerator autoGenerator = new AutoGenerator();

        //1、全局配置
        autoGenerator.setGlobalConfig(new GlobalConfig()
                //设置作者
                .setAuthor("jc_hook")
                //输出目录
                .setOutputDir("F:/project/local/MPdemo/src/main/java")
                //重新生成时文件是否覆盖
                .setFileOverride(false)
                //生成后是否打开资源管理器
                .setOpen(false)
                // 自定义文件命名,%s会自动填充表实体类名字
                .setMapperName("%sMapper")
                .setXmlName("%sMapper")
                .setServiceName("%sService")
                .setServiceImplName("%sServiceImpl")
                .setControllerName("%sController")

        );
        //2、数据源配置
        autoGenerator.setDataSource(new DataSourceConfig()
                //设置数据库路径
                .setUrl("jdbc:mysql://localhost:3306/demo?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=UTF-8")
                //设置账号
                .setUsername("root")
                //设置密码
                .setPassword("123456")
                //设置数据库类型
                .setDbType(DbType.MYSQL)
                //设置驱动
                .setDriverName("com.mysql.cj.jdbc.Driver")
        );

        //3、包配置
        autoGenerator.setPackageInfo(new PackageConfig()
                //模块名
                .setModuleName("user")
                //包名
                .setParent("com.example.demo")
                // 设置Controller包名
                .setController("controller")
                // 设置entity包名
                .setEntity("bean")
                // 设置Mapper包名
                .setMapper("mapper")
                // 设置Service包名
                .setService("service")
                // 设置Service实现类包名
                .setServiceImpl("service.impl")
                // 设置Mapper.xml包名
                .setXml("mapper")
        );

        //5、策略配置
        autoGenerator.setStrategy(new StrategyConfig()
                // 需要生成的表
                .setInclude("t_user")
                // 实体类使用Lombok
                .setEntityLombokModel(true)
                // 表名生成策略,下划线转驼峰
                .setNaming(NamingStrategy.underline_to_camel)
        );

        //6、执行
        autoGenerator.execute();

    }
}

1.3 测试

执行代码
在这里插入图片描述
在指定路径下生成了代码

二、条件构造器

QueryWrapper(LambdaQueryWrapper) 和UpdateWrapper(LambdaUpdateWrapper) 的父类
用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条件

2.1 AbstractWrapper

2.1.1 参数说明

参数	说明
params	key为数据库字段名,value为字段值
null2IsNull	为true则在map的value为null时调用 isNull 方法,为false时则忽略value为null的
condition	默认为true，是否将条件加入到总sql句后

2.1.2 条件

allEq（全部eq或个别isNull）

allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)

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)

lt（小于）

lt(R column, Object val)
lt(boolean condition, R column, Object val)

le（小于等于）

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)

notBetween

notBetween(R column, Object val1, Object val2)
notBetween(boolean condition, R column, Object val1, Object val2)

like

like(R column, Object val)
like(boolean condition, R column, Object val)

notLike

notLike(R column, Object val)
notLike(boolean condition, R column, Object val)

likeLeft（LIKE ‘%值’）

likeLeft(R column, Object val)
likeLeft(boolean condition, R column, Object val)

likeRight（LIKE ‘值%’）

likeRight(R column, Object val)
likeRight(boolean condition, R column, Object val)

isNull

isNull(R column)
isNull(boolean condition, R column)

isNotNull

isNotNull(R column)
isNotNull(boolean condition, R column)

in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)

notIn

notIn(R column, Collection<?> value)
notIn(boolean condition, R column, Collection<?> value)

inSql

inSql(R column, String inValue)
inSql(boolean condition, R column, String inValue)

例: inSql(“age”, “1,2,3,4,5,6”)—>age in (1,2,3,4,5,6)

notInSql

notInSql(R column, String inValue)
notInSql(boolean condition, R column, String inValue)

例: notInSql(“age”, “1,2,3,4,5,6”)—>age not in (1,2,3,4,5,6)

groupBy

groupBy(R... columns)
groupBy(boolean condition, R... columns)

orderByAsc

orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)

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(“sum(age) > 10”)—>having sum(age) > 10

func

func(Consumer<Children> consumer)
func(boolean condition, Consumer<Children> consumer)

func 方法(主要方便在出现if…else下调用不同方法能不断链)
例: func(i -> if(true) {i.eq(“id”, 1)} else {i.ne(“id”, 1)})

or()
or(boolean condition)

注意事项:
主动调用or表示紧接着下一个方法不是用and连接!(不调用or则默认为使用and连接)

and

and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)

nested

nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)

正常嵌套不带 AND 或者 OR

apply

apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)

注意事项:
该方法可用于数据库函数动态入参的params对应前面applySql内部的{index}部分.这样是不会有sql注入风险的,反之会有!
例: apply(“date_format(dateColumn,’%Y-%m-%d’) = {0}”, “2008-08-08”)—>date_format(dateColumn,’%Y-%m-%d’) = ‘2008-08-08’")

exists

exists(String existsSql)
exists(boolean condition, String existsSql)

notExists

notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)

2.2 QueryWrapper

继承自 AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件
及 LambdaQueryWrapper, 可以通过 new QueryWrapper().lambda() 方法获取

select

select(String... sqlSelect)
//根据字段进行查询（前提entity对应字段有值）
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)

2.3 UpdateWrapper

继承自 AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件
及 LambdaUpdateWrapper, 可以通过 new UpdateWrapper().lambda() 方法获取!

set

set(String column, Object val)
set(boolean condition, String column, Object val)

例: set(“name”, “”)—>数据库字段值变为空字符串
例: set(“name”, null)—>数据库字段值变为null

setSql
set

setSql(String sql)

设置 SET 部分 SQL
例: setSql(“name = ‘老李头’”)

三、CURD 接口

3.1 Service CURD 接口

提供了IService接口，进一步封装 CRUD
服务类可以通过继承ServiceImpl,调用CRUD接口
存在自定义通用 Service 方法的可能，可以创建自己的 IBaseService 继承IService接口
泛型 T 为任意实体对象
对象 Wrapper 为条件构造器

Save

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

Update

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

SaveOrUpdate

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

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);

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);

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);

Page

// 无条件分页查询
IPage<T> page(IPage<T> page);
// 条件分页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

Count

// 查询总记录数
int count();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

3.2 Mapper CURD 接口

CRUD 封装BaseMapper (opens new window)接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
泛型 T 为任意实体对象
参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
对象 Wrapper 为条件构造器

Insert

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

Update

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

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);

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);

3.3 ActiveRecord模式

实体类只需继承 Model 类即可进行强大的 CRUD 操作
需要项目中已注入对应实体的BaseMapper

继承 Model

public class UserBean extends Model<UserBean> {
    //fields...
    
}

调用CRUD方法(仅演示部分api)

UserBean user = new UserBean();
user.insert();
user.selectAll();
user.updateById();
user.deleteById();
// ...