Mybatis-plus筆記（一）

Mybatis-plus學習筆記

在Springboot中使用mp並測試

在pom文件中引入如下依賴：(mp依賴和mysq依賴)

<!--mybatis-plus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
	<version>3.1.1</version>
</dependency>
<!--mysql驅動-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

基礎配置：

在application.yml中配置基本數據連接信息：

# DataSource Config
spring:
    datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/mp?useSSL=false&serverTimezone=GMT%2B8
        username: root
        password: root

# Logger Config
logging:
    level:
      com.neo: warn
      com.neo.mapper: trace
    pattern:
        console: '%p%m%n'

調入測試數據庫腳本：

/*
 Navicat Premium Data Transfer

 Source Server         : 本地數據庫
 Source Server Type    : MySQL
 Source Server Version : 50726
 Source Host           : localhost:3306
 Source Schema         : mp

 Target Server Type    : MySQL
 Target Server Version : 50726
 File Encoding         : 65001

 Date: 02/02/2020 21:11:32
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` bigint(20) NOT NULL COMMENT '主鍵',
  `name` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '姓名',
  `age` int(11) NULL DEFAULT NULL COMMENT '年齡',
  `email` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '郵箱',
  `manager_id` bigint(20) NULL DEFAULT NULL COMMENT '直屬上級id',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '創建時間',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `manager_fk`(`manager_id`) USING BTREE,
  CONSTRAINT `manager_fk` FOREIGN KEY (`manager_id`) REFERENCES `user` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1087982257332887553, '大boss', 40, '[e-mail]', NULL, '2019-01-11 14:20:20');
INSERT INTO `user` VALUES (1088248166370832385, '王天風', 25, '[e-mail]', 1087982257332887553, '2019-02-05 11:12:22');
INSERT INTO `user` VALUES (1088250446457389058, '李藝偉', 28, '[e-mail]', 1088248166370832385, '2019-02-14 08:31:16');
INSERT INTO `user` VALUES (1094590409767661570, '張雨琪', 31, '[e-mail]', 1088248166370832385, '2019-01-14 09:15:15');
INSERT INTO `user` VALUES (1094592041087729666, '劉紅雨', 32, '[e-mail]', 1088248166370832385, '2019-01-14 09:48:16');

SET FOREIGN_KEY_CHECKS = 1;

在Springboot的測試包中創建測試類，測試配置是否成功：

package com.neo;

import com.neo.mapper.UserMapper;
import com.neo.model.User;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.SQLOutput;
import java.util.List;

/**
 * @author Alex
 * @create 2020-02-02 20:37
 **/
@RunWith(SpringRunner.class)
@SpringBootTest
public class SimpleTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void select(){
        List<User> users = userMapper.selectList(null);
        Assert.assertEquals(5,users.size());
        users.forEach(System.out::println);
    }

}

測試結果：

User(id=1087982257332887553, name=大boss, age=40, email=[e-mail], managerId=null, createTime=2019-01-11T14:20:20)
User(id=1088248166370832385, name=王天風, age=25, email=[e-mail], managerId=1087982257332887553, createTime=2019-02-05T11:12:22)
User(id=1088250446457389058, name=李藝偉, age=28, email=[e-mail], managerId=1088248166370832385, createTime=2019-02-14T08:31:16)
User(id=1094590409767661570, name=張雨琪, age=31, email=[e-mail], managerId=1088248166370832385, createTime=2019-01-14T09:15:15)
User(id=1094592041087729666, name=劉紅雨, age=32, email=[e-mail], managerId=1088248166370832385, createTime=2019-01-14T09:48:16)

通用mapper

新增（Create)

◆新增方法

UserMapper代碼：

package com.neo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.neo.model.User;
import org.apache.ibatis.annotations.Mapper;

//要使用mp,就要集成BaseMapper
@Mapper
public interface UserMapper extends BaseMapper<User> {

}

在測試方法中調用userMapper中的insert方法：

 @Test
    public void insert(){
        User user = new User();
        user.setName("黃小明");
        user.setAge(20);
        user.setManagerId(1088248166370832385L);
        user.setCreateTime(LocalDateTime.now());
        int rows = userMapper.insert(user);
        System.out.println("影響記錄數："+rows);

    }

測試結果：

DEBUG==>  Preparing: INSERT INTO user ( id, name, age, manager_id, create_time ) VALUES ( ?, ?, ?, ?, ? ) 
DEBUG==> Parameters: 1223961279246393345(Long), 黃小明(String), 20(Integer), 1088248166370832385(Long), 2020-02-02T21:28:03.621(LocalDateTime)
DEBUG<==    Updates: 1
影響記錄數：1

