mybatis-plus

最新推荐文章于 2024-05-21 10:51:55 发布

高冷大猛男

最新推荐文章于 2024-05-21 10:51:55 发布

阅读量498

点赞数

文章标签： mybatis

本文链接：https://blog.csdn.net/weixin_60934893/article/details/133003319

版权

1.特征

    无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑

    损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作

    强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求

    支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错

    支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题

    支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作

    支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）

    内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用

    内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询

    分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库

    内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询

    内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

2.使用流程

2.1 导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

2.2 启动类中注入注解

在spring boot启动类中添加@MapperScan注解，扫描Mapper文件夹：

@SpringBootApplication
@MapperScan("com.wen.mybatis_plus.mapper")  //扫描mapper
public class MybatisPlusApplication {

    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusApplication.class, args);
    }

}

2.3编写mapper包下的接口

@Mapper
public interface UserMapper extends BaseMapper<User> {

}

2.4开始测试

@SpringBootTest
class MybatisPlusApplicationTests {

    //继承了BaseMapper所有的方法，可以编写自己的扩展方法
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect(){
        System.out.println("--------selectAll method test-------");
        //查询全部用户，参数是一个Wrapper，条件构造器，先不使用为null
        List<User> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);
    }

3.mybatis-plus封装的sql

public interface BaseMapper<T> extends Mapper<T> {
    int insert(T entity);

    int deleteById(Serializable id);

    int deleteByMap(@Param("cm") Map<String, Object> columnMap);

    int delete(@Param("ew") Wrapper<T> queryWrapper);

    int deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    int updateById(@Param("et") T entity);

    int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

    T selectById(Serializable id);

    List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);

    T selectOne(@Param("ew") Wrapper<T> queryWrapper);

    Integer selectCount(@Param("ew") Wrapper<T> queryWrapper);

    List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

    List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);

    List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);

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

3.1各个方法举例

3.1.1 插入一条记录

User user = new User();
user.setName("John");
user.setAge(30);
int result = baseMapper.insert(user);

3.1.2 根据主键删除记录

int result = baseMapper.deleteById(1);

3.1.3 根据列的键值对删除记录

Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age", 30);
int result = baseMapper.deleteByMap(columnMap);

3.1.4 根据条件删除记录

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age", 30);
int result = baseMapper.delete(queryWrapper);

3.1.5 根据一批主键值删除多条记录

List<Integer> idList = Arrays.asList(1, 2, 3);
int result = baseMapper.deleteBatchIds(idList);

3.1.6 根据主键更新记录

User user = new User();
user.setId(1);
user.setName("UpdatedName");
int result = baseMapper.updateById(user);

3.1.7 根据条件更新记录

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("age", 30);
User user = new User();
user.setName("UpdatedName");
int result = baseMapper.update(user, updateWrapper);

3.1.8 根据主键查询一条记录

User user = baseMapper.selectById(1);

3.1.9 根据一批主键值查询多条记录

List<Integer> idList = Arrays.asList(1, 2, 3);
List<User> userList = baseMapper.selectBatchIds(idList);

3.1.10 根据列的键值对查询记录

Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age", 30);
List<User> userList = baseMapper.selectByMap(columnMap);

3.1.11 根据条件查询一条记录

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age", 30);
User user = baseMapper.selectOne(queryWrapper);

3.1.12 根据条件查询记录的数量

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age", 30);
Integer count = baseMapper.selectCount(queryWrapper);

3.1.13 根据条件查询多条记录

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age", 30);
List<User> userList = baseMapper.selectList(queryWrapper);

3.1.14 根据条件查询多条记录，并将结果转换为Map的列表

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age", 30);
List<Map<String, Object>> resultMapList = baseMapper.selectMaps(queryWrapper);

3.1.15 根据条件查询多条记录，并将结果转换为Object的列表

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age", 30);
List<Object> resultList = baseMapper.selectObjs(queryWrapper);

3.1.16 分页查询

Page<User> page = new Page<>(1, 10);
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age", 30);
IPage<User> userPage = baseMapper.selectPage(page, queryWrapper);

3.1.17 分页查询并返回Map的列表

Page<User> page = new Page<>(1, 10);
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age", 30);
IPage<Map<String, Object>> resultMapPage = baseMapper.selectMapsPage(page, queryWrapper);

4.LambdaQueryWrapper跟querywrapper的区别是什么？

使用方式：

QueryWrapper：在使用 QueryWrapper 构建查询条件时，通常需要传递字符串形式的字段名，如 queryWrapper.eq("name", "John")，其中 "name" 是数据库表中的字段名。这种方式在编码时容易出现拼写错误或者字段名变更导致的问题。

LambdaQueryWrapper：与 LambdaQueryWrapper 一起使用时，可以利用 Lambda 表达式，直接引用实体类的属性，如 lambdaQueryWrapper.eq(User::getName, "John")。这种方式在编码时更加类型安全，编译器可以检查属性名的正确性，避免拼写错误或者字段名变更导致的问题。

类型安全性：

QueryWrapper：由于 QueryWrapper 使用字符串字段名，因此在编译时不会对字段名进行类型检查，容易在运行时出现错误，特别是在字段名变更或者拼写错误的情况下。

LambdaQueryWrapper：使用 Lambda 表达式引用属性名，可以在编译时进行类型检查，因此更加类型安全，可以在编码阶段捕获到错误。

IDE支持：

LambdaQueryWrapper 更容易受到现代IDE的支持，例如自动补全和重构工具，因为它们可以理解Lambda表达式，而不仅仅是字符串。

5.queryWrapper的方法

eq(String column, Object value)：等于查询条件。

ne(String column, Object value)：不等于查询条件。

gt(String column, Object value)：大于查询条件。

