magic__Coder
magic__Coder

MyBatis-Plus实战（Spring Boot集成）

1.为何MyBatis-Plus

在Spring框架风靡java开发的今天，java应用的持久层框架主要有MyBatis和JPA（Spring Data JPA）。熟悉这两个框架的开发者很容易就能总结出以下结论：

  • MyBatis优势

    • SQL语句可以自由控制，更灵活，性能较高。
    • SQL与代码分离，易于阅读和维护
    • 提供XML标签，支持编写动态SQL语句

  • JPA优势

    • JPA移植性比较好（JPQL）
    • 提供了很多CRUD方法，开发效率高
    • 对象化程度更高

对比这两个框架的优势，也可以很容易发现MyBatis的劣势：

  • MyBatis劣势
    • 简单CRUD操作还得写SQL语句
    • 项目中有大量SQL需要维护
    • MyBatis自身功能很有限，但支持Plugin

那么，有没有一种框架可以结合这两个框架的优势，使得我们开发应用的效率可以大大提高，又可以灵活、好维护呢？答案正是我们今天要讨论的主角：MyBatis-Plus。

MyBatis-Plus 荣获【2018年度开源中国最受欢迎的中国软件】 TOP5 ：

本文将以一个简单的例子来讲解MyBatis-Plus在项目开发中的应用。

2.何为MyBatis-Plus

MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

MyBatis-Plus官方的愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍。

MyBatis-Plus实战（Spring Boot集成）_第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 操作智能分析阻断，也可自定义拦截规则，预防误操作

以下是MP的框架结构：

MyBatis-Plus实战（Spring Boot集成）_第2张图片

3.Spring Boot集成

在Spring Boot中集成MP是一件非常简单的事，只需要引入MP官方提供的starter依赖即可：

<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-boot-starterartifactId>
    <version>3.2.0version>
dependency>
  • 注：引入 MyBatis-Plus 之后请不要再次引入 MyBatis 以及 MyBatis-Spring，以避免因版本差异导致的问题。
  • 全新的 MyBatis-Plus 3.0 版本基于 JDK8，提供了 lambda 形式的调用，所以安装集成 MP3.0 要求如下：
    • JDK 8+
    • Maven or Gradle
  • 当然，数据库连接用到的connector以及数据源spring.datasource的配置也是必不可少的。

4.MP实战

在正式进入实战之前，我们先设计一套用来操作的数据库：

现有一张Team表，其表数据如下：

id name city
1 Lakers Los Angeles
2 Warriors Golden State
3 Raptors Toronto
4 Bucks Milwaukee
5 Spurs San Antonio

对应的数据库Schema脚本如下：

DROP TABLE IF EXISTS team;

CREATE TABLE team
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '球队名称',
    city VARCHAR(30) NULL DEFAULT NULL COMMENT '所在城市',
    PRIMARY KEY(id)
);

对应的数据库 Data 脚本如下：

DELETE FROM team;

INSERT INTO team(id, name, city) VALUES
(1, 'Lakers', 'Los Angeles'),
(2, 'Warriors', 'Golden State'),
(3, 'Raptors', 'Toronto'),
(4, 'Bucks', 'Milwaukee'),
(5, 'Spurs', 'San Antonio');

另外，用作多表关联实战，还有一张Player表，其表部分数据如下：

id team_id name no
1001 1 Rejon Rondo 9
2001 2 Stephen Curry 30
3001 3 Kyle Lowry 7
4001 4 George Hill 3
5001 5 Tony Parker 9

对应的数据库Schema脚本如下：

DROP TABLE IF EXISTS player;

CREATE TABLE player
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    team_id BIGINT(20) DEFAULT NULL COMMENT '所属球队ID',
    name VARCHAR(50) DEFAULT NULL COMMENT '球员名称',
    no INT(3) DEFAULT NULL COMMENT '球员号码',
    PRIMARY KEY(id)
);

对应的数据库 Data 脚本如下：

DELETE FROM player;

INSERT INTO player(id, team_id, name, no) VALUES
(1001, 1, 'Rejon Rondo', 9),
(1002, 1, 'Danny Green', 14),
(1003, 1, 'LeBron James', 23),
(1004, 1, 'Anthony Davis', 3),
(1005, 1, 'Dwight Howard', 39),
(1006, 1, 'Kyle Kuzma', 0),
(1007, 1, 'DeMarcus Cousins', 15),
(1008, 1, 'JaVale McGee', 7),
(1009, 1, 'Jared Dudley', 10),
(1010, 1, 'Kentavious Caldwell-Pope', 1),
(1011, 1, 'Avery Bradley', 11),
(1012, 1, 'Quinn Cook', 2),

(2001, 2, 'Stephen Curry', 30),
(2002, 2, 'Angelo Russell', 0),
(2003, 2, 'Klay Thompson', 11),
(2004, 2, 'Draymond Green', 23),
(2005, 2, 'Willie Cauley Stein', 2),

(3001, 3, 'Kyle Lowry', 7),
(3002, 3, 'Fan Jordon', 23),
(3003, 3, 'Pascal Siakam', 43),
(3004, 3, 'Serge Ibaka', 9),
(3005, 3, 'Marc Gasol', 33),

(4001, 4, 'George Hill', 3),
(4002, 4, 'Eric Bledsoe', 6),
(4003, 4, 'Khris Middleton', 22),
(4004, 4, 'The Alphabet', 34),
(4005, 4, 'Robin Lopez', 42),

(5001, 5, 'Tony Parker', 9),
(5002, 5, 'Patty Mills', 8),
(5003, 5, 'Manu Ginobili', 20),
(5004, 5, 'Boris Diaw', 33),
(5005, 5, 'Tim Duncan', 21),

(0001, NULL, 'Carmelo Anthony', NULL),
(0002, NULL, 'JR Smith', NULL),
(0003, NULL, 'Kenneth Faried', NULL),
(0004, NULL, 'Tyreke Evans', NULL),
(0005, NULL, 'Joakim Noah', NULL);

这两张表很简单，Player表通过tearm_id属性外键关联Team表。最后还需要在我们的Spring Boot准备这两个实体的DO类：

public class Team {

    private Long id;
    private String name;
    private String city;

    // getters and setters
}

public class Player {

    private Long id;
    private Long teamId;
    private String name;
    private Integer no;

    // getters and setters
}
  • 建议在项目中引入Lombok框架，可以省去定义pojo的getter和setter的繁琐工作，代码也更简洁。

