提高開發效率的一款mybatis開發神器

時間 2019-12-11

原文原文鏈接

文末附有完整案例的代碼內容！！java

之前在開發的時候，使用mybatis的時候，常常都須要先配置xml映射文件，而後每條sql操做都須要本身進行手動編寫，對於一些複雜的sql這麼來操做確實有必要，可是若是隻是一些很是簡單的insert，update，delete，select這類型的語句而言，也須要開發人員花費額外的時間進行手動編寫的話，確實費時又費力。mysql

可否爲mybatis特別定製一套可以自動爲咱們生成一些簡單sql功能，同時又支持咱們進行自定義sql設置功能的強大框架呢？git

mybatis plus所以誕生了。web

這隻小鳥太魔性了spring

mybatis plus是一款專門針對於傳統MyBatis開發中sql須要手動進行映射配置繁瑣缺點的一款框架技術，這款框架技術提供了十分豐富的api供開發者們使用，在 MyBatis 的基礎上只作加強不作改變，爲簡化開發、提升效率而生。sql

Mybatis plus到底有多方便呢，咱們閒話很少說，直接上手代碼實例來進行演示：數據庫

首先咱們須要導入一些相關的pom依賴配置express

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sise</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatisplus-spring-boot-starter</artifactId>
            <version>1.0.5</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>2.3</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>


</project>

導入了jar包以後，爲了方便測試，咱們首先在數據庫裏面搭建相關的數據表信息apache

CREATE TABLE `teacher` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `teacher_name` varchar(60) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,
  `teacher_pwd` varchar(60) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=14 DEFAULT CHARSET=gbk;

該表對應的實體類：api

package com.sise.model;

import com.baomidou.mybatisplus.annotations.TableName;

/**
 * @author idea
 * @data 2019/5/24
 */
@TableName(value = "teacher")
public class Teacher {
    private int id;

    private String teacherName;

    private String teacherPwd;

    public int getId() {
        return id;
    }


    public Teacher() {
    }

    public Teacher(int id) {
        this.id = id;
    }

    public Teacher setId(int id) {
        this.id = id;
        return this;
    }

    public String getTeacherName() {
        return teacherName;
    }

    public Teacher setTeacherName(String teacherName) {
        this.teacherName = teacherName;
        return this;
    }

    public String getTeacherPwd() {
        return teacherPwd;
    }

    public Teacher setTeacherPwd(String teacherPwd) {
        this.teacherPwd = teacherPwd;
        return this;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", teacherName='" + teacherName + ''' +
                ", teacherPwd='" + teacherPwd + ''' +
                '}';
    }
}

一般咱們在開發的時候都會自定義一個Dao層，mybatis plus裏面提供了一個叫作BaseMapper的接口，內部已經提供了至關多的crud操做函數的封裝。能夠來仔細查看一下該接口的內容：

/**
 * 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>
 * http://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.mapper;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.RowBounds;

/**
 * <p>
 * Mapper 繼承該接口後，無需編寫 mapper.xml 文件，便可得到CRUD功能
 * </p>
 * <p>
 * 這個 Mapper 支持 id 泛型
 * </p>
 *
 * @author hubin
 * @Date 2016-01-23
 */
public interface BaseMapper<T> {

    /**
     * <p>
     * 插入一條記錄
     * </p>
     *
     * @param entity 實體對象
     * @return int
     */
    Integer insert(T entity);

    /**
     * <p>
     * 插入一條記錄
     * </p>
     *
     * @param entity 實體對象
     * @return int
     */
    Integer insertAllColumn(T entity);

    /**
     * <p>
     * 根據 ID 刪除
     * </p>
     *
     * @param id 主鍵ID
     * @return int
     */
    Integer deleteById(Serializable id);

    /**
     * <p>
     * 根據 columnMap 條件，刪除記錄
     * </p>
     *
     * @param columnMap 表字段 map 對象
     * @return int
     */
    Integer deleteByMap(@Param("cm") Map<String, Object> columnMap);

    /**
     * <p>
     * 根據 entity 條件，刪除記錄
     * </p>
     *
     * @param wrapper 實體對象封裝操做類（能夠爲 null）
     * @return int
     */
    Integer delete(@Param("ew") Wrapper<T> wrapper);

