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

﹏ヽ暗。殇╰゛Y 2022-11-26 02:58 135阅读 0赞

### gitee仓库地址：[https://gitee.com/wangwenlongGitHub/conformity.git][https_gitee.com_wangwenlongGitHub_conformity.git] ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMjI3Mjgx_size_16_color_FFFFFF_t_70][]

### **特性** ###

*  **损耗小**：启动即会自动注入基本 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**

<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接口的实现**

@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 (jobob@qq.com).
     * <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);
        }
    
        /**
         * 不等于 <>
         *
         * @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);
        }
    
        /**
         * 大于 >
         *
         * @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);
        }
    
        /**
         * 大于等于 >=
         *
         * @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);
        }
    
        /**
         * 小于 <
         *
         * @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);
        }
    
        /**
         * 小于等于 <=
         *
         * @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);
    }

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

[https_gitee.com_wangwenlongGitHub_conformity.git]: https://gitee.com/wangwenlongGitHub/conformity.git
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMjI3Mjgx_size_16_color_FFFFFF_t_70]: /images/20221124/f1ed122b7b5344e7abe041e6310a9568.png