Springboot集成Mybatis-plus(含自定义分页)

gitee仓库地址：https://gitee.com/wangwenlongGitHub/conformity.git

特性

损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库

...... 它的特性不止这些，以上内容摘自官网，只提取了常用的几个，其他特性小伙伴本可自行翻阅官方资料

Springboot整合Mybatis-plus样例演示(含增删改查+分页查询样例)

1、Pom

<!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.0</version>
        </dependency>

2、yml配置

spring:
  # 配置数据源
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/conformity?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false
    username: root
    password: root1234

3、类的继承

@Data
@ToString
@TableName(value = "sys_user")
public class SysUserPlus implements Serializable {


    @TableId(value = "id",type = IdType.AUTO)
    private Integer id;//用户id
    private String name;//用户名
    private int age;//用户年龄
    private String sex;//用户性别
    private String phone;//用户电话
    private String portrait;//用户头像
    private String telephone;//座机
    private String address;//地址
    private String enabled;//是否启用
    private String username;//用户名
    private String password;//密码
    private String remark;//备注



}

4、dao/mapper(@Mapper注解等同于启动类的@MapperScan注解，用于扫描Mapper/dao层)

@Mapper
public interface SysUserPlusDao extends BaseMapper<SysUserPlus> {
}

5、Service、ServiceImpl

public interface SysUserPlusService extends IService<SysUserPlus> {
}

@Service
public class SysUserPlusServiceImpl extends ServiceImpl<SysUserPlusDao, SysUserPlus> implements SysUserPlusService {
}

注册分页插件(没有这个类，分页插件是不生效的)

@Configuration
public class MybatisPlusConfig {

    /**
     * 注册分页插件
     * @return
     */
    @Bean
    public PaginationInterceptor paginationInterceptor(){
        return  new PaginationInterceptor();
    }
}

6、控制层

    /**
     * 不分页无参数查询所有
     * @return List<SysUserPlus>
     */
    @RequestMapping(value = "/findAll", method = RequestMethod.POST)
    @PreAuthorize("hasPermission('/conformity/sysUserPlus/findAll','sys:user:findAll')")
    public JsonResultT findAll() {
        List<SysUserPlus> findAll = sysUserPlusService.list();
        if (findAll != null && findAll.size() > 0) {
            return new JsonResultT<>(201, "查询成功", findAll);
        } else {
            return new JsonResultT(210, "查询为空");
        }
    }


    /**
     * 分页查询+多参数查询(非动态)
     * @param page 当前页
     * @param pageSize 每页总条数
     * @param name 名称
     * @return Page<SysUserPlus>
     */
    @RequestMapping(value = "/findPage", method = RequestMethod.GET)
    public JsonResultT findPage(long page,long pageSize,String name) {
        Page<SysUserPlus> iPage = new Page<>(page,pageSize);
        //Entity 对象封装操作类
        QueryWrapper<SysUserPlus> queryWrapper = new QueryWrapper<>();
        queryWrapper
                .isNotNull("name")
                .eq("name", name);
        IPage<SysUserPlus> page1 = sysUserPlusService.page(iPage, queryWrapper);
        if (page1 != null) {
            return new JsonResultT<>(201, "查询成功", page1);
        } else {
            return new JsonResultT(210, "查询为空");
        }
    }


 @RequestMapping(value = "/findById", method = RequestMethod.GET)
    @PreAuthorize("hasPermission('/conformity/sysUserPlus/findById','sys:user:findById')")
    public JsonResultT findById(Integer id) {
        SysUserPlus byId = sysUserPlusService.getById(id);
        if (byId != null) {
            return new JsonResultT<>(201, "查询成功", byId);
        } else {
            return new JsonResultT(210, "查询为空");
        }
    }


    @RequestMapping(value = "/insert", method = RequestMethod.POST)
    public JsonResultT insert(@RequestBody SysUserPlus sysUserPlus) {
        boolean save = sysUserPlusService.save(sysUserPlus);
        if (save) {
            return new JsonResultT<>(201, "新增成功", true);
        } else {
            return new JsonResultT(210, "新增失败");
        }
    }

    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public JsonResultT update(@RequestBody SysUserPlus sysUserPlus) {
        boolean update = sysUserPlusService.updateById(sysUserPlus);
        if (update) {
            return new JsonResultT<>(201, "编辑成功", true);
        } else {
            return new JsonResultT(210, "编辑失败");
        }
    }


    @RequestMapping(value = "/delete", method = RequestMethod.GET)
    public JsonResultT delete(Integer id) {
        boolean removeById = sysUserPlusService.removeById(id);
        if (removeById) {
            return new JsonResultT<>(201, "删除成功", true);
        } else {
            return new JsonResultT(210, "删除失败");
        }
    }