4.1通用Mapper - CRUD接口

为了可以看到MP操作数据库时使用的SQL语句，需要把mapper包或者项目日志级别logging.level配置为TRACE。

说明:

  • 通用 CRUD 封装BaseMapper接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
  • 泛型 T 为任意实体对象
  • 参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
  • 对象 Wrapper 为 条件构造器

DAO层的数据库操作接口通过继承通用Mappercom.baomidou.mybatisplus.core.mapper.BaseMapper来使用MP提供的CRUD能力，使得我们可以不用写SQL语句，更简便的操作数据库。我们先来看看**通用Mapper（BaseMapper）**的源码：

MyBatis-Plus实战（Spring Boot集成）_第3张图片

可以看到通用Mapper提供了很多应对各种业务需求的数据库操作，现在我们先创建之前提到的两个DO类对应的DAO操作类：

public interface TeamMapper extends BaseMapper<Team> {
}

public interface PlayerMapper extends BaseMapper<Player> {
}

非常简单，我们现在一行代码都不需要。接下来我们还需要在Spring Boot启动类中使用@MapperScan配置Mapper包扫描。下面我们对Mapper的操作进行一一介绍。

4.1.1C - Insert操作

  • Insert相关方法：
    • int insert(T entity);// 插入一条记录

现在我们直接使用单元测试的方式给Team表插入一个新的球队：

@SpringBootTest
class TeamMapperTest {

    @Autowired
    private TeamMapper teamMapper;

    @Test
    public void testInsert() {
        Team team = new Team();
        team.setName("Cavaliers");
        team.setCity("Cleveland");
        int result = teamMapper.insert(team);
        Assertions.assertEquals(1, result);
    }

}
  • 如果单元测试成功，说明我们的Spring Boot集成MyBatis-Plus环境成功。

我们现在查看数据库，Team表中确实多了一条记录，但是id这一列是一长串数字（当然你运行的结果跟我的很大概率是不一样的数字），即使你设置了表主键是自增长策略，依然是这个情况。

MyBatis-Plus实战（Spring Boot集成）_第4张图片

这是因为MP的默认主键策略起的作用。

MP主键策略

值 描述
AUTO 数据库自增
INPUT 自行输入
ID_WORKER 分布式全局唯一ID 长整型类型
UUID 32位UUID字符串
NONE 无状态
ID_WORKER_STR 分布式全局唯一ID 字符串类型

MP默认的主键策略是ID_WORKER，所以我们Insert操作生成的数据id为一串数字。要修改MP的主键策略，可以通过全局和局部的配置。

全局配置主键是MP配置项（MP配置大全）的一部分，通过在Spring Boot的配置文件中配置mybatis-plus.global-config.db-config.id-type即可。

局部配置则是通过一个成员变量注解@TableId来实现，以下是该注解的描述：

属性 类型 必须指定 默认值 描述
value String 否 “” 主键字段名
type Enum 否 IdType.NONE 主键类型
  • TableId注解除了声明Id策略的type外，还有一个名为value的属性，这个属性定义的是当我们的数据表实体的主键名。在MP中，默认的数据库主键名为id，如果我们表实体主键不是起名为id，那么我们就需要配置这个属性。

我们可以看到，声明的DO类默认的Id策略是NONE，这个时候就受全局配置的影响。我们可以尝试把MP全局主键策略配置为AUTO，即自增长策略，注意，这时也需要数据表启用自增长策略。

  • 对于Insert操作，MP默认会把entity所有的属性转换成数据表的列来插入，如果设计的DO类中有非表字段的属性，那么insert操作就会报错，为了避免这种情况，可以在非数据表字段的属性添加@TableField(exist = false)注解来设置非数据库表字段。