◆常用注解

@TabName注解

當修改數據庫表明卻不想修改實體類型時，可以通過@TabName("數據庫表名")來指定表名，否則會運行報錯

@Data
@TableName("mp_user")
public class User {
    //主鍵
    private Long id;
    //姓名
    private String name;
    //年齡
    private Integer age;
    //郵箱
    private String email;
    //直屬上級
    private Long managerId;
    //創建時間
    private LocalDateTime createTime;
}

@TabId注解

當實例中主鍵與數據庫中的主鍵名稱不一致時（例如實例中為駝峰命名，數據庫表中為下划線命名），可使用該注解

@TableField注解

當實例中的字段與數據庫中的字段不同時，就可以使用該注解映射，如下例：

 @TableField("name")
 private String realName;

◆排除非表字段的三種方式

第一種方法：在聲明類屬性時使用 transient 關鍵字聲明

第二種方法：如上方法可能無法序列化該字段，故可以在聲明類屬性時：使用 static 關鍵字聲明為靜態變量（注意，用static 聲明的靜態變量lombok不會為其添加set和get方法）

第三種方法：使用@TableField（exist = true）注解注解 其中括號中的 exist = true 表示該字段不是數據庫表中的字段，無需映射

查詢（Retrieve)

◆基本查詢方法

通過id查詢：selectById()方法

 @Test
    public void selectById() {
        User user = userMapper.selectById(1094590409767661570L);
        System.out.println(user);

    }

批量查詢：selectBatchIds（）

@Test
    public void selectByIds() {
        List<Long> idsList = Arrays.asList(1094592041087729666L, 1223961279246393345L, 1088250446457389058L);
        List<User> users = userMapper.selectBatchIds(idsList);
        users.forEach(System.out::println);
    }

通過map查詢：

   @Test
    public void selectByMap() {
        Map<String,Object> columnMap = new HashMap<>();
        columnMap.put("name","王天風");
        columnMap.put("age",25);
        //通過此map會執行類似 where name="王天風" and age=25 的sql
        List<User> userList = userMapper.selectByMap(columnMap);
        userList.forEach(System.out::println);
    }

注意：此map中的鍵名為數據表中列名，並非實體類中的屬性名

◆以條件構造器為參數的查詢方法

 /* 查詢要求：
        1、名字中包含雨並且年齡小於40
        name like '%雨%' and age<40
     */
    @Test
    public void selectByWrapper() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //等同於
        //QueryWrapper<User> query = Wrappers.<User>query();
        queryWrapper.like("name","雨").lt("age",40);
        //注意：此處的鍵名依舊為數據庫中的列名
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

 /*
    2、名字中包含雨年並且齡大於等於20且小於等於40並且email不為空
   name like '%雨%' and age between 20 and 40 and email is not null

     */
    @Test
    public void selectByWrapper2() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //等同於
        //QueryWrapper<User> query = Wrappers.<User>query();
        queryWrapper.like("name","雨").between("age",20,40).isNotNull("email");
        //注意：此處的鍵名依舊為數據庫中的列名
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

/*
    3、名字為王姓或者年齡大於等於25，按照年齡降序排列，年齡相同按照id升序排列
   name like '王%' or age>=25 order by age desc,id asc

     */
    @Test
    public void selectByWrapper3() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //等同於
        //QueryWrapper<User> query = Wrappers.<User>query();
        queryWrapper.likeRight("name","王").or()
                .ge("age",25).orderByDesc("age").orderByAsc("id");

        //注意：此處的鍵名依舊為數據庫中的列名
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

/*
    4、創建日期為2019年2月14日並且直屬上級為名字為王姓
      date_format(create_time,'%Y-%m-%d')='2019-02-14' and manager_id in (select id from user where name like '王%')
     */
    @Test
    public void selectByWrapper4() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //等同於
        //QueryWrapper<User> query = Wrappers.<User>query();
        queryWrapper.apply("date_format(create_time,'%Y-%m-%d')={0}","2019-02-14")
                .inSql("manager_id","select id from user where name like '王%'");

        //注意：此處的鍵名依舊為數據庫中的列名
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }
//注意：以上方法查詢為推薦查詢，不建議寫如下方式查詢：會導致sql注入風險
//queryWrapper.apply("date_format(create_time,'%Y-%m-%d')="2019-02-14")