    /**
     * <p>
     * 刪除（根據ID 批量刪除）
     * </p>
     *
     * @param idList 主鍵ID列表
     * @return int
     */
    Integer deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    /**
     * <p>
     * 根據 ID 修改
     * </p>
     *
     * @param entity 實體對象
     * @return int
     */
    Integer updateById(@Param("et") T entity);

    /**
     * <p>
     * 根據 ID 修改
     * </p>
     *
     * @param entity 實體對象
     * @return int
     */
    Integer updateAllColumnById(@Param("et") T entity);

    /**
     * <p>
     * 根據 whereEntity 條件，更新記錄
     * </p>
     *
     * @param entity  實體對象
     * @param wrapper 實體對象封裝操做類（能夠爲 null）
     * @return
     */
    Integer update(@Param("et") T entity, @Param("ew") Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 whereEntity 條件，更新記錄
     * </p>
     *
     * @param setStr  set字符串
     * @param wrapper 實體對象封裝操做類（能夠爲 null）
     * @return
     */
    Integer updateForSet(@Param("setStr") String setStr, @Param("ew") Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 ID 查詢
     * </p>
     *
     * @param id 主鍵ID
     * @return T
     */
    T selectById(Serializable id);

    /**
     * <p>
     * 查詢（根據ID 批量查詢）
     * </p>
     *
     * @param idList 主鍵ID列表
     * @return List<T>
     */
    List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

    /**
     * <p>
     * 查詢（根據 columnMap 條件）
     * </p>
     *
     * @param columnMap 表字段 map 對象
     * @return List<T>
     */
    List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);

    /**
     * <p>
     * 根據 entity 條件，查詢一條記錄
     * </p>
     *
     * @param entity 實體對象
     * @return T
     */
    T selectOne(@Param("ew") T entity);

    /**
     * <p>
     * 根據 Wrapper 條件，查詢總記錄數
     * </p>
     *
     * @param wrapper 實體對象
     * @return int
     */
    Integer selectCount(@Param("ew") Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 entity 條件，查詢所有記錄
     * </p>
     *
     * @param wrapper 實體對象封裝操做類（能夠爲 null）
     * @return List<T>
     */
    List<T> selectList(@Param("ew") Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 Wrapper 條件，查詢所有記錄
     * </p>
     *
     * @param wrapper 實體對象封裝操做類（能夠爲 null）
     * @return List<T>
     */
    List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 Wrapper 條件，查詢所有記錄
     * 注意： 只返回第一個字段的值
     * </p>
     *
     * @param wrapper 實體對象封裝操做類（能夠爲 null）
     * @return List<Object>
     */
    List<Object> selectObjs(@Param("ew") Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 entity 條件，查詢所有記錄（並翻頁）
     * </p>
     *
     * @param rowBounds 分頁查詢條件（能夠爲 RowBounds.DEFAULT）
     * @param wrapper   實體對象封裝操做類（能夠爲 null）
     * @return List<T>
     */
    List<T> selectPage(RowBounds rowBounds, @Param("ew") Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 Wrapper 條件，查詢所有記錄（並翻頁）
     * </p>
     *
     * @param rowBounds 分頁查詢條件（能夠爲 RowBounds.DEFAULT）
     * @param wrapper   實體對象封裝操做類
     * @return List<Map<String, Object>>
     */
    List<Map<String, Object>> selectMapsPage(RowBounds rowBounds, @Param("ew") Wrapper<T> wrapper);

}

這些內置的功能都是已經提早自定義好了的，所以對於一些經常使用的簡單的sql咱們能夠避免使用手動拼接的方式來實現，大大提高了開發人員的開發效率，結合文章上邊所說的教師對象，咱們自定義一個Mapper接口用於實現crud的操做：

package com.sise.dao;

import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.sise.model.Teacher;
import org.apache.ibatis.annotations.Mapper;


/**
 * @author idea
 * @data 2019/5/24
 */
@Mapper
public interface TeacherMapper extends BaseMapper<Teacher> {
}

爲了方便測試，我直接選擇了在controller裏面引用dao函數的功能。

1.提早定義好的插入功能：

BaseMapper裏面封裝了已經定義好的insert語句，可以方便咱們直接調用，無須本身手動編寫sql

@GetMapping(value = "/insert")
    public void insert(){
        Teacher  teacher=new Teacher();
        teacher.setTeacherName(createRandomStr(6));
        teacher.setTeacherPwd(createRandomStr(6));
        teacherMapper.insert(teacher);
    }

    /**
     * 生成隨機字符串
     *
     * @return
     */
    private static String createRandomStr(int length){
        String str="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        Random random=new Random();
        StringBuffer sb=new StringBuffer();
        for(int i=0;i<length;i++){
            int number=random.nextInt(str.length());
            sb.append(str.charAt(number));
        }
        return sb.toString();
    }

生成的sql語句：

INSERT INTO teacher ( id, teacher_name, teacher_pwd ) VALUES ( 0, 'mNJXIf', 'LKTnam' );

2.提早定義好的刪除功能

BaseMapper裏面提供有已經定義好的delete功能，

   @GetMapping(value = "/delete")
    public void delete(){
        Teacher  teacher=new Teacher();
        teacher.setId(11);
        EntityWrapper entityWrapper=new EntityWrapper(teacher);
        teacherMapper.delete(entityWrapper);
    }

生成的sql語句：

DELETE FROM teacher WHERE id=11;

3.提早定義好的更新功能

BaseMapper裏面定義了相關的update功能，可是在進行update的時候有個地方須要注意，來看看下邊這段代碼先

    @GetMapping(value = "/update")
    public void update(){
        //update的判斷條件
        EntityWrapper entityWrapper=new EntityWrapper(new Teacher(1));
        //更新以後的對象
        Teacher teacher=new Teacher();
        teacher.setTeacherPwd("new-pwd");
        teacherMapper.update(teacher,entityWrapper);
    }

生成的sql語句：

UPDATE teacher SET teacher_pwd='new-pwd'  WHERE id=1;

mybatis-plus裏面提供了一個叫作EntityWrapper的對象封裝操做類，經過傳入相關的Entity來判斷傳入的查詢參數，這裏的使用讓我回想起了之前用hibernate的那種味道，不得不說這種功能的設計確實幫開發者的開發效率提高了不少。

之前寫更新語句的時候，常常是須要在xml裏面進行很是多繁瑣耗時的sql拼接工做，如今mybatis-plus經過EntityWrapper這個封裝類，大大節省了相應時間。

4.根據指定id進行查詢

mybatis-plus也默認提供了關鍵字查詢的功能，能夠將查詢參數經過對象Entity的形式注入，很是方便。

ps:mybatis-plus已經默認帶有了sql注入的預防功能，所以這點能夠放心使用。

  @GetMapping(value = "/selectAllById")
    public Teacher selectByTeacherName(int id){
        return teacherMapper.selectOne(new Teacher(id));
    }

生成的sql語句：

SELECT id,teacher_name AS teacherName,teacher_pwd AS teacherPwd
 FROM teacher
 WHERE id=0;

5.使用Map來進行多關鍵字的查詢

有些時候，除了使用查詢時候使用Entity關鍵字來進行查詢以外，還能夠經過使用Map的形式來進行多關鍵字的搜索實現，相關代碼以下所示：

    @GetMapping(value = "/selectAllByMap")
    public List<Teacher> selectAllByEntity(String name){
        Map<String,Object> hashMap=new HashMap<>();
        hashMap.put("teacher_name",name);
        return teacherMapper.selectByMap(hashMap);
    }

注意，這裏的map放入的key值須要和表裏面的字段命名一致。

生成的sql語句：

SELECT id,teacher_name AS teacherName,teacher_pwd AS teacherPwd
 FROM teacher
 WHERE teacher_name = 'qwe';

6.統計查詢

    @GetMapping(value = "/selectCountByEntity")
    public int selectCount(String name){
        Teacher teacher=new Teacher();
        teacher.setId(1);
        teacher.setTeacherName(name);
        EntityWrapper<Teacher> entityWrapper=new EntityWrapper<>(teacher);
        return teacherMapper.selectCount(entityWrapper);
    }

生成的sql語句：

SELECT COUNT(1)  FROM teacher  WHERE id=1 AND teacher_name='qwe';

7.分頁查詢

在實際開發中，分頁查詢功能一直是很是廣泛須要運用到的一點，在mybatis-plus裏面，他提供了一個叫作Page的類供咱們使用，相應的代碼以下所示：

   @GetMapping(value = "/selectAllInPage")
    public List<Teacher> selectAllInPage(int pageNumber,int pageSize){
        Page<Teacher> page =new Page<>(pageNumber,pageSize);
        EntityWrapper<Teacher> entityWrapper = new EntityWrapper<>();
        entityWrapper.ge("id", 1);
        return teacherMapper.selectPage(page,entityWrapper);
    }

生成的sql語句：

SELECT id,teacher_name AS teacherName,teacher_pwd AS teacherPwd  FROM teacher  WHERE (id >= 1) LIMIT 0,1;

mybatis-plus使用的分頁技術是傳統的 limit 物理分頁方式。

8. in 查詢

查詢的時候，若是須要使用in查詢的話，可使用selectBatchIds這個api功能：

    @GetMapping(value = "/selectInIdArr")
    public List<Teacher> selectInIdArr(){
        List<Integer> idList=new ArrayList<>();
        idList.add(1);
        idList.add(10);
        idList.add(11);
        return teacherMapper.selectBatchIds(idList);
    }

生成的sql語句：

SELECT id,teacher_name AS teacherName,teacher_pwd AS teacherPwd FROM teacher WHERE id IN ( 1 , 10 , 11 );

9.複雜條件查詢

針對於比較複雜的多條件查詢，mybatis-plus內部提供的EntityWrapper支持有許多豐富的查詢api功能供咱們使用。

爲了方便理解，下邊經過實際的代碼案例來進行解釋

allEq查詢（至關於條件所有都要求知足的狀況）

 @GetMapping(value = "/selectAllByWrapper1")
    public  List<Teacher> selectAllByWrapper1(){
        Map<String,Object> map=new HashMap<>();
        map.put("teacher_name","name");
        map.put("teacher_pwd","pwd");
        EntityWrapper entity=new EntityWrapper();
        entity.allEq(map);
        return teacherMapper.selectList(entity);
    }

生成的sql語句：

SELECT id,teacher_name AS teacherName,teacher_pwd AS teacherPwd
 FROM teacher
 WHERE (teacher_pwd = 'pwd' AND teacher_name = 'name');

ne查詢

   @GetMapping(value = "/selectAllByWrapper3")
    public List<Teacher> selectAllByWrapper3(){
        EntityWrapper entity=new EntityWrapper();
        entity.ne("teacher_name","name");
        return teacherMapper.selectList(entity);
    }

生成的sql語句：

SELECT id,teacher_name AS teacherName,teacher_pwd AS teacherPwd
 FROM teacher
 WHERE (teacher_name <> 'name');

eq查詢

    @GetMapping(value = "/selectAllByWrapper2")
    public List<Teacher> selectAllByWrapper2(){
        EntityWrapper entity=new EntityWrapper();
        entity.eq("teacher_name","name");
        return teacherMapper.selectList(entity);
    }

生成的sql語句：

SELECT id,teacher_name AS teacherName,teacher_pwd AS teacherPwd
 FROM teacher
 WHERE (teacher_name = 'name');

複雜的多條件查詢：

  @GetMapping(value = "/selectAllByWrapper4")
    public  List<Teacher> selectAllByWrapper4(){
        EntityWrapper entity=new EntityWrapper();
        entity.gt("id","0");
        entity.le("id",11);
        entity.ne("teacher_name","null_name");
        entity.like("teacher_name","tt");
        entity.notLike("teacher_pwd","sadas");
        entity.orderBy("id");
        return teacherMapper.selectList(entity);
    }

生成的sql語句：

組合的and和or條件查詢：

生成的sql語句：

SELECT id,teacher_name AS teacherName,teacher_pwd AS teacherPwd
 FROM teacher
 WHERE (id>1) OR (id=0 AND teacher_name='name' AND teacher_pwd IS NULL);

having和groupby查詢：

生成的sql語句：

SELECT id,teacher_name AS teacherName,teacher_pwd AS teacherPwd
 FROM teacher GROUP BY teacher_name HAVING (id>1);

除了常規的基於Mapper的直接操做數據庫操做功能之外，Mybatis-plus內部還提供了一個叫作IService的接口，內部含有不少豐富的CRUD操做功能能夠供開發人員調用：

/**
 * Copyright (c) 2011-2016, 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>
 * http://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.service;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;

/**
 * <p>
 * 頂級 Service
 * </p>
 *
 * @author hubin
 * @Date 2016-04-20
 */
public interface IService<T> {

    /**
     * <p>
     * 插入一條記錄（選擇字段，策略插入）
     * </p>
     *
     * @param entity 實體對象
     * @return boolean
     */
    boolean insert(T entity);

    /**
     * <p>
     * 插入一條記錄（所有字段）
     * </p>
     *
     * @param entity 實體對象
     * @return boolean
     */
    boolean insertAllColumn(T entity);

    /**
     * <p>
     * 插入（批量），該方法不適合 Oracle
     * </p>
     *
     * @param entityList 實體對象列表
     * @return boolean
     */
    boolean insertBatch(List<T> entityList);

    /**
     * <p>
     * 插入（批量）
     * </p>
     *
     * @param entityList 實體對象列表
     * @param batchSize  插入批次數量
     * @return boolean
     */
    boolean insertBatch(List<T> entityList, int batchSize);

    /**
     * <p>
     * 批量修改插入
     * </p>
     *
     * @param entityList 實體對象列表
     * @return boolean
     */
    boolean insertOrUpdateBatch(List<T> entityList);

    /**
     * <p>
     * 批量修改插入
     * </p>
     *
     * @param entityList 實體對象列表
     * @param batchSize
     * @return boolean
     */
    boolean insertOrUpdateBatch(List<T> entityList, int batchSize);

    /**
     * <p>
     * 批量修改或插入所有字段
     * </p>
     *
     * @param entityList 實體對象列表
     * @return boolean
     */
    boolean insertOrUpdateAllColumnBatch(List<T> entityList);

    /**
     * 批量修改或插入所有字段
     *
     * @param entityList 實體對象列表
     * @param batchSize
     * @return boolean
     */
    boolean insertOrUpdateAllColumnBatch(List<T> entityList, int batchSize);

    /**
     * <p>
     * 根據 ID 刪除
     * </p>
     *
     * @param id 主鍵ID
     * @return boolean
     */
    boolean deleteById(Serializable id);

    /**
     * <p>
     * 根據 columnMap 條件，刪除記錄
     * </p>
     *
     * @param columnMap 表字段 map 對象
     * @return boolean
     */
    boolean deleteByMap(Map<String, Object> columnMap);

    /**
     * <p>
     * 根據 entity 條件，刪除記錄
     * </p>
     *
     * @param wrapper 實體包裝類 {@link Wrapper}
     * @return boolean
     */
    boolean delete(Wrapper<T> wrapper);

    /**
     * <p>
     * 刪除（根據ID 批量刪除）
     * </p>
     *
     * @param idList 主鍵ID列表
     * @return boolean
     */
    boolean deleteBatchIds(Collection<? extends Serializable> idList);

    /**
     * <p>
     * 根據 ID 選擇修改
     * </p>
     *
     * @param entity 實體對象
     * @return boolean
     */
    boolean updateById(T entity);

    /**
     * <p>
     * 根據 ID 修改所有字段
     * </p>
     *
     * @param entity 實體對象
     * @return boolean
     */
    boolean updateAllColumnById(T entity);

    /**
     * <p>
     * 根據 whereEntity 條件，更新記錄
     * </p>
     *
     * @param entity  實體對象
     * @param wrapper 實體包裝類 {@link Wrapper}
     * @return boolean
     */
    boolean update(T entity, Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 whereEntity 條件，自定義set值更新記錄
     * </p>
     *
     * @param setStr  set值字符串
     * @param wrapper 實體包裝類 {@link Wrapper}
     * @return boolean
     */
    boolean updateForSet(String setStr, Wrapper<T> wrapper);

    /**
     * <p>
     * 根據ID 批量更新
     * </p>
     *
     * @param entityList 實體對象列表
     * @return boolean
     */
    boolean updateBatchById(List<T> entityList);

    /**
     * <p>
     * 根據ID 批量更新
     * </p>
     *
     * @param entityList 實體對象列表
     * @param batchSize  更新批次數量
     * @return boolean
     */
    boolean updateBatchById(List<T> entityList, int batchSize);

    /**
     * <p>
     * 根據ID 批量更新所有字段
     * </p>
     *
     * @param entityList 實體對象列表
     * @return boolean
     */
    boolean updateAllColumnBatchById(List<T> entityList);

    /**
     * <p>
     * 根據ID 批量更新所有字段
     * </p>
     *
     * @param entityList 實體對象列表
     * @param batchSize  更新批次數量
     * @return boolean
     */
    boolean updateAllColumnBatchById(List<T> entityList, int batchSize);

    /**
     * <p>
     * TableId 註解存在更新記錄，否插入一條記錄
     * </p>
     *
     * @param entity 實體對象
     * @return boolean
     */
    boolean insertOrUpdate(T entity);

    /**
     * 插入或修改一條記錄的所有字段
     *
     * @param entity 實體對象
     * @return boolean
     */
    boolean insertOrUpdateAllColumn(T entity);

    /**
     * <p>
     * 根據 ID 查詢
     * </p>
     *
     * @param id 主鍵ID
     * @return T
     */
    T selectById(Serializable id);

    /**
     * <p>
     * 查詢（根據ID 批量查詢）
     * </p>
     *
     * @param idList 主鍵ID列表
     * @return List<T>
     */
    List<T> selectBatchIds(Collection<? extends Serializable> idList);

    /**
     * <p>
     * 查詢（根據 columnMap 條件）
     * </p>
     *
     * @param columnMap 表字段 map 對象
     * @return List<T>
     */
    List<T> selectByMap(Map<String, Object> columnMap);

    /**
     * <p>
     * 根據 Wrapper，查詢一條記錄
     * </p>
     *
     * @param wrapper 實體對象
     * @return T
     */
    T selectOne(Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 Wrapper，查詢一條記錄
     * </p>
     *
     * @param wrapper {@link Wrapper}
     * @return Map<String,Object>
     */
    Map<String, Object> selectMap(Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 Wrapper，查詢一條記錄
     * </p>
     *
     * @param wrapper {@link Wrapper}
     * @return Object
     */
    Object selectObj(Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 Wrapper 條件，查詢總記錄數
     * </p>
     *
     * @param wrapper 實體對象
     * @return int
     */
    int selectCount(Wrapper<T> wrapper);

    /**
     * <p>
     * 查詢列表
     * </p>
     *
     * @param wrapper 實體包裝類 {@link Wrapper}
     * @return
     */
    List<T> selectList(Wrapper<T> wrapper);

    /**
     * <p>
     * 翻頁查詢
     * </p>
     *
     * @param page 翻頁對象
     * @return
     */
    Page<T> selectPage(Page<T> page);

    /**
     * <p>
     * 查詢列表
     * </p>
     *
     * @param wrapper {@link Wrapper}
     * @return
     */
    List<Map<String, Object>> selectMaps(Wrapper<T> wrapper);

    /**
     * <p>
     * 根據 Wrapper 條件，查詢所有記錄
     * </p>
     *
     * @param wrapper 實體對象封裝操做類（能夠爲 null）
     * @return List<Object>
     */
    List<Object> selectObjs(Wrapper<T> wrapper);

    /**
     * <p>
     * 翻頁查詢
     * </p>
     *
     * @param page    翻頁對象
     * @param wrapper {@link Wrapper}
     * @return
     */
    @SuppressWarnings("rawtypes")
    Page<Map<String, Object>> selectMapsPage(Page page, Wrapper<T> wrapper);

    /**
     * <p>
     * 翻頁查詢
     * </p>
     *
     * @param page    翻頁對象
     * @param wrapper 實體包裝類 {@link Wrapper}
     * @return
     */
    Page<T> selectPage(Page<T> page, Wrapper<T> wrapper);

}

在使用的過程當中，mybatis-plus還能兼容原有mybatis的xml和註解模式的sql拼寫功能。

mybatis-plus這種集mybatis與hibernate的優勢一塊兒的框架。提供了hibernate的單表CRUD操做的方便同時，又保留了mybatis的特性。

不得不說mybatis-plus的出現搭配上原有的mybatis框架極大的促進了開發效率的提高，同時基友搭配，效率翻倍。所以也有人把它們比作成魂鬥羅裏面的兩兄弟，基友搭配，效率翻倍。

本案例的代碼連接：

https://gitee.com/IdeaHome_admin/wfw