4.1.2R - Select操作

  • Select相关方法：
    • T selectById(Serializable id);// 根据 ID 查询
    • List selectBatchIds(@Param(Constants.COLLECTION) Collection idList);// 根据 ID 查询
    • List selectByMap(@Param(Constants.COLUMN_MAP) Map columnMap);// 查询（根据 columnMap 条件）
    • T selectOne(@Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据 entity 条件，查询一条记录
    • Integer selectCount(@Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据 Wrapper 条件，查询总记录数
    • List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据 entity 条件，查询全部记录
    • List> selectMaps(@Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据 Wrapper 条件，查询全部记录
    • List selectObjs(@Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
    • IPage selectPage(IPage page, @Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据 entity 条件，查询全部记录（并翻页）
    • IPage> selectMapsPage(IPage page, @Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据 Wrapper 条件，查询全部记录（并翻页）

      • MP中的Select和Delete都提供了多种操作，总的来说可以分成根据Id操作、根据columnMap操作（Map设置表字段和值）和根据Wrapper操作（Wrapper是MP提供的条件构造器，可以实现很强大的功能）。上面最后两个是关于分页的查询，这部分将在本文后面进行讲解。

      根据Id和根据columnMap操作相对比较简单，实现的功能也相对有限，这里先看几个例子：

      @Test
public void testSelectById() {
    // 查找Id为1的球队
    Team team = teamMapper.selectById(1L);
    // MP执行的SQL：
    // Preparing: SELECT id,city,name FROM team WHERE id=?
    // Parameters: 1(Long)
    Assertions.assertNotNull(team);

    // 查找Id为1、2、3的球队
    List<Team> teamList = teamMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
    // MP执行的SQL：
    // Preparing: SELECT id,city,name FROM team WHERE id IN ( ? , ? , ? )
    // Parameters: 1(Long), 2(Long), 3(Long)
    Assertions.assertNotEquals(0, teamList.size());
}

@Test
public void testSelectByMap() {
    // 查找洛杉矶的球队
    Map<String, Object> columnMap = new HashMap<>();
    columnMap.put("city", "Los Angeles");   // Key值为数据库列名
    List<Team> teamList = teamMapper.selectByMap(columnMap);
    // MP执行的SQL：
    // Preparing: SELECT id,city,name FROM team WHERE city = ?
    // Parameters: Los Angeles(String)
    Assertions.assertNotEquals(0, teamList.size());
}

      如果想要实现复杂的操作比如聚合、投影等操作，就要使用高级的**条件构造器（Wrapper）**方法了。

      条件构造器

      MP关于条件构造器主要涉及到AbstractWrapper、QueryWrapper(LambdaQueryWrapper)和UpdateWrapper(LambdaUpdateWrapper)。

      • AbstractWrapper
        • QueryWrapper(LambdaQueryWrapper)和UpdateWrapper(LambdaUpdateWrapper)的父类，用于生成sql的where条件，entity属性也用于生成sql的where条件。
        • 注意：entity生成的where条件与使用各个api生成的where条件没有任何关联行为。
      • QueryWrapper
        • 继承自AbstractWrapper，自身的内部属性entity也用于生成where条件，LambdaQueryWrapper可以通过new QueryWrapper().lambda()方法获取。
      • UpdateWrapper
        • 继承自AbstractWrapper，自身的内部属性entity也用于生成where条件，LambdaUpdateWrapper可以通过new UpdateWrapper().lambda()方法获取。

      条件构造器包含了基本上所有的SQL操作，光看概念会有点抽象，接下来我们用一些实际的例子来近距离感受下条件构造器的强大功能。

      一些例子
      @SpringBootTest
class PlayerMapperTest {

    @Autowired
    private PlayerMapper playerMapper;

    /*
    1.球员姓名包含Kyle且号码小于40的球员
    name LIKE '%Kyle%' AND no < 40
     */
    @Test
    public void testQuery1() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.like("name", "Kyle").lt("no", 40);

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? AND no < ?)
        // Parameters: %Kyle%(String), 40(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    2.球员姓名包含Kyle且号码大于等于0且小于等于20并且team_id不为空
    name LIKE '%Kyle%' AND no BETWEEN 20 AND 40 AND team_id IS NOT NULL
     */
    @Test
    public void testQuery2() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.like("name", "Kyle")
                    .between("no", 0, 20)
                    .isNotNull("team_id");

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? AND no BETWEEN ? AND ? AND team_id IS NOT NULL)
        // Parameters: %Kyle%(String), 0(Integer), 20(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    3.球员姓名以Anthony开头或者球员号码大于等于25，按照号码降序排序，号码相同按照team_id升序排序
    name LIKE 'Anthony%' OR no >= 25 ORDER BY no DESC, team_id ASC
     */
    @Test
    public void testQuery3() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.likeRight("name", "Anthony")   // 以 LIKE 'X%' 形式
                    .or().gt("no", 25)  // 调用 .or() 即可以 or 形式连接
                    .orderByDesc("no")
                    .orderByAsc("team_id");

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? OR no > ?) ORDER BY no DESC , team_id ASC
        // Parameters: Anthony%(String), 25(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    4.球员姓名包含Anthony并且所属球队为Lakers
    name LIKE '%Anthony%' AND team_id IN (SELECT id FROM team WHERE name = 'Lakers')
     */
    @Test
    public void testQuery4() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.like("name", "Anthony")
                    .inSql("team_id", "SELECT id FROM team WHERE name = 'Lakers'"); // in 操作

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? AND team_id IN (SELECT id FROM team WHERE name = 'Lakers'))
        // Parameters: %Anthony%(String)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    5.球员姓名包含Kyle并且（球员号码小于40或者team_id不为空）
    name LIKE '%Kyle%' AND (no < 40 OR team_id IS NOT NULL)
     */
    @Test
    public void testQuery5() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.like("name", "Kyle")
                    // .and(qw -> qw.lt("no", 40).or().isNotNull("team_id"))    // AND 嵌套
                    .nested(qw -> qw.lt("no", 40).or().isNotNull("team_id"));   // 正常嵌套 不带 AND 或者 OR

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? AND ( (no < ? OR team_id IS NOT NULL) ))
        // Parameters: %Kyle%(String), 40(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    6.球员姓名以Kyle开头或者（球员号码小于40并且号码大于0并且team_id不为空）
    name LIKE 'Kyle%' AND (no < 40 AND no > 0 AND team_id IS NOT NULL)
     */
    @Test
    public void testQuery6() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.likeRight("name", "Kyle")
                // .or(qw -> qw.lt("no", 40).gt("no", 0).isNotNull("team_id"))    // OR 嵌套
                .or().nested(qw -> qw.lt("no", 40).gt("no", 0).isNotNull("team_id"));   // 正常嵌套 不带 AND 或者 OR

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? OR ( (no < ? AND no > ? AND team_id IS NOT NULL) ))
        // Parameters: Kyle%(String), 40(Integer), 0(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    7.（球衣号码小于40或team_id不为空）并且姓名以LeBron开头
    (no < 40 OR team_id IS NOT NULL) AND name LIKE 'LeBron%'
     */
    @Test
    public void testQuery7() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.nested(qw -> qw.lt("no", 40).or().isNotNull("team_id"))
                    .likeRight("name", "LeBron");

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (( (no < ? OR team_id IS NOT NULL) ) AND name LIKE ?)
        // Parameters: 40(Integer), LeBron%(String)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    8.球员号码为3, 13, 23, 33
    no in (3, 13, 23, 33)
     */
    @Test
    public void testQuery8() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.in("no", Arrays.asList(3, 13, 23, 33));

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (no IN (?,?,?,?))
        // Parameters: 3(Integer), 13(Integer), 23(Integer), 33(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    9.limit
    LIMIT 1
     */
    @Test
    public void testQuery9() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.in("no", Arrays.asList(3, 13, 23, 33))
                    .last("limit 1");   // 无视优化规则直接拼接到 sql 的最后；只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (no IN (?,?,?,?)) limit 1
        // Parameters: 3(Integer), 13(Integer), 23(Integer), 33(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    10.select
    SELECT id, name
    FROM player
     */
    @Test
    public void testQuery10() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.select(Player.class, i -> i.getColumn().equals("id")||i.getColumn().equals("name"))    // 投影操作，指定返回的列
                    //.select("id", "name")   // 投影操作，指定返回的列
                    .in("no", Arrays.asList(3, 13, 23, 33));

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,name FROM player WHERE (no IN (?,?,?,?))
        // Parameters: 3(Integer), 13(Integer), 23(Integer), 33(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    11.使用统计函数
    SELECT team_id, AVG(no) avg_no, MAX(no) max_no
    FROM player
    GROUP BY team_id
    HAVING SUM(no) < 500
     */
    @Test
    public void testQuery11() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.select("team_id", "AVG(no) avg_no", "MAX(no) max_no")  // select 可以直接使用聚合函数并且起别名
                    .groupBy("team_id") // group by
                    .having("max_no < 500");   // 通过 sql 指定 having

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT team_id,AVG(no) avg_no,MAX(no) max_no FROM player GROUP BY team_id HAVING SUM(no) < 500
        // Parameters:
        Assertions.assertNotEquals(0, playerList.size());
    }

}

      MP设计的方法大多都是名如其意，而且使用非常简单和优雅，多操作几遍很快就能上手。另外，通用Mapper还提供了selectOne、selectMaps等方法，大家可以自行设计应用场景来熟悉我们没有使用到的方法，调用方法都类似。

      另外，这里再介绍一个更优雅的查询方式，使用QueryChainWrapper进行操作，一步到位：

      @Test