7、自定义分页+动态查询

//控制层
    @RequestMapping(value = "/findPageCustom", method = RequestMethod.GET)
    public JsonResultT findPageCustom(Integer page,Integer pageSize,String name) {
        IPage<SysUserPlus> page1 = sysUserPlusService.findPageCustom(page, pageSize, name);
        if (page1 != null) {
            return new JsonResultT<>(201, "查询成功", page1);
        } else {
            return new JsonResultT(210, "查询为空");
        }
    }

//service层
    @Override
    public IPage<SysUserPlus> findPageCustom(Integer page, Integer pageSize, String name) {
        Page<SysUserPlus> iPage = new Page<>(page,pageSize);
        return baseMapper.findPageCustom(iPage, name);
    }

//Mapper层(基于注解的sql)
    @Select({"<script>",
            "select * from sys_user\n",
            "where 1=1",
            "<if test='name!=null'>",
            "and name like CONCAT('%',#{name},'%')",
            "</if>",
            "</script>"})
    IPage<SysUserPlus> findPageCustom(Page<SysUserPlus> page, @Param("name") String name);

QueryWrapper源码

注：它作用于条件查询，比如like、between、=

它继承了AbstractWrapper，而AbstractWrapper又是Compare接口的实现

扫描二维码关注公众号，回复： 11905219 查看本文章

@SuppressWarnings("serial")
public class QueryWrapper<T> extends AbstractWrapper<T, String, QueryWrapper<T>>
    implements Query<QueryWrapper<T>, T, String> {
}




@SuppressWarnings("serial")
public class QueryWrapper<T> extends AbstractWrapper<T, String, QueryWrapper<T>>
    implements Query<QueryWrapper<T>, T, String> {

}

而我们用于搜索的条件筛选就是来自Compare接口中的方法，源码如下(人家的解释写的很清楚，需要哪个调用哪个就可以了)

/*
 * Copyright (c) 2011-2020, hubin ([email protected]).
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * <p>
 * https://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.baomidou.mybatisplus.core.conditions.interfaces;

import java.io.Serializable;
import java.util.Map;
import java.util.function.BiPredicate;

/**
 * 查询条件封装
 * <p>比较值</p>
 *
 * @author hubin miemie HCL
 * @since 2017-05-26
 */
public interface Compare<Children, R> extends Serializable {

    /**
     * ignore
     */
    default <V> Children allEq(Map<R, V> params) {
        return allEq(params, true);
    }

    /**
     * ignore
     */
    default <V> Children allEq(Map<R, V> params, boolean null2IsNull) {
        return allEq(true, params, null2IsNull);
    }

    /**
     * map 所有非空属性等于 =
     *
     * @param condition   执行条件
     * @param params      map 类型的参数, key 是字段名, value 是字段值
     * @param null2IsNull 是否参数为 null 自动执行 isNull 方法, false 则忽略这个字段\
     * @return children
     */
    <V> Children allEq(boolean condition, Map<R, V> params, boolean null2IsNull);

    /**
     * ignore
     */
    default <V> Children allEq(BiPredicate<R, V> filter, Map<R, V> params) {
        return allEq(filter, params, true);
    }