/*
    5、名字為王姓並且（年齡小於40或郵箱不為空）
    name like '王%' and (age<40 or email is not null)
     */
    @Test
    public void selectByWrapper5() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //等同於
        //QueryWrapper<User> query = Wrappers.<User>query();
        queryWrapper.likeRight("name","王").
                and(wq->wq.lt("age",40)
                .or().isNotNull("email"));
        //注意：此處的鍵名依舊為數據庫中的列名
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

  /*
    6、名字為王姓或者（年齡小於40並且年齡大於20並且郵箱不為空）
    name like '王%' or (age<40 and age>20 and email is not null)
     */
    @Test
    public void selectByWrapper6() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //等同於
        //QueryWrapper<User> query = Wrappers.<User>query();
        queryWrapper.likeRight("name","王")
                .or(wq->wq.lt("age",40).gt("age",20).isNotNull("email"));

        //注意：此處的鍵名依舊為數據庫中的列名
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

/*
    7、（年齡小於40或郵箱不為空）並且名字為王姓
    (age<40 or email is not null) and name like '王%'
     */
    @Test
    public void selectByWrapper7() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //等同於
        //QueryWrapper<User> query = Wrappers.<User>query();
        queryWrapper.nested(wq->wq.lt("age",40).or().
                isNotNull("email"))
                .likeRight("name","王");
        //注意：此處的鍵名依舊為數據庫中的列名
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

  /*
    8、年齡為30、31、34、35
    age in (30、31、34、35)

     */
    @Test
    public void selectByWrapper8() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //等同於
        //QueryWrapper<User> query = Wrappers.<User>query();
      queryWrapper.in("age",Arrays.asList(30,31,34,35));
        //注意：此處的鍵名依舊為數據庫中的列名
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

◆select中字段不全出現的處理方法

並非每次查詢都要查詢所有字段，測試可用如下方法查詢

 /*
          10、名字中包含雨並且年齡小於40(需求1加強版)
        第一種情況：select id,name
                       from user
                       where name like '%雨%' and age<40

       */
      @Test
      public void selectByWrapperSuper() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("id","name").like("name","雨").lt("age",40);
        List<User> userList =userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
      }
      /*
      第二種情況：select id,name,age,email
                       from user
                       where name like '%雨%' and age<40
       */
    @Test
    public void selectByWrapperSuper2() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name","雨").lt("age",40)
        .select(User.class,info->!info.getColumn().equals("create_time")
                &&!info.getColumn().equals("manager_id"));
        List<User> userList =userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

◆條件構造器中condition作用

@Test
    public void testCondition() {
        String name="王";
        String email="";
        condition(name,email);
    }

    public void condition(String name,String email){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//       if(StringUtils.isNotEmpty(name)){
//           queryWrapper.like("name",name);
//       }
//        if(StringUtils.isNotEmpty(email)){
//            queryWrapper.like("email",email);
//        }
        //以上代碼過於臃腫，可采用如下代碼代替
        queryWrapper.like(StringUtils.isNotEmpty(name),"name",name)
                .like(StringUtils.isNotEmpty(email),"email",email);

        List<User> userList =userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

◆創建條件構造器時傳入實體對象

  @Test
    public void selectByWrapperEntity() {
        User whereUser = new User();
        whereUser.setName("劉紅雨");
        whereUser.setAge(32);
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>(whereUser);
        List<User> userList =userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

◆條件構造器中allEq用法

 @Test
    public void selectByWrapperAllEq() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        Map<String,Object> params = new HashMap<String,Object>();
        params.put("name","王天風");
        params.put("age","25");
        queryWrapper.allEq(params);
        List<User> userList =userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

◆其他以條件構造器為參數的查詢方法

  @Test
    public void selectByWrapperMaps() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        queryWrapper.select("id","name").like("name","雨").lt("age",40);
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);

    }

selectMaps:

/*
            按照直屬上級分組，查詢每組的平均年齡、最大年齡、最小年齡。
            並且只取年齡總和小於500的組。
            select avg(age) avg_age,min(age) min_age,max(age) max_age
            from user
            group by manager_id
            having sum(age) <500
     */
    @Test
    public void selectByWrapperMaps2() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

        queryWrapper.select("avg(age) avg_age","min(age) min_age","max(age) max_age")
        .groupBy("manager_id").having("sum(age)<{0}",500);

        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);

    }

selectObjs:

@Test
    public void selectByWrapperObjs() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

        queryWrapper.select("id","name").like("name","雨").lt("age",40);
        List<Object> userList = userMapper.selectObjs(queryWrapper);
        userList.forEach(System.out::println);

    }