public void testQueryChain() {
    QueryChainWrapper<Player> queryChainWrapper = new QueryChainWrapper<>(playerMapper);
    List<Player> playerList = queryChainWrapper.eq("team_id", 1)
        .list();    // 其底层是调用了 BaseMapper.selectList
    Assertions.assertNotEquals(0, playerList.size());
    // MP执行的SQL：
    // Preparing: SELECT team_id,AVG(no) avg_no,MAX(no) max_no FROM player GROUP BY team_id HAVING max_no < 500
    // Parameters:
}

      之前还提到了LambdaQueryWrapper，使用方法跟QueryWrapper类似，而且LambdaQueryWrapper可以定制查询的列：

      @Test
public void testQueryLambda() {
    // 三种构建 LambdaQueryWrapper 的方法：
    //LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //LambdaQueryWrapper lambdaQueryWrapper = new QueryWrapper().lambda();
    LambdaQueryWrapper<Player> lambdaQueryWrapper = Wrappers.lambdaQuery();
    
    lambdaQueryWrapper.eq(Player::getTeamId, 1L);
    List<Player> playerList = playerMapper.selectList(lambdaQueryWrapper);
    // MP执行的SQL：
    // Preparing: SELECT id,no,team_id,name FROM player WHERE (team_id = ?)
    // Parameters: 1(Long)
    Assertions.assertNotEquals(0, playerList.size());

    LambdaQueryChainWrapper<Player> lambdaQueryChainWrapper = new LambdaQueryChainWrapper<>(playerMapper);
    playerList = lambdaQueryChainWrapper.eq(Player::getTeamId, 1L).list();
    // MP执行的SQL：
    // Preparing: SELECT id,no,team_id,name FROM player WHERE (team_id = ?)
    // Parameters: 1(Long)
    Assertions.assertNotEquals(0, playerList.size());
}

      不管是QueryWrapper还是LambdaQueryWrapper，除了上面提到的构造方法外，都有对应的传入一个entity的构造方法，这时候MP在构造WHERE时会把entity的非空属性以AND的形式直接添加，并且与条件构造器本身设置的条件不冲突。但是以entity的形式只是简单的用=条件，例如：

      @Test
public void testQueryEntity() {
    Player player = new Player();
    player.setName("James");

    QueryWrapper<Player> queryWrapper = new QueryWrapper<>(player);
    queryWrapper.eq("team_id", 1L);
    List<Player> playerList = playerMapper.selectList(queryWrapper);
    // MP执行的SQL：
    // Preparing: SELECT id,no,team_id,name FROM player WHERE name=? AND (team_id = ?)
    // Parameters: James(String), 1(Long)
    Assertions.assertNotEquals(0, playerList.size());
}

      这段单元测试会失败，因为playerList.size()为0，这是由于查询条件name使用了=，如果我们希望name以LIKE的形式来构建查询，那么我们可以在name属性上设置@TableField(condition = SqlCondition.LIKE)，这时单元测试就跟我们预想的一样了。

      4.1.3U - Update操作

      • Update相关方法：
        • updateById// 根据 ID 修改
        • update// 根据 whereEntity 条件，更新记录

      MP的Update操作都是基于entity，entity的非空属性将会成为UPDATE的字段（id除外）。其中updateById只接收一个entity参数，并且id属性不能为空。而update方法除了接收需要修改的数据entity之外，还要传入一个Wrapper对象，一般Update操作使用UpdateWrapper，这个Wrapper对象可以指定需要Update的记录：

      @Test
public void testUpdate() {
    Player player = new Player();
    player.setNo(0);
    UpdateWrapper<Player> updateWrapper = new UpdateWrapper<>();
    updateWrapper.isNull("team_id");
    int result = playerMapper.update(player, updateWrapper);
    // MP执行的SQL：
    // Preparing: UPDATE player SET no=? WHERE (team_id IS NULL)
    // Parameters: 0(Integer)
    Assertions.assertNotEquals(0, result);
}

      有了之前QueryWrapper的基础，现在使用UpdateWrapper就信手拈来了。但是我们发现这样使用UpdateWrapper并没有使用到UpdateWrapper的特性，其实UpdateWrapper有关于Update的方法：

      @Test
public void testUpdateSet() {
    UpdateWrapper<Player> updateWrapper = new UpdateWrapper();
    updateWrapper.isNull("team_id").set("no", 100);
    int result = playerMapper.update(null, updateWrapper);
    // MP执行的SQL：
    // Preparing: UPDATE player SET no=? WHERE (team_id IS NULL)
    // Parameters: 0(Integer)
    Assertions.assertNotEquals(0, result);
}

      当通过UpdateWrapper进行SET操作时，entity就可以传入一个null值了。

      4.1.4D - Delete操作

      • Delete相关方法：
        • int deleteById(Serializable id); // 根据 ID 删除
        • int deleteByMap(@Param(Constants.COLUMN_MAP) Map columnMap);// 根据 columnMap 条件，删除记录
        • int delete(@Param(Constants.WRAPPER) Wrapper wrapper);// 根据 entity 条件，删除记录
        • int deleteBatchIds(@Param(Constants.COLLECTION) Collection idList);// 删除（根据ID 批量删除）

      Delete操作涉及的方法相对简单，直接通过Id或者构建WHERE即可。

      4.2通用Service

      MP的另一大特色是框架为我们提供了通用Service，使得我们只需关注系统业务。

      说明:

      • 通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 、remove 删除、list 查询集合 、page 分页 前缀命名方式区分 Mapper 层避免混淆。
      • 泛型 T 为任意实体对象
      • 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
      • 对象 Wrapper 为 条件构造器

      通用Service的操作跟通用Mapper类似，区别是按照Service层规范把DAO层的insert、select、delete改成了save、get\list和remove。

      现在我们也创建Service层的接口和实现类：

      public interface TeamService extends IService<Team> {
}

@Service
@Transactional
public class TeamServiceImpl extends ServiceImpl<TeamMapper, Team> implements TeamService {
}