    /**
     * ignore
     */
    default <V> Children allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull) {
        return allEq(true, filter, params, null2IsNull);
    }

    /**
     * 字段过滤接口，传入多参数时允许对参数进行过滤
     *
     * @param condition   执行条件
     * @param filter      返回 true 来允许字段传入比对条件中
     * @param params      map 类型的参数, key 是字段名, value 是字段值
     * @param null2IsNull 是否参数为 null 自动执行 isNull 方法, false 则忽略这个字段
     * @return children
     */
    <V> Children allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull);

    /**
     * ignore
     */
    default Children eq(R column, Object val) {
        return eq(true, column, val);
    }

    /**
     * 等于 =
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val       值
     * @return children
     */
    Children eq(boolean condition, R column, Object val);

    /**
     * ignore
     */
    default Children ne(R column, Object val) {
        return ne(true, column, val);
    }

    /**
     * 不等于 &lt;&gt;
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val       值
     * @return children
     */
    Children ne(boolean condition, R column, Object val);

    /**
     * ignore
     */
    default Children gt(R column, Object val) {
        return gt(true, column, val);
    }

    /**
     * 大于 &gt;
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val       值
     * @return children
     */
    Children gt(boolean condition, R column, Object val);

    /**
     * ignore
     */
    default Children ge(R column, Object val) {
        return ge(true, column, val);
    }

    /**
     * 大于等于 &gt;=
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val       值
     * @return children
     */
    Children ge(boolean condition, R column, Object val);

    /**
     * ignore
     */
    default Children lt(R column, Object val) {
        return lt(true, column, val);
    }

    /**
     * 小于 &lt;
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val       值
     * @return children
     */
    Children lt(boolean condition, R column, Object val);

    /**
     * ignore
     */
    default Children le(R column, Object val) {
        return le(true, column, val);
    }

    /**
     * 小于等于 &lt;=
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val       值
     * @return children
     */
    Children le(boolean condition, R column, Object val);

    /**
     * ignore
     */
    default Children between(R column, Object val1, Object val2) {
        return between(true, column, val1, val2);
    }

    /**
     * BETWEEN 值1 AND 值2
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val1      值1
     * @param val2      值2
     * @return children
     */
    Children between(boolean condition, R column, Object val1, Object val2);

    /**
     * ignore
     */
    default Children notBetween(R column, Object val1, Object val2) {
        return notBetween(true, column, val1, val2);
    }

    /**
     * NOT BETWEEN 值1 AND 值2
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val1      值1
     * @param val2      值2
     * @return children
     */
    Children notBetween(boolean condition, R column, Object val1, Object val2);

    /**
     * ignore
     */
    default Children like(R column, Object val) {
        return like(true, column, val);
    }

    /**
     * LIKE '%值%'
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val       值
     * @return children
     */
    Children like(boolean condition, R column, Object val);

    /**
     * ignore
     */
    default Children notLike(R column, Object val) {
        return notLike(true, column, val);
    }

    /**
     * NOT LIKE '%值%'
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val       值
     * @return children
     */
    Children notLike(boolean condition, R column, Object val);

    /**
     * ignore
     */
    default Children likeLeft(R column, Object val) {
        return likeLeft(true, column, val);
    }

    /**
     * LIKE '%值'
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val       值
     * @return children
     */
    Children likeLeft(boolean condition, R column, Object val);

    /**
     * ignore
     */
    default Children likeRight(R column, Object val) {
        return likeRight(true, column, val);
    }

    /**
     * LIKE '值%'
     *
     * @param condition 执行条件
     * @param column    字段
     * @param val       值
     * @return children
     */
    Children likeRight(boolean condition, R column, Object val);
}

好啦，这篇文章就介绍到这里的，感谢阅读！！！

Springboot集成Mybatis-plus(含自定义分页)

gitee仓库地址：https://gitee.com/wangwenlongGitHub/conformity.git

特性

Springboot整合Mybatis-plus样例演示(含增删改查+分页查询样例)

QueryWrapper源码

猜你喜欢