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)

      • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
        须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
      • 学习JavaEE的日子 Day32 线程池 A 北枝 学习JavaEE学习java-eejava线程池
        Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
      • SpringMVC设置全局异常处理器 水岸齐天 javaspring
        文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
      • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】 还算善良_ 私有代码库工具类javalist数据结构
        packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
      • springboot集成logback-spring.xml文件 RT_0114 SpringBootspringbootspringlogback
        彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
      • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shirojavajava安全开发语言
        请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
      • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？ 大龄下岗程序员 mysqljavamysqlspring
        Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
      • 3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb前端ajaxelementuijava前端框架
        P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
      • eclipse导入项目 warning报错 org.springframework.ide.eclipse.core.springnature zhangfeng1133 ideeclipsejava
        报错org.springframework.ide.eclipse.core.springnature报错信息"org.springframework.ide.eclipse.core.springnature"通常表示EclipseIDE中与Spring框架集成的插件出现了问题。这个错误可能是因为SpringIDE插件没有正确安装或配置，或者Eclipse的更新过程中出现了问题。解决方法：确认S
      • MyBatis高级面试题-2024 my_styles mybatisjava开发语言面试题
        MyBatis的核心组件有哪些？首先第一个是，SqlSessionFactory，它就像是一个会话工厂。它的任务是创建SqlSession对象，这个对象是我们与数据库交互的主要途径。SqlSessionFactory的作用很重要，因为它可以帮我们配置数据库连接信息和事务管理等。一旦这个工厂被建立起来，它就会加载一些必要的配置和映射文件，为后续的数据库操作提供一个可靠的基础。第二个是SqlSessi
      • 枚举使用笔记 万变不离其宗_8 项目笔记笔记
        1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
      • linux安装docker及docker-compose 部署spring boot项目 时而有事儿 dockerlinuxdockerlinuxspringboot
        linux系统环境：centos5.14本篇描述的是在centos系统版本下安装docker，如果是ubuntu版本，请看这篇文章：linuxubuntu20安装docker和docker-compose-CSDN博客正文：安装docker和docker-compose安装docker---------运行命名等待安装完成遇到选择直接输入yyuminstall-yyum-utilsdevice-m
      • Python dict字符串转json对象，小数精度丢失问题 朝如青丝 暮成雪 jsonpython
        一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
      • java实体中返回前端的double类型四舍五入（格式化） 婲落ヽ紅顏誶 java
        根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
      • Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java数据结构开发语言
        在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
      • Java学习笔记01 .wsy. 日常java学习笔记
        1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
      • Java回溯知识点（含面试大厂题和源码） 一成码农 java面试开发语言
        回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
      • Azkaban各种类型的Job编写 __元昊__
        一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
      • java基础相关面试题详细总结 。。。。。96 java开发语言
        1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
      • Thinkphp - 详细实现网站系统登录功能，附带 Mysql 数据库设置、Web 前端展示界面、信息校验等（详细代码，即设计过程） 王佳斌 +Thinkphpmysql前端数据库
        前言登录功能，是我们几乎开发每个系统都必须的模块。登录功能设计思路，主要包括几个方面。用户输入网址展示登录页面用户输入用户名，密码等点击登录进行信息校验校验通过之后，记录用户登录信息，跳转指定页面用户校验失败，提示失败信息页面目录具体功能实现为了快速搭建可用、美观的页面，我们采用一个比较成熟的前端框架Bootstrap。下面我们到Bootstrap的官网Bootsrap官网下载bootstrap。
      • javascript 日期转换为时间戳，时间戳转换为日期的函数 cdcdhj javascript学习日记javascript开发语言ecmascript
        日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
      • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
        Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
      • COMP315 JavaScript Cloud Computing for E Commerce zhuyu0206girl javascript开发语言ecmascript
        Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
      • JSON与AJAX：网页交互的利器 入冉心 jsonajax前端
        在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
      • 程序员开发技术整理 laizhixue 学习前端框架
        前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
      • SAP Spartacus的Component映射 JerryWang_汪子熙
        Spartacus默认的购物车界面：https://github.com/SAP/spartacus-bootcamp/blob/master/sparta0/src/app/components/cart.component.ts新建一个CartComponent，对Spartacus标准的CartDetailsComponent进行扩展：import{Component}from'@angul
      • javascript的数据类型及转换 田小田txt
        一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
      • java线程之Lock的使用 dimdark
        目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
      • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解 爱跑步的程序员~ 刷题蓝桥杯省赛
        文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
      • Java学习笔记04：Java_数组 JasonYangQ Javajava
        文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
      • 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版本设为默