public interface PlayerService extends IService<Player> {
}

@Service
@Transactional
public class PlayerServiceImpl extends ServiceImpl<PlayerMapper, Player> implements PlayerService {
}

      使用通用Service非常简单，声明接口时继承IService就可以拥有MP提供的通用Service的能力；实现类除了实现接口外还需要继承MP的ServiceImpl类，并传入通用Mapper和对应的DO对象。

      下面我们直接通过几个例子来使用MP的通用Service：

      @SpringBootTest
class TeamServiceTest {

    @Autowired
    TeamService teamService;

    @Test
    public void testSave() {
        Team team = new Team();
        team.setName("Nuggets");
        team.setCity("Denver");
        boolean result = teamService.save(team);
        Assertions.assertTrue(result);

        Team team1 = new Team();
        team1.setName("Grizzlies");
        team1.setCity("Memphis");
        Team team2 = new Team();
        team2.setName("NETS");
        team2.setCity("Brooklyn");
        Team team3 = new Team();
        team3.setName("Thunder");
        team3.setCity("Oklahoma");
        result = teamService.saveBatch(Arrays.asList(team1, team2, team3));
        Assertions.assertTrue(result);
    }

    @Test
    public void testSelect() {
        Team team = teamService.getOne(Wrappers.<Team>query().eq("id", 1L), false);
        Assertions.assertNotNull(team);
        // MP执行的SQL：
        // Preparing: SELECT id,city,name FROM team WHERE (id = ?)
        // Parameters: 1(Long)

        List<Team> teamList = teamService.list(Wrappers.<Team>query().le("id", 5L));
        Assertions.assertNotEquals(0, teamList.size());
        // MP执行的SQL：
        // Preparing: SELECT id,city,name FROM team WHERE (id <= ?)
        // Parameters: 5(Long)
    }

    @Test
    public void testUpdate() {
        Team team = new Team();
        team.setId(1L);
        team.setName("Laker");
        boolean result = teamService.saveOrUpdate(team);    // saveOrUpdate 会先执行 SELECT BY Id 操作，如果找到有记录则进行 UPDATE 操作，否则进行 INSERT 操作
        Assertions.assertTrue(result);
        // MP执行的SQL：
        // Preparing: SELECT id,city,name FROM team WHERE id=?
        // Parameters: 1(Long)
        // Preparing: UPDATE team SET name=? WHERE id=?
        // Parameters: Laker(String), 1(Long)

        team = new Team();
        team.setId(100L);
        team.setName("Blazers");
        team.setCity("Portland");
        result = teamService.saveOrUpdate(team);
        Assertions.assertTrue(result);
        // MP执行的SQL：
        // Preparing: SELECT id,city,name FROM team WHERE id=?
        // Parameters: 100(Long)
        // Preparing: INSERT INTO team ( id, city, name ) VALUES ( ?, ?, ? )
        // Parameters: 100(Long), Portland(String), Blazers(String)

        teamService.update(Wrappers.<Team>update().eq("id", 1L).set("name", "Lakers"));
        // MP执行的SQL：
        // Preparing: UPDATE team SET name=? WHERE (id = ?)
        // Parameters: Lakers(String), 1(Long)
    }

}

      我们可以看到，通用Service和通用Mapper操作方式基本保持一致，需要注意的是，通用Service的save和update操作返回值是boolean类型。另外，我们还可以用链式操作以更优雅的方式进行操作：

      @Test
public void testChain() {
    List<Team> teamList = teamService.query().select("id", "name").le("id", 5L).list();
    Assertions.assertNotEquals(0, teamList.size());
    // MP执行的SQL：
    // Preparing: SELECT id,name FROM team WHERE (id <= ?)
    // Parameters: 5(Long)
}

      4.3分页查询

      在实际项目中用得最多也比较重要的业务应该就是分页操作了，MP对分页操作也做了插件支持。

      在Spring Boot项目中使用MP的分页功能也非常简单，只需要在容器中注入PaginationInterceptor对象即可。这里以@Configuration配置：

      @EnableTransactionManagement
@Configuration
public class MyBatisPlusConfig {
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        // paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        // paginationInterceptor.setLimit(500);
        return paginationInterceptor;
    }
}

      有了这个配置，就可以在项目中使用MP的分页插件了。其中通用Mapper和通用Service都提供了分页查询的相关功能，我们以通用Service为例使用MP的分页功能。

      首先我们来看一下分页功能最重要的一个接口IPage，这里直接上源码：

      public interface IPage<T> extends Serializable {

    /**
     * 降序字段数组
     *
     * @return order by desc 的字段数组
     * @see #orders()
     */
    @Deprecated
    default String[] descs() {
        return null;
    }

    /**
     * 升序字段数组
     *
     * @return order by asc 的字段数组
     * @see #orders()
     */
    @Deprecated
    default String[] ascs() {
        return null;
    }

    /**
     * 获取排序信息，排序的字段和正反序
     *
     * @return 排序信息
     */
    List<OrderItem> orders();

    /**
     * KEY/VALUE 条件
     *
     * @return ignore
     */
    default Map<Object, Object> condition() {
        return null;
    }

    /**
     * 自动优化 COUNT SQL【 默认：true 】
     *
     * @return true 是 / false 否
     */
    default boolean optimizeCountSql() {
        return true;
    }

    /**
     * 进行 count 查询 【 默认: true 】
     *
     * @return true 是 / false 否
     */
    default boolean isSearchCount() {
        return true;
    }

    /**
     * 计算当前分页偏移量
     */
    default long offset() {
        return getCurrent() > 0 ? (getCurrent() - 1) * getSize() : 0;
    }

    /**
     * 当前分页总页数
     */
    default long getPages() {
        if (getSize() == 0) {
            return 0L;
        }
        long pages = getTotal() / getSize();
        if (getTotal() % getSize() != 0) {
            pages++;
        }
        return pages;
    }

    /**
     * 内部什么也不干
     * 
      只是为了 json 反序列化时不报错
      
     */      
    default IPage<T> setPages(long pages) {
        // to do nothing
        return this;
    }

    /**
     * 分页记录列表
     *
     * @return 分页对象记录列表
     */
    List<T> getRecords();

    /**
     * 设置分页记录列表
     */
    IPage<T> setRecords(List<T> records);

    /**
     * 当前满足条件总行数
     *
     * @return 总条数
     */
    long getTotal();

    /**
     * 设置当前满足条件总行数
     */
    IPage<T> setTotal(long total);

    /**
     * 当前分页总页数
     *
     * @return 总页数
     */
    long getSize();

    /**
     * 设置当前分页总页数
     */
    IPage<T> setSize(long size);

    /**
     * 当前页，默认 1
     *
     * @return 当前页
     */
    long getCurrent();

    /**
     * 设置当前页
     */
    IPage<T> setCurrent(long current);

    /**
     * IPage 的泛型转换
     *
     * @param mapper 转换函数
     * @param     转换后的泛型
     * @return 转换泛型后的 IPage
     */
    @SuppressWarnings("unchecked")
    default <R> IPage<R> convert(Function<? super T, ? extends R> mapper) {
        List<R> collect = this.getRecords().stream().map(mapper).collect(toList());
        return ((IPage<R>) this).setRecords(collect);
    }
}

      其中对我们比较重要的属性有current（当前页数）、size（每页记录数）、pages（总页数）、total(总记录数)和records（分页数据）。

      MP为我们提供了一个简单IPage实现：Page类。下面是一个简单的分页查询例子：

      @Test