selectCount :

  @Test
    public void setUserMapperCount() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

        queryWrapper.like("name","雨").lt("age",40);
        int count = userMapper.selectCount(queryWrapper);
        System.out.println(count);
    }

◆Lambda條件構造器

創建lambda條件構造器有兩種方法

​ 第一種：

LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();

第二種：直接new 一個lambda條件構造器

LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();

第三種：

LambdaQueryWrapper<User> LambdaQuery = Wrappers.<User>lambdaQuery();

  @Test
    public void selectLambda() {
//        LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();
//        LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
        LambdaQueryWrapper<User> lambdaQuery = Wrappers.<User>lambdaQuery();

        lambdaQuery.like(User::getName,"雨").lt(User::getAge,40);
        //where name like '%雨%' and age <40
        List<User> userList = userMapper.selectList(lambdaQuery);
        userList.forEach(System.out::println);
    }

◆使用條件構造器的自定義SQL

(要求版本大於等於3.0.7)

在UserMapper中定於接口方法（采用注解的方式）

 @Select("select * from user ${ew.customSqlSegment}")
 List<User> selectAll(@Param(Constants.WRAPPER)Wrapper<User> wrapper);

在測試中使用自定義方法：

    @Test
    public void selectMy() {
//        LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();
//        LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
        LambdaQueryWrapper<User> lambdaQuery = Wrappers.<User>lambdaQuery();

        lambdaQuery.like(User::getName,"雨").lt(User::getAge,40);
        //where name like '%雨%'
        List<User> userList = userMapper.selectAll(lambdaQuery);//此處使用自定義接口方法
        userList.forEach(System.out::println);

    }

如果不想把自定義sql寫在接口中，例如寫在xml中，還可以采用如下方法：

第一步：在yml配置文件中配置接口對應的xml路徑