ge(String column, Object value)：大于等于查询条件。

lt(String column, Object value)：小于查询条件。

le(String column, Object value)：小于等于查询条件。

between(String column, Object val1, Object val2)：范围查询条件。

notBetween(String column, Object val1, Object val2)：不在范围内的查询条件。

like(String column, Object value)：模糊查询条件。

notLike(String column, Object value)：不包含查询条件。

likeLeft(String column, Object value)：左模糊查询条件。

likeRight(String column, Object value)：右模糊查询条件。

isNull(String column)：为 null 查询条件。

isNotNull(String column)：不为 null 查询条件。

in(String column, Collection<?> values)：in 查询条件。

notIn(String column, Collection<?> values)：not in 查询条件。

inSql(String column, String inValue)：in 查询条件，in 子查询。

notInSql(String column, String inValue)：not in 查询条件，not in 子查询。

groupBy(String... columns)：分组查询条件。

orderByAsc(String... columns)：升序排序查询条件。

orderByDesc(String... columns)：降序排序查询条件。

last(String... sql)：在 SQL 语句最后添加自定义 SQL 片段。

apply(String applySql, Object... params)：动态添加 SQL 片段，可以用于复杂的条件组合。

and()：连接多个查询条件，使用 AND 连接。

or()：连接多个查询条件，使用 OR 连接。

nested(Consumer<QueryWrapper<T>> consumer)：嵌套查询条件，用于构建复杂的查询逻辑。

exists(String existsSql)：exists 子查询条件。

notExists(String notExistsSql)：not exists 子查询条件。

select(String... columns)：指定查询的字段。

selectExclude(String... excludeColumns)：排除不查询的字段。

6. mybatis-plus分页

@Configuration
@MapperScan("com.xuecheng.content.mapper")
public class MybatisPlusConfig {
    /**
     * 定义分页拦截器
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

}

分页的演示

public PageResult<CourseBase> queryCourseBaseList(PageParams pageParams, QueryCourseParamsDto queryCourseParamsDto) {


        //构建查询条件对象
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        //构建查询条件，根据课程名称查询
        //判断queryCourseParamsDto.getCourseName())是否为空，不为空模糊查询CourseBase中的name，查询关键字是queryCourseParamsDto.getCourseName()
        queryWrapper.like(StringUtils.isNotEmpty(queryCourseParamsDto.getCourseName()), CourseBase::getName, queryCourseParamsDto.getCourseName());
        //构建查询条件，根据课程审核状态查询
        queryWrapper.eq(StringUtils.isNotEmpty(queryCourseParamsDto.getAuditStatus()), CourseBase::getAuditStatus, queryCourseParamsDto.getAuditStatus());
        //构建查询条件，根据课程发布状态查询
        queryWrapper.eq(StringUtils.isNotEmpty(queryCourseParamsDto.getPublishStatus()), CourseBase::getStatus, queryCourseParamsDto.getPublishStatus());

        //分页对象
        Page<CourseBase> page = new Page<>(pageParams.getPageNo(), pageParams.getPageSize());
        // 查询数据内容获得结果
        Page<CourseBase> pageResult = courseBaseMapper.selectPage(page, queryWrapper);
        // 获取数据列表
        List<CourseBase> list = pageResult.getRecords();
        // 获取数据总数
        long total = pageResult.getTotal();
        // 构建结果集
        PageResult<CourseBase> courseBasePageResult = new PageResult<>(list, total, pageParams.getPageNo(), pageParams.getPageSize());
        return courseBasePageResult;


    }

上述代码pageResult的方法总结

getRecords()：获取分页查询的数据记录列表，通常返回一个 List<CourseBase>，包含了查询到的课程信息。

getTotal()：获取总记录数，返回一个 long 类型的值，表示满足查询条件的总记录数。

getCurrent()：获取当前页码，返回一个 long 类型的值，表示当前页的页码。

getSize()：获取每页记录数，返回一个 long 类型的值，表示每页显示的记录数。

getPages()：获取总页数，返回一个 long 类型的值，表示满足查询条件的总页数。

hasPrevious()：判断是否有上一页，返回一个 boolean 类型的值，如果当前页不是第一页，则返回 true，否则返回 false。

hasNext()：判断是否有下一页，返回一个 boolean 类型的值，如果当前页不是最后一页，则返回 true，否则返回 false。

getOrders()：获取排序字段信息，返回一个 List<OrderItem>，表示按照哪些字段进行排序，以及排序的方式（升序还是降序）。

optimizeCountSql(boolean isCount)：设置是否优化总记录数查询的SQL，传入 true 表示进行优化，传入 false 表示不进行优化。

searchCount(boolean searchCount)：设置是否查询总记录数，传入 true 表示查询总记录数，传入 false 表示不查询总记录数。

isSearchCount()：判断是否查询总记录数，返回一个 boolean 类型的值，如果设置了查询总记录数则返回 true，否则返回 false。

getCurrentMap()：获取当前分页查询的参数信息，返回一个 Map<String, Object>，包含了当前页码、每页记录数等信息。

optimizePageSize(boolean isOptimize)：设置是否优化分页查询的SQL，传入 true 表示进行优化，传入 false 表示不进行优化。

高冷大猛男

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
mybatis-plus

强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求。使用字符串字段名，因此在编译时不会对字段名进行类型检查，容易在运行时出现错误，特别是在字段名变更或者拼写错误的情况下。：使用 Lambda 表达式引用属性名，可以在编译时进行类型检查，因此更加类型安全，可以在编码阶段捕获到错误。这种方式在编码时更加类型安全，编译器可以检查属性名的正确性，避免拼写错误或者字段名变更导致的问题。
复制链接

扫一扫