public void testPage() {
    // 设置分页条件
    Page<Player> page = new Page<>();
    page.setCurrent(1);
    page.setSize(5);
    playerService.page(page, Wrappers.<Player>query().eq("team_id", 1L));
    // MP执行的SQL：
    // Preparing: SELECT COUNT(1) FROM player WHERE (team_id = ?)
    // Parameters: 1(Long)
    // Preparing: SELECT id,no,team_id,name FROM player WHERE (team_id = ?) LIMIT ?,?
    // Parameters: 1(Long), 0(Long), 5(Long)

    //page.getPages();  // 总页数
    //page.getTotal();  // 总记录数
    // 分页结果保存在 page 的 records 属性中
    Assertions.assertNotEquals(0, page.getRecords().size());

    page.setSearchCount(false);    // 是否需要查询总记录数，这里设置不需要
    playerService.page(page, Wrappers.<Player>query().eq("team_id", 1L));
    // MP执行的SQL：
    // Preparing: SELECT id,no,team_id,name FROM player WHERE (team_id = ?) LIMIT ?,?
    // Parameters: 1(Long), 0(Long), 5(Long)
    Assertions.assertNotEquals(0, page.getRecords().size());
}

      这里有一点需要注意，就是当业务对表的总记录数不关心的时候，可以通过Page.setSearchCount(false)方法来避免执行SELECT COUNT(1)操作。

      很多时候我们的分页查询的业务会非常复杂，通过条件构造器也可能不能实现我们的需求，这时候就需要我们自己写SQL了，这不正是MyBatis的强项吗。好在MP对MyBatis原有的特性完全支持，使得我们可以自定义SQL。接下来我们重点讲解MP自定义SQL。

      4.4回到MyBatis - 使用自定义SQL

      在本文开头提到，MP只对MyBatis做了增强，并没有改变MyBatis原有的特性。所以对于原来MyBatis的强项自定义SQL功能，也可以应用到MP中，而且MP也对这部分做了增强。

      提示：本节内容需要MyBatis基础。

      我们之前都是在使用MP来构造我们想要的SQL语句，应对一些很复杂的场景，我们有时可能很难直接通过MP来一步构造SQL语句，这时候我们可以自己写SQL–就像以前用MyBatis一样。

      如果抛开MP只使用MyBatis写SQL的话，是这样的：

      @Select({
    ""
})
List find(@Param("team") Team team);
      • 注：如果使用XML的方式，在MyBatis框架下还需要配置mybatis.mapper-locations；如果是MP框架，则是配置mybatis-plus.mapper-locations

      上面是原生Mybatis支持的SQL绑定功能（其实MyBatis的优势就体现在这）。虽然这种方式非常灵活，但用过MyBatis做过项目的都知道，因为每一个DAO方法都需要对应一段SQL，再加上各种结果转换和条件判断，SQL充斥着整个项目。MP官方也为我们考虑了这个问题，其在不改变原有方式的情况下做了改进。下面先来介绍下普通操作（CURD）自定义SQL的MP打开方式：

      在Mapper中添加一个名为"ew"（MP规定，可以用Constants.WRAPPER这个值为"ew"的常量）的Wrapper类型参数：

      @Select("SELECT * FROM team ${ew.customSqlSegment}")    // Wrapper.customSqlSegment为自定义SQL的内容
List<Team> findMP(@Param(Constants.WRAPPER) Wrapper<Team> wrapper);

      调用时传入一个条件构造器即可，但需要注意的是，MP的这种自定义SQL的方式只能添加到WHERE条件，但WHERE中的判断逻辑可以省略（如AND或OR的拼接，都交给了Wrapper实现），而且WHERE关键字也不需要我们特地指定。然后通过以下方式调用：

      @Test
public void testCustomFindMP() {
    List<Team> teamList = teamMapper.findMP(Wrappers.<Team>query().le("id", 5L));
    // MP执行的SQL：
    // Preparing: SELECT * FROM team WHERE (id <= ?)
    // Parameters: 5(Long)
    Assertions.assertNotEquals(0, teamList.size());
}

      分页查询的自定义SQL也非常简单，在Mapper中定义分页查询（Page参数必须是第一个参数）：

      @Select("SELECT * FROM player ${ew.customSqlSegment}")
IPage<Player> pageCustomMP(Page page, @Param(Constants.WRAPPER) Wrapper<Player> wrapper);

      调用方式也是我们非常熟悉的方式：

      @Test