Mybatis-plus:
  mapper-locations: classpath:mp/mapper/*.xml

​ 在配置路徑下新建UserMapper.xml文件,同時去除接口中的注解sql

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.neo.mapper.UserMapper" >
    <select id="selectAll" resultType="com.neo.model.User">
        select * from user ${ew.customSqlSegment}
    </select>
</mapper>

◆MyBatis分頁介紹

mybatis中提供分頁方法，但是該分頁是邏輯分頁，而非物理分頁。

◆MP分頁插件實現物理分頁

新建配置包(com.neo.configuration)並新建配置分頁類MybatisPlusConfig：

@Configuration
public class MybatisPlusConfig {
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

測試（selectPage）：

 @Test
    public void selectPage() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        queryWrapper.ge("age", 26);
        Page<User> page = new Page<>(1, 2);
        IPage<User> iPage = userMapper.selectPage(page, queryWrapper);
        System.out.println("總頁數:" + iPage.getPages());
        System.out.println("總記錄數:" + iPage.getTotal());
        List<User> userlist = iPage.getRecords();
        userlist.forEach(System.out::println);
    }

運行日志：

DEBUG==>  Preparing: SELECT COUNT(1) FROM user WHERE age >= ? 
DEBUG==> Parameters: 26(Integer)
TRACE<==    Columns: COUNT(1)
TRACE<==        Row: 7
DEBUG==>  Preparing: SELECT id,name,age,email,manager_id,create_time FROM user WHERE age >= ? LIMIT ?,? 
DEBUG==> Parameters: 26(Integer), 0(Long), 2(Long)
TRACE<==    Columns: id, name, age, email, manager_id, create_time
TRACE<==        Row: 1087982257332887553, 大boss, 40, [e-mail], null, 2019-01-11 14:20:20
TRACE<==        Row: 1088250446457389058, 李藝偉, 28, [e-mail], 1088248166370832385, 2019-02-14 08:31:16
DEBUG<==      Total: 2
總頁數:4
總記錄數:7
User(id=1087982257332887553, name=大boss, age=40, email=[e-mail], managerId=null, createTime=2019-01-11T14:20:20)
User(id=1088250446457389058, name=李藝偉, age=28, email=[e-mail], managerId=1088248166370832385, createTime=2019-02-14T08:31:16)

測試(selectMapsPage):

    @Test
    public void selectPage() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
//        queryWrapper.ge("age",26);
        Page<User> page = new Page<>(1, 2);
//        IPage<User> iPage = userMapper.selectPage(page, queryWrapper);
//        System.out.println("總頁數:"+ iPage.getPages());
//        System.out.println("總記錄數:"+ iPage.getTotal());
//        List<User> userlist = iPage.getRecords();
        IPage<Map<String, Object>> iPage = userMapper.selectMapsPage(page, queryWrapper);
        System.out.println("總頁數:"+ iPage.getPages());
        System.out.println("總記錄數:"+ iPage.getTotal());
        List<Map<String, Object>> userlist = iPage.getRecords();
        userlist.forEach(System.out::println);
    }

DEBUG==>  Preparing: SELECT COUNT(1) FROM user 
DEBUG==> Parameters: 
TRACE<==    Columns: COUNT(1)
TRACE<==        Row: 13
DEBUG==>  Preparing: SELECT id,name,age,email,manager_id,create_time FROM user LIMIT ?,? 
DEBUG==> Parameters: 0(Long), 2(Long)
TRACE<==    Columns: id, name, age, email, manager_id, create_time
TRACE<==        Row: 1087982257332887553, 大boss, 40, [e-mail], null, 2019-01-11 14:20:20
TRACE<==        Row: 1088248166370832385, 王天風, 25, [e-mail], 1087982257332887553, 2019-02-05 11:12:22
DEBUG<==      Total: 2
總頁數:7
總記錄數:13
{createTime=2019-01-11 14:20:20.0, name=大boss, id=1087982257332887553, age=40, email=[e-mail]}
{createTime=2019-02-05 11:12:22.0, name=王天風, id=1088248166370832385, managerId=1087982257332887553, age=25, email=[e-mail]}

從以上兩個例子看以看出每個是執行了兩條sql語句，如果只想要查詢結果，不想要查詢總數，只需要將page的第三個參數變為false，即可：

Page<User> page = new Page<>(1, 2,false);

當我們在做多表聯查時，就不能使用如上方式查詢了，此時可以在xml文件中自定義sql:

更新（Update)

◆根據id更新

    @Test
    public void updateById(){
        User user= new User();
        user.setId(1088248166370832385L);
        user.setAge(26);
        user.setEmail("[e-mail]");
        int rows = userMapper.updateById(user);
        System.out.println("影響記錄數："+ rows);
    }

運行日志：

DEBUG==>  Preparing: UPDATE user SET age=?, email=? WHERE id=? 
DEBUG==> Parameters: 26(Integer), [e-mail](String), 1088248166370832385(Long)
DEBUG<==    Updates: 1
影響記錄數：1

◆以條件構造器作為參數的更新方法

 @Test
    public void updateByWrapper(){
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("name","李藝偉").eq("age",28);
        User user = new User();
        user.setEmail("[e-mail]");
        user.setAge(29);
        int rows = userMapper.update(user, updateWrapper);
        System.out.println("影響行數："+rows
        );

    }
運行日志：
DEBUG==>  Preparing: UPDATE user SET age=?, email=? WHERE name = ? AND age = ? 
DEBUG==> Parameters: 29(Integer), [e-mail](String), 李藝偉(String), 28(Integer)
DEBUG<==    Updates: 1
影響行數：1

◆條件構造器中set方法使用

(只修改少量字段時)：

    @Test
    public void updateByWrapper(){
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        //通過條件構造器的鏈式編程設置更新信息
        updateWrapper.eq("name","李藝偉").eq("age",29).set("email","[e-mail]");
		//   User user = new User();

        int rows = userMapper.update(null, updateWrapper);
        System.out.println("影響行數："+rows
        );

    }

lambda條件構造器更新：

    @Test
    public void updateByWrapperLambda(){
        LambdaUpdateWrapper<User> lambdaUpdate = Wrappers.<User>lambdaUpdate();
        lambdaUpdate.eq(User::getName,"李藝偉").eq(User::getAge,29).set(User::getAge,31);
        int rows = userMapper.update(null, lambdaUpdate);
        System.out.println("影響行數："+rows);
    }

刪除（Delete)

◆根據id刪除的方法

  @Test
    public void deleteById() {
       int rows= userMapper.deleteById(1223976086888599553L);
        System.out.println("影響行數："+rows);
    }

根據id批量刪除：

    @Test
    public void deleteBatchIds() {
        int rows =  userMapper.deleteBatchIds(
                Arrays.asList(1223973741031141377L,
                1223972327026405378L,1223970002606067714L));

        System.out.println("影響行數："+rows);
    }

◆其他普通刪除方法

    @Test
    public void deleteByMap() {
        Map<String,Object> columnMap= new HashMap<>();
        columnMap.put("name","向后");
        columnMap.put("age","31");
        int rows = userMapper.deleteByMap(columnMap);
        System.out.println("影響行數："+rows);
    }

◆以條件構造器為參數的刪除方法

ActiveRecord模式

AR探索

​ ◆AR模式簡介

​ ◆MP中AR模式的實現