public void testPageCustomMP() {
    IPage<Player> playerIPage = playerMapper.pageCustomMP(new Page(1, 5), Wrappers.<Player>query().le("id", 5L));
    // MP执行的SQL：
    // Preparing: SELECT COUNT(1) FROM player WHERE (id <= ?)
    // Parameters: 5(Long)
    // Preparing: SELECT * FROM player WHERE (id <= ?) LIMIT ?,?
    // Parameters: 5(Long), 0(Long), 5(Long)
    Assertions.assertNotEquals(0, playerIPage.getRecords().size());
}

      5.结尾

      • 本文demo资源：

        • 源码
        • 数据

      • 参考资料：

        • MyBatis-Plus官网

      • 关于MP还有很多更高级的话题，如逻辑删除，乐观锁以及分布式事务等，下次再跟大家一起分享。

      你可能感兴趣的:(spring,boot,java,spring,spring,boot,mybatis,mybatis-plus)

      • Long类型前后端数据不一致 igotyback 前端
        响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
      • LocalDateTime 转 String igotyback java开发语言
        importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
      • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
        需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
      • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
        ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
        华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
      • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
        ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
      • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
        Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
      • node.js学习 小猿L node.jsnode.js学习vim
        node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
      • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
        SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
      • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
        前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
      • Java 重写(Override)与重载(Overload) 叨唧唧的
        Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
      • 简单了解 JVM 记得开心一点啊 jvm
        目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
      • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
        1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
      • Java企业面试题3 马龙强_ java
        1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
      • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
        Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
      • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
        一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
      • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
        欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
      • python语法——三目运算符 HappyRocking pythonpython三目运算符
        在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
      • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
        目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
      • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
        ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
      • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
        一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
      • Java：爬虫框架 dingcho Javajava爬虫
        一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
      • python怎么将png转为tif_png转tif weixin_39977276
        发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
      • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
        前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
      • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
        这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
      • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
        在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
      • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
        文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
      • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
        引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
      • Spring Boot中实现跨域请求 BABA8891 springboot后端java
        在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
      • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
        文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
      • Java开发中，spring mvc 的线程怎么调用？ 小麦麦子 springmvc
        今天逛知乎，看到最近很多人都在问spring mvc 的线程http://www.maiziedu.com/course/java/ 的启动问题，觉得挺有意思的，那哥们儿问的也听仔细，下面的回答也很详尽，分享出来，希望遇对遇到类似问题的Java开发程序猿有所帮助。 问题：     在用spring mvc架构的网站上，设一线程在虚拟机启动时运行，线程里有一全局
      • maven依赖范围 bitcarter maven
        1.test 测试的时候才会依赖，编译和打包不依赖，如junit不被打包 2.compile 只有编译和打包时才会依赖 3.provided 编译和测试的时候依赖，打包不依赖，如：tomcat的一些公用jar包 4.runtime 运行时依赖，编译不依赖 5.默认compile 依赖范围compile是支持传递的，test不支持传递 1.传递的意思是项目A，引用
      • Jaxb org.xml.sax.saxparseexception : premature end of file darrenzhu xmlprematureJAXB
        如果在使用JAXB把xml文件unmarshal成vo(XSD自动生成的vo)时碰到如下错误： org.xml.sax.saxparseexception : premature end of file 很有可能时你直接读取文件为inputstream，然后将inputstream作为构建unmarshal需要的source参数。InputSource inputSource = new In
      • CSS Specificity 周凡杨 html权重Specificitycss
          有时候对于页面元素设置了样式，可为什么页面的显示没有匹配上呢？ because specificity CSS 的选择符是有权重的，当不同的选择符的样式设置有冲突时，浏览器会采用权重高的选择符设置的样式。     规则：   HTML标签的权重是1 Class 的权重是10 Id 的权重是100
      • java与servlet g21121 servlet
        servlet 搞java web开发的人一定不会陌生，而且大家还会时常用到它。 下面是java官方网站上对servlet的介绍： java官网对于servlet的解释 写道 Java Servlet Technology Overview Servlets are the Java platform technology of choice for extending and enha
      • eclipse中安装maven插件 510888780 eclipsemaven
        1.首先去官网下载 Maven： http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-3.2.3-bin.tar.gz 下载完成之后将其解压， 我将解压后的文件夹：apache-maven-3.2.3， 并将它放在 D:\tools目录下， 即 maven 最终的路径是：D:\tools\apache-mave
      • jpa@OneToOne关联关系 布衣凌宇 jpa
        Nruser里的pruserid关联到Pruser的主键id，实现对一个表的增删改，另一个表的数据随之增删改。 Nruser实体类 //***************************************************************** @Entity @Table(name="nruser") @DynamicInsert @Dynam
      • 我的spring学习笔记11-Spring中关于声明式事务的配置 aijuans spring事务配置
        这两天学到事务管理这一块，结合到之前的terasoluna框架，觉得书本上讲的还是简单阿。我就把我从书本上学到的再结合实际的项目以及网上看到的一些内容，对声明式事务管理做个整理吧。我看得Spring in Action第二版中只提到了用TransactionProxyFactoryBean和<tx:advice/>,定义注释驱动这三种，我承认后两种的内容很好，很强大。但是实际的项目当中
      • java 动态代理简单实现 antlove javahandlerproxydynamicservice
        dynamicproxy.service.HelloService package dynamicproxy.service; public interface HelloService { public void sayHello(); }   dynamicproxy.service.impl.HelloServiceImpl package dynamicp
      • JDBC连接数据库 百合不是茶 JDBC编程JAVA操作oracle数据库
                 如果我们要想连接oracle公司的数据库，就要首先下载oralce公司的驱动程序，将这个驱动程序的jar包导入到我们工程中;   JDBC链接数据库的代码和固定写法;     1,加载oracle数据库的驱动;     &nb
      • 单例模式中的多线程分析 bijian1013 javathread多线程java多线程
        谈到单例模式，我们立马会想到饿汉式和懒汉式加载，所谓饿汉式就是在创建类时就创建好了实例，懒汉式在获取实例时才去创建实例，即延迟加载。 饿汉式： package com.bijian.study; public class Singleton { private Singleton() { } // 注意这是private 只供内部调用 private static
      • javascript读取和修改原型特别需要注意原型的读写不具有对等性 bijian1013 JavaScriptprototype
                对于从原型对象继承而来的成员，其读和写具有内在的不对等性。比如有一个对象A，假设它的原型对象是B，B的原型对象是null。如果我们需要读取A对象的name属性值，那么JS会优先在A中查找，如果找到了name属性那么就返回；如果A中没有name属性，那么就到原型B中查找name，如果找到了就返回；如果原型B中也没有
      • 【持久化框架MyBatis3六】MyBatis3集成第三方DataSource bit1129 dataSource
        MyBatis内置了数据源的支持，如：   <environments default="development"> <environment id="development"> <transactionManager type="JDBC" /> <data
      • 我程序中用到的urldecode和base64decode,MD5 bitcarter cMD5base64decodeurldecode
        这里是base64decode和urldecode，Md5在附件中。因为我是在后台所以需要解码： string Base64Decode(const char* Data,int DataByte,int& OutByte) { //解码表 const char DecodeTable[] = { 0, 0, 0, 0, 0, 0
      • 腾讯资深运维专家周小军：QQ与微信架构的惊天秘密 ronin47
        社交领域一直是互联网创业的大热门，从PC到移动端，从OICQ、MSN到QQ。到了移动互联网时代，社交领域应用开始彻底爆发，直奔黄金期。腾讯在过去几年里，社交平台更是火到爆，QQ和微信坐拥几亿的粉丝，QQ空间和朋友圈各种刷屏，写心得，晒照片，秀视频，那么谁来为企鹅保驾护航呢？支撑QQ和微信海量数据背后的架构又有哪些惊天内幕呢？本期大讲堂的内容来自今年2月份ChinaUnix对腾讯社交网络运营服务中心
      • java-69-旋转数组的最小元素。把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素 bylijinnan java
        public class MinOfShiftedArray { /** * Q69 旋转数组的最小元素 * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。 * 例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。 */ publ
      • 看博客，应该是有方向的 Cb123456 反省看博客
        看博客，应该是有方向的:  我现在就复习以前的，在补补以前不会的，现在还不会的，同时完善完善项目，也看看别人的博客.  我刚突然想到的:  1.应该看计算机组成原理，数据结构，一些算法，还有关于android,java的。  2.对于我，也快大四了，看一些职业规划的，以及一些学习的经验，看看别人的工作总结的.    为什么要写
      • [开源与商业]做开源项目的人生活上一定要朴素,尽量减少对官方和商业体系的依赖 comsci 开源项目
             为什么这样说呢？  因为科学和技术的发展有时候需要一个平缓和长期的积累过程，但是行政和商业体系本身充满各种不稳定性和不确定性，如果你希望长期从事某个科研项目，但是却又必须依赖于某种行政和商业体系，那其中的过程必定充满各种风险。。。       所以，为避免这种不确定性风险，我
      • 一个 sql优化 （[精华] 一个查询优化的分析调整全过程！很值得一看 ） cwqcwqmax9 sql
        见   http://www.itpub.net/forum.php?mod=viewthread&tid=239011 Web翻页优化实例 提交时间: 2004-6-18 15:37:49      回复    发消息  环境： Linux ve
      • Hibernat and Ibatis dashuaifu Hibernateibatis
        Hibernate  VS  iBATIS 简介 Hibernate 是当前最流行的O/R mapping框架，当前版本是3.05。它出身于sf.net，现在已经成为Jboss的一部分了 iBATIS 是另外一种优秀的O/R mapping框架，当前版本是2.0。目前属于apache的一个子项目了。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mappi
      • 备份MYSQL脚本 dcj3sjt126com mysql
        #!/bin/sh # this shell to backup mysql #[email protected] (QQ:1413161683 DuChengJiu) _dbDir=/var/lib/mysql/ _today=`date +%w` _bakDir=/usr/backup/$_today [ ! -d $_bakDir ] && mkdir -p
      • iOS第三方开源库的吐槽和备忘 dcj3sjt126com ios
        转自 ibireme的博客   做iOS开发总会接触到一些第三方库，这里整理一下，做一些吐槽。   目前比较活跃的社区仍旧是Github，除此以外也有一些不错的库散落在Google Code、SourceForge等地方。由于Github社区太过主流，这里主要介绍一下Github里面流行的iOS库。   首先整理了一份 Github上排名靠
      • html wlwmanifest.xml eoems htmlxml
        所谓优化wp_head()就是把从wp_head中移除不需要元素，同时也可以加快速度。 步骤： 加入到function.php remove_action('wp_head', 'wp_generator'); //wp-generator移除wordpress的版本号，本身blog的版本号没什么意义，但是如果让恶意玩家看到，可能会用官网公布的漏洞攻击blog remov
      • 浅谈Java定时器发展 hacksin java并发timer定时器
        java在jdk1.3中推出了定时器类Timer,而后在jdk1.5后由Dou Lea从新开发出了支持多线程的ScheduleThreadPoolExecutor，从后者的表现来看，可以考虑完全替代Timer了。 Timer与ScheduleThreadPoolExecutor对比： 1.    Timer始于jdk1.3,其原理是利用一个TimerTask数组当作队列
      • 移动端页面侧边导航滑入效果 ini jqueryWebhtml5cssjavascirpt
        效果体验：http://hovertree.com/texiao/mobile/2.htm可以使用移动设备浏览器查看效果。效果使用到jquery-2.1.4.min.js，该版本的jQuery库是用于支持HTML5的浏览器上，不再兼容IE8以前的浏览器，现在移动端浏览器一般都支持HTML5，所以使用该jQuery没问题。HTML文件代码： <!DOCTYPE html> <h
      • AspectJ+Javasist记录日志 kane_xie aspectjjavasist
        在项目中碰到这样一个需求，对一个服务类的每一个方法，在方法开始和结束的时候分别记录一条日志，内容包括方法名，参数名+参数值以及方法执行的时间。   @Override public String get(String key) { // long start = System.currentTimeMillis(); // System.out.println("Be
      • redis学习笔记 MJC410621 redisNoSQL
        1)nosql数据库主要由以下特点：非关系型的、分布式的、开源的、水平可扩展的。 1，处理超大量的数据 2，运行在便宜的PC服务器集群上， 3，击碎了性能瓶颈。 1)对数据高并发读写。 2)对海量数据的高效率存储和访问。 3)对数据的高扩展性和高可用性。 redis支持的类型： Sring 类型 set name lijie get name lijie set na
      • 使用redis实现分布式锁 qifeifei
        在多节点的系统中，如何实现分布式锁机制，其中用redis来实现是很好的方法之一，我们先来看一下jedis包中，有个类名BinaryJedis,它有个方法如下：   public Long setnx(final byte[] key, final byte[] value) { checkIsInMulti(); client.setnx(key, value); ret
      • BI并非万能，中层业务管理报表要另辟蹊径 张老师的菜 大数据BI商业智能信息化
               BI是商业智能的缩写，是可以帮助企业做出明智的业务经营决策的工具，其数据来源于各个业务系统，如ERP、CRM、SCM、进销存、HER、OA等。        BI系统不同于传统的管理信息系统，他号称是一个整体应用的解决方案，是融入管理思想的强大系统：有着系统整体的设计思想，支持对所有
      • 安装rvm后出现rvm not a function 或者ruby -v后提示没安装ruby的问题 wudixiaotie function
        1.在~/.bashrc最后加入 [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"  2.重新启动terminal输入：   rvm use ruby-2.2.1 --default  把当前安装的ruby版本设为默