MyBatis 批量插入数据优化

前言

最近在项目上遇到了批量插入的场景问题，由于每次需要插入超过 10w+ 的数据量并且字段也蛮多的导致如果使用循环单次插入的方式插入数据插入的效率不高。相信读者们在实际开发中也遇到过这样类似的场景，那么批量插入如何实现呢？

其实我也是一知半解，之前只见过别人博客上的批量插入实现，对于实际优化上的细节以及优化的程度并不了解。所以正好借此机会，在这里认真地把批量插入的实现及优化过程实操一遍并记录下来，有兴趣的读者们可以接着往下观看，有不对的地方还希望能在评论里指出来。

既然涉及到了数据库层面的操作，我想从 JDBC 和 MyBatis / MyBatis Plus 两个层面分别实现一下批量插入，下面将依次讲解实现及优化过程。

JDBC 实现批量插入

在编写代码前，先准备一下 JDBC 批量插入需要的测试环境。

JDBC 测试环境

建表语句（使用数据库版本 mysql 5.7.19）

DROP TABLE IF EXISTS `fee`;
CREATE TABLE `fee`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `owner` varchar(64) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL COMMENT '归属人',
  `fee1` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用1',
  `fee2` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用2',
  `fee3` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用3',
  `fee4` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用4',
  `fee5` decimal(30, 5) NULL DEFAULT NULL COMMENT '费用5',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_unicode_ci COMMENT = '费用表' ROW_FORMAT = Dynamic;

maven 坐标（使用 Java 版本 JDK 1.8）

!-- MySQL 驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.9</version>
</dependency>

普通插入

在实现批量插入之前呢，为了更明显的看到普通插入方式和批量插入方式的不同，先来写一遍普通插入（循环插入）的实现并记录一下插入所需时间。

使用 JDBC 不需要添加额外的配置文件，直接上代码：

/**
 * JDBC - 普通插入（循环遍历一条一条插入）
 * @author 单程车票
 */
public class JDBCDemo {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/test";
        String user = "root";
        String password = "123456";
        String driver = "com.mysql.jdbc.Driver";
        // sql语句
        String sql = "INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`) VALUES (?,?,?,?,?,?);";
        Connection conn = null;
        PreparedStatement ps = null;
        // 开始时间
        long start = System.currentTimeMillis();
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, user, password);
            ps = conn.prepareStatement(sql);
            // 循环遍历插入数据
            for (int i = 1; i <= 100000; i++) {
                ps.setString(1, "o"+i);
                ps.setBigDecimal(2, new BigDecimal("11111.111"));
                ps.setBigDecimal(3, new BigDecimal("11111.111"));
                ps.setBigDecimal(4, new BigDecimal("11111.111"));
                ps.setBigDecimal(5, new BigDecimal("11111.111"));
                ps.setBigDecimal(6, new BigDecimal("11111.111"));
                ps.executeUpdate();
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（普通插入方式）：" + (end - start) + " ms");
    }
}

执行结果：

img

可以看到使用普通插入的方式插入 10w 条数据需要的时间大概在 80 s 左右，接下来看看使用批量插入的方式优化了多少。

批处理插入

下面就是 JDBC 批量插入的实现方式：批处理插入方式 + 手动事务提交。

代码：

/**
 * JDBC - 批处理插入
 * @author 单程车票
 */
public class JDBCPlusDemo {
    public static void main(String[] args) {
        // url 设置允许重写批量提交 rewriteBatchedStatements=true
        String url = "jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true";
        String user = "root";
        String password = "123456";
        String driver = "com.mysql.jdbc.Driver";
        // sql语句（注意url设置为rewriteBatchedStatements=true时，不允许sql语句带有;号，否则会抛出BatchUpdateException异常）
        String sql = "INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`) VALUES (?,?,?,?,?,?)";
        Connection conn = null;
        PreparedStatement ps = null;
        // 开始时间
        long start = System.currentTimeMillis();
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, user, password);
            ps = conn.prepareStatement(sql);
            // 关闭自动提交
            conn.setAutoCommit(false);
            for (int i = 1; i <= 100000; i++) {
                ps.setString(1, "o"+i);
                ps.setBigDecimal(2, new BigDecimal("11111.111"));
                ps.setBigDecimal(3, new BigDecimal("11111.111"));
                ps.setBigDecimal(4, new BigDecimal("11111.111"));
                ps.setBigDecimal(5, new BigDecimal("11111.111"));
                ps.setBigDecimal(6, new BigDecimal("11111.111"));
                // 加入批处理（将当前sql加入缓存）
                ps.addBatch();
                // 以 1000 条数据作为分片
                if (i % 1000 == 0) {
                    // 执行缓存中的sql语句
                    ps.executeBatch();
                    // 清空缓存
                    ps.clearBatch();
                }
            }
            ps.executeBatch();
            ps.clearBatch();
            // 事务提交（实际开发中需要判断有插入失败的需要在 finally 中做好事务回滚操作）
            conn.commit();
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（批处理插入）：" + (end - start) + " ms");
    }
}

执行结果：

img

可以看到使用批处理+手动提交的方式插入 10w 条数据的执行时间大概在 1s 左右，速度明显提高了很多。接下来看看批处理方式需要注意的细节和重点有哪些：

  1. 利用 PreparedStatement 批量处理的三个方法来实现批量操作，分别是：

    • addBatch()：该方法用于向批处理中添加一批参数。通常在执行批量操作之前，通过多次调用该方法，将不同的参数添加到批处理中，然后一次性将这些参数一起提交给数据库执行。
    • executeBatch()：该方法用于执行当前的批处理。一旦添加完所有参数到批处理后，可以调用该方法将这些参数提交给数据库执行。该方法会返回一个整数数组，表示批处理中每个操作所影响的行数。
    • clearBatch()：该方法用于清空当前的批处理。在执行完当前批处理后需要清空当前批处理，可以调用该方法来清空之前添加的所有参数。

  3. 在配置 MySQL 的 url 时需要加上 rewriteBatchedStatements=true 才能达到真正意义上的批处理效果。

    • 这个设置是为了把允许重写批量提交（rewriteBatchedStatements）开启。
    • 在默认不开启的情况下，会无视 executeBatch() 方法，将原本应该批量执行的 sql 语句又拆散成单条语句执行。也就是说如果不开启允许重写批量提交，实际上批处理操作和原本的单条语句循环插入的效果一样。

  5. 使用 JDBC 时需要注意插入的 sql 语句结尾不能带 ; 号，否则会抛出 BatchUpdateException 异常。

    • 如图：img
    • 这是因为使用批处理是会在结尾处进行拼接，如果结尾有 ; 号会导致插入语句变成 INSERT INTO TABLE(X,X,X,X) VALUES (X,X,X,X);,(X,X,X,X);,(X,X,X,X);,这样自然会出现 sql 语法错误。

  7. 需要注意批量处理时的分片操作，上面代码的分片大小为 1000（这是参考了后面 MP 框架的默认分片大小），分片操作可以避免一次性提交的数据量过大从而导致数据库在处理时出现的性能问题和内存占用过高问题，有效的分片可以减轻数据库的负担。

  8. 使用手动事务提交可以提高插入速度，在批量插入大量数据时，手动事务提交相对于自动提交事务来说可以减少磁盘的写入次数，减少锁竞争，从而提高插入的性能。

    • 可以通过 setAutoCommit(false) 来关闭自动提交事务，等全部批量插入完成后再通过 commit() 手动提交事务。

MyBatis / MyBatis Plus 实现批量插入

由于 MyBatis Plus 相对于 MyBatis 来说只做了增强并没有改变 MyBatis 的功能，所以接下来将以 MyBatis Plus 来实现批量插入，其中有些方式是两个框架都可以使用的，有些则是 MP 独有的，会在后续讲解中标注出来。

MyBatis Plus 测试环境

先来配一下 MP 需要的测试环境，继续利用上文的 JDBC 测试环境并补充 MP 需要的测试环境：

maven 坐标：

<!-- MyBatis Plus 依赖 -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3.1</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

application.properties ：

# 配置数据库
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
spring.datasource.username=root
spring.datasource.password=123456

实现代码

由于 MyBatis / MyBatis Plus 的测试代码过多，所以在这里统一展示实体类、service、mapper 的实现代码，后续只给出测试代码。

Fee.java - 实体类

/**
 * Fee 实体类
 * @author 单程车票
 */
@TableName("fee")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Fee {

    @TableId(type = IdType.AUTO)
    private Long id;
    private String owner;
    private BigDecimal fee1;
    private BigDecimal fee2;
    private BigDecimal fee3;
    private BigDecimal fee4;
    private BigDecimal fee5;

}

FeeMapper.java - Mapper 接口

/**
 * Fee Mapper接口
 * @author 单程车票
 */
@Mapper
public interface FeeMapper extends BaseMapper<Fee> {

    /**
     * 单条数据插入
     * @param fee 实体类
     * @return 插入结果
     */
    int insertByOne(Fee fee);

    /**
     * foreach动态拼接sql插入
     * @param feeList 实体类集合
     * @return 插入结果
     */
    int insertByForeach(List<Fee> feeList);
}

这里继承 BaseMapper 只是为了使用最后的 MP 自带的批处理插入方法。如果不使用那种方式则可以不继承。

FeeMapper.xml - Mapper 映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="db.review.mapper.FeeMapper">

    <insert id="insertByOne">
        INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`)
        VALUES (#{owner}, #{fee1}, #{fee2}, #{fee3}, #{fee4}, #{fee5})
    </insert>

    <insert id="insertByForeach">
        INSERT INTO fee(`owner`,`fee1`,`fee2`,`fee3`,`fee4`,`fee5`)
        VALUES
        <foreach collection="feeList" item="fee" separator=",">
            (#{fee.owner}, #{fee.fee1}, #{fee.fee2}, #{fee.fee3}, #{fee.fee4}, #{fee.fee5})
        </foreach>
   </insert>

</mapper>

FeeService.java - Service 接口

/**
 * Fee Service 接口
 * @author 单程车票
 */
public interface FeeService extends IService<Fee> {

    /**
     * 普通插入
     * @param feeList 实体类列表
     * @return 插入结果
     */
    int saveByFor(List<Fee> feeList);

    /**
     * foreach 动态拼接插入
     * @param feeList 实体类列表
     * @return 插入结果
     */
    int saveByForeach(List<Fee> feeList);


    /**
     * 批处理插入
     * @param feeList 实体类列表
     * @return 插入结果
     */
    int saveByBatch(List<Fee> feeList);
}

同样这里继承 IService 也只是为了使用最后的 MP 自带的批处理插入方法。如果不使用那种方式则可以不继承。

FeeServiceImpl.java - Service 实现类

/**
 * Fee Service 实现类
 * @author 单程车票
 */
@Service
public class FeeServiceImpl extends ServiceImpl<FeeMapper, Fee> implements FeeService {

    @Resource
    private FeeMapper feeMapper;

    @Resource
    private SqlSessionFactory sqlSessionFactory;

    @Override
    public int saveByFor(List<Fee> feeList) {
        // 记录结果（影响行数）
        int res = 0;
        // 循环插入
        for (Fee fee : feeList) {
            res += feeMapper.insertByOne(fee);
        }
        return res;
    }

    @Override
    public int saveByForeach(List<Fee> feeList) {
        // 通过mapper的foreach动态拼接sql插入
        return feeMapper.insertByForeach(feeList);
    }

    @Transactional
    @Override
    public int saveByBatch(List<Fee> feeList) {
        // 记录结果（影响行数）
        int res = 0;
        // 开启批处理模式
        SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
        FeeMapper feeMapper = sqlSession.getMapper(FeeMapper.class);
        for (int i = 1; i <= feeList.size(); i++) {
            // 利用mapper的单条插入方法插入
            res += feeMapper.insertByOne(feeList.get(i-1));
            // 进行分片类似 JDBC 的批处理
            if (i % 100000 == 0) {
                sqlSession.commit();
                sqlSession.clearCache();
            }
        }
        sqlSession.commit();
        sqlSession.clearCache();
        return res;
    }
}

同样这里继承 ServiceImpl 也只是为了使用最后的 MP 自带的批处理插入方法。如果不使用那种方式则可以不继承。

普通插入

同样为了形成对比，先来看看循环单条插入所需要的执行时间，通过 SpringBootTest 进行测试：

测试代码（代码没有使用 MyBatis Plus 的增强功能，所以这种方式在 MyBatis 和 MyBatis Plus 两个框架都适用）：

/**
 * MP 测试类
 *
 * @author 单程车票
 */
@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo1() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // 普通插入
        feeService.saveByFor(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（普通插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 1; i <= 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

测试结果：

img

可以看到花费时间大致和 JDBC 的普通插入方式一致都在 80s 左右。

foreach 动态拼接插入

接下来，看看使用 foreach 动态 sql 来实现拼接 sql 的方式进行插入的执行时间是多少。

测试代码（代码没有使用 MyBatis Plus 的增强功能，所以这种方式在 MyBatis 和 MyBatis Plus 两个框架都适用）：

/**
 * MP 测试类
 *
 * @author 单程车票
 */
@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo2() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // foreach动态拼接插入
        feeService.saveByForeach(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（foreach动态拼接插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 1; i <= 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

测试结果：

img

可以看到当数据量为 10w 条时，测试结果报错，这是因为默认情况下 MySQL 可执行的最大 SQL 语句大小为 4194304 即 4MB，这里使用动态 SQL 拼接后的大小远大于默认值，故报错。

可以通过设置 MySQL 的默认 sql 大小来解决此问题（这里设置为 10MB）：

sql
复制代码set global max_allowed_packet=10*1024*1024;

重新运行后的测试结果：

img

可以看到增大默认是 SQL 大小后插入的时间在 3s 左右，相对于 JDBC 的批处理来说速度要稍微慢一点，但比起普通插入来说已经优化很多了。但是这种方式的弊端也很明显，就是无法确定 SQL 究竟多大，不能总是更改默认的 SQL 大小，不实用。

批处理插入

接下来，来看看 JDBC 的批处理插入方式在 MyBatis / MyBatis Plus 框架中是如何实现的。

测试代码（代码没有使用 MyBatis Plus 的增强功能，所以这种方式在 MyBatis 和 MyBatis Plus 两个框架都适用）：

/**
 * MP 测试类
 *
 * @author 单程车票
 */
@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo3() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // 批处理插入
        feeService.saveByBatch(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（批处理插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

测试结果：

img

可以看到使用 MyBatis / MyBatis Plus 框架实现的批处理插入方式和 JDBC 的批处理插入方式的执行时间都在 1s 左右。

实现的核心代码如下：

@Transactional
@Override
public int saveByBatch(List<Fee> feeList) {
    // 记录结果（影响行数）
    int res = 0;
    // 开启批处理模式
    SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
    FeeMapper feeMapper = sqlSession.getMapper(FeeMapper.class);
    for (int i = 1; i <= feeList.size(); i++) {
        // 利用mapper的单条插入方法插入
        res += feeMapper.insertByOne(feeList.get(i-1));
        // 进行分片类似 JDBC 的批处理
        if (i % 100000 == 0) {
            sqlSession.commit();
            sqlSession.clearCache();
        }
    }
    sqlSession.commit();
    sqlSession.clearCache();
    return res;
}

需要注意的是：

  • 和 JDBC 一样都需要开启允许重写批量处理提交（即在配置文件的数据库配置 url 中加上rewriteBatchedStatements=true）。
  • 代码中需要使用批处理模式（利用 SqlSessionFactory 设置批处理模式并获取对应的 Mapper 接口）
  • 代码中同样进行了分片操作，目的是为了减轻数据库的负担避免在处理时内存占用过高。
  • 可以在实现方法中加上 @Transactional 注解来起到手动提交事务的效果（好处和 JDBC 一样）。

MP 自带的批处理插入

接下来，看看 MyBatis Plus 自带的批处理方法的执行效率如何。

测试代码（注意代码中没有使用到上面的任何实现代码，而是依靠 MP 自带的 saveBatch() 方法完成批量插入）：

/**
 * MP 测试类
 *
 * @author 单程车票
 */
@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo4() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // MP 自带的批处理插入
        feeService.saveBatch(feeList);
        // 结束时间
        long end = System.currentTimeMillis();
        System.out.println("十万条数据插入时间（MP 自带的批处理插入方式）：" + (end - start) + " ms");
    }

    private List<Fee> getFeeList() {
        List<Fee> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list.add(new Fee(null, "o" + i,
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111"),
                    new BigDecimal("11111.111")));
        }
        return list;
    }
}

测试结果：

img

可以看到使用 MP 自带的批处理方法执行时间在 2s 左右，虽然比自己实现的批处理方法差了一点点，但是架不住它可以拿来就用，所以这也是一种好的选择。

注意：这里依旧需要开启允许重写批量处理提交（即在配置文件的数据库配置 url 中加上rewriteBatchedStatements=true）。这个很关键，否则效率上会大打折扣的。

放一张没有开启允许重写批量处理的执行结果：

img

MP 自带的 saveBatch() 方法源码分析

相信大家不只是为了使用 MP 的批量处理方法，应该都好奇 MP 自带的 saveBatch() 方法是如何实现的，那么接下来我想深入源码一起来看看。

进入第一层源码：

img

可以看到这里带上了一个参数 batchSize = 1000（这里其实就是分片大小 1000，也是我上述代码借鉴的分片大小），接着往下进入 executeBatch() 方法：

img

可以看到 Lambda 表达式其实跟上面的实现批处理插入方式类似，先一条一条插入数据，当达到分片大小后，提交并刷新，从而达到批处理的效果。再深入到下一个 executeBatch() 方法会看到底层使用的也是批处理模式。

img

所以其实 MP 自带的批处理方法和上文中实现的批处理方法类似。

总要有总结

以上就是这次批量插入场景问题下如何通过 JDBC 和 MyBatis / MyBatis Plus 框架实现批量插入的整个优化过程了。

通过上面的讲解，相信大家应该也可以看出来哪些实现方式是有着良好的效率和性能的。

  • 使用 JDBC 推荐使用自己实现批处理方式。
  • 使用 MyBatis / MyBaits Plus 推荐使用自己实现的批处理方式或 MP 自带的批处理方法。

记得使用批处理方式进行批量插入一定要带上 rewriteBatchedStatements=true，这点很重要。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/349945.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

分寝室

分寝室

L1-7 分寝室 分数 20 作者 陈越 单位 浙江大学 学校新建了宿舍楼&#xff0c;共有 n 间寝室。等待分配的学生中&#xff0c;有女生 n0​ 位、男生 n1​ 位。所有待分配…
阅读更多...
Vue使用svg图片-svg-sprite-loader插件

Vue使用svg图片-svg-sprite-loader插件

需求&#xff1a;设计给的一个按钮图标是svg的&#xff0c;不是element自带的图标使用插件svg-sprite-loader svg-sprite-loader 什么是svg-sprite-loader&#xff1f; 将多个 svg 打包成 svg-sprite。svg 雪碧图。类似于 CSS 中的 Sprite 技术。图标图形整合在 一起&#xf…
阅读更多...
爆火《幻兽帕鲁》被指用AI缝合宝可梦，开发者自曝传奇经历：是人类的奇迹

爆火《幻兽帕鲁》被指用AI缝合宝可梦，开发者自曝传奇经历：是人类的奇迹

梦晨 克雷西 发自 凹非寺 量子位 | 公众号 QbitAI 4天卖出600万份&#xff0c;爆火游戏《幻兽帕鲁》最高180万人同时在线&#xff0c;直接登顶。 这个成绩&#xff0c;甚至在整个Steam游戏平台历史上也能排到第二&#xff0c;连平台自家王牌CS2都被挤下去了。 同时&#xff0…
阅读更多...
NGINX如何实现rtmp推流服务

NGINX如何实现rtmp推流服务

最近直播大火&#xff0c;直播推流软件遍地开花&#xff0c;那么用NGINX如何进行推流呢&#xff1f;下面我们就简单的介绍一下用NGINX的rtmp模块如何实现视频推流&#xff0c;我们主要从一下几点介绍&#xff1a; 推流拉流推流认证拉流认证 package mainimport ("fmt&qu…
阅读更多...
[MQ]常用的mq产品图形管理web界面或客户端

[MQ]常用的mq产品图形管理web界面或客户端

一、MQ介绍 1.1 定义 MQ全称为Message Queue&#xff0c;消息队列是应用程序和应用程序之间的通信方法。 如果非要用一个定义来概括只能是抽象出来一些概念&#xff0c;概括为跨服务之间传递信息的软件。 1.2 MQ产品 较为成熟的MQ产品&#xff1a;IBMMQ&#xff08;IBM We…
阅读更多...
公司内网虚拟机中穿透服务器Coturn的搭建

公司内网虚拟机中穿透服务器Coturn的搭建

1. 写在前面 coturn服务器的搭建文章已经非常多&#xff0c;但是对于对linux不熟悉的人来说排查错误的文章不多&#xff0c;此篇文章把我这次搭建过程以及如何排查问题做一个梳理我这里是在oracle vm虚拟机中搭建安装的ubuntu&#xff0c;通过H3C路由器映射到外网以下介绍我只…
阅读更多...
SpringBoot的默认组件扫描

SpringBoot的默认组件扫描

本篇博客主要探究&#xff1a;为什么SpringBoot项目中我们没有配置组件扫描的包&#xff0c;为什么它会默认扫描启动类所在的包&#xff1f; 一、访问与启动类所在同一包下的接口 我们先来看一个简单的接口&#xff1a; 我们可以观察到&#xff0c;HelloController这个类处在…
阅读更多...
Linux中LVM实验

Linux中LVM实验

LVM实验&#xff1a; 1、分区 -L是大小的意思-n名称的意思 从vg0&#xff08;卷组&#xff09;分出来 2、格式化LV逻辑卷 LVM扩容 如果icdir空间不够了&#xff0c; 扩展空间lvextend -L 5G /dev/vg0/lv1 /dev/vg0/lv1(pp,vg,lv) 刷新文件系统xfs_growfs /lvdir VG扩容 …
阅读更多...
阿里云快速搭建《幻兽帕鲁》服务器自建指南

阿里云快速搭建《幻兽帕鲁》服务器自建指南

如何自建幻兽帕鲁服务器&#xff1f;基于阿里云服务器搭建幻兽帕鲁palworld服务器教程来了&#xff0c;一看就懂系列。本文是利用OOS中幻兽帕鲁扩展程序来一键部署幻兽帕鲁服务器&#xff0c;阿里云百科aliyunbaike.com分享官方基于阿里云服务器快速创建幻兽帕鲁服务器教程&…
阅读更多...
【华为云-云驻共创】数据高速公路—数仓集群通信技术详解

【华为云-云驻共创】数据高速公路—数仓集群通信技术详解

【摘要】本文讲解GaussDB&#xff08;DWS&#xff09;集群通信技术如何在大规模集群中承载高并发业务&#xff0c;如何实现高性能分布式通信系统。主要讲述客户端、CN、DN三类进程间的通信原理和流程&#xff0c;分为CN通信框架和DN间通信框架。 数据仓库服务GaussDB&#xff0…
阅读更多...
伊恩·斯图尔特《改变世界的17个方程》薛定谔方程笔记

伊恩·斯图尔特《改变世界的17个方程》薛定谔方程笔记

想法是等这学期学到薛定谔方程后再把整份完善下。 它告诉我们什么&#xff1f; 这个方程不是把物质作为粒子&#xff0c;而是作为波&#xff0c;并描述这样的波如何传播。 为什么重要&#xff1f; 薛定谔方程是量子力学的基础&#xff0c;它与广义相对论一起构成了当今最有效的…
阅读更多...
【CKA认证考试参考题库及万字详解】

【CKA认证考试参考题库及万字详解】

目录 【CKA认证考试参考题库及详解】说明题库总结第1题&#xff1a;节点排障1. 分值权重&#xff1a;13%2. 考题内容2.1 设置配置环境2.2 Context2.3 Task 3. 考点解析4. 考点参考链接5. 操作命令和结果5.1 必背操作命令5.2 详细操作步骤和结果 6. 验证命令和结果 第2题&#x…
阅读更多...
近期孩子燃放烟花已引发多起火灾 富维图像烟火识别来揭秘

近期孩子燃放烟花已引发多起火灾 富维图像烟火识别来揭秘

家长们&#xff0c;请注意&#xff01;最近有报道称&#xff0c;孩子们燃放烟花引发了多起火灾。 相关案例1 1月4日&#xff0c;浙江嘉兴海盐武原街道一小区内一名12岁的男孩在楼下燃放烟花&#xff0c;只见烟花点着后&#xff0c;突然“腾空而起”飞入五楼住户的阳台。所幸扑…
阅读更多...
【doghead】2： 数据产生及pacing发送

【doghead】2： 数据产生及pacing发送

默认采用fake的数据生产者 FakeDataProducer也可以读取h264文件生成：H264FileDataProducerUSE_FAKE_DATA_PRODUCER G:\CDN\BWE-DEV\Bifrost\worker\src\bifrost\bifrost_send_algorithm\bifrost_pacer.cpp FakeDataProducer 生产制造rtp包 ExperimentDumpData ： 可用带宽、发…
阅读更多...
Jellyfin影音服务本地部署并结合内网穿透实现公网访问本地资源

Jellyfin影音服务本地部署并结合内网穿透实现公网访问本地资源

文章目录 1. 前言2. Jellyfin服务网站搭建2.1. Jellyfin下载和安装2.2. Jellyfin网页测试 3.本地网页发布3.1 cpolar的安装和注册3.2 Cpolar云端设置3.3 Cpolar本地设置 4.公网访问测试5. 结语 1. 前言 随着移动智能设备的普及&#xff0c;各种各样的使用需求也被开发出来&…
阅读更多...
EchoLink Launchpad在LBank圆满结束，投资额超过1.3亿 USDT，$ECHO即将上线

EchoLink Launchpad在LBank圆满结束，投资额超过1.3亿 USDT，$ECHO即将上线

继ACGN Protocol的成功之后&#xff0c;LBank刚刚结束了其第四期LaunchPad——EchoLink。这个项目在去中心化物理基础设施网络&#xff08;DePIN&#xff09;和物联网&#xff08;IoT&#xff09;领域标志着重要的进步&#xff0c;利用独特的设备工作证明&#xff08;PoDW&…
阅读更多...
PMP考试中问题的解决方法

PMP考试中问题的解决方法

PMP考试中的题型越来越倾向于情景题。特别是题干当中描述一个问题&#xff0c;问项目经理如何解决。大家有时候可能摸不着头脑&#xff0c;因此有必要给大家做个总结。 第一种方法&#xff1a;DMAIC 也就是六西格玛项目的模式。 D&#xff1a;Define&#xff0c;也就是首先要…
阅读更多...
易点易动设备管理系统的移动应用：在任何时间、任何地点管理设备

易点易动设备管理系统的移动应用：在任何时间、任何地点管理设备

随着科技的不断进步&#xff0c;移动应用已经成为了现代商业环境中不可或缺的一部分。企业需要能够随时随地管理和监控设备&#xff0c;以提高效率、降低成本并确保设备的正常运行。易点易动设备管理系统的移动应用为企业提供了便捷的解决方案&#xff0c;使设备管理变得更加灵…
阅读更多...
1031 查验身份证 (15)

1031 查验身份证 (15)

一个合法的身份证号码由17位地区、日期编号和顺序编号加1位校验码组成。校验码的计算规则如下&#xff1a; 首先对前17位数字加权求和&#xff0c;权重分配为&#xff1a;{7&#xff0c;9&#xff0c;10&#xff0c;5&#xff0c;8&#xff0c;4&#xff0c;2&#xff0c;1&am…
阅读更多...
将 Amazon Bedrock 与 Elasticsearch 和 Langchain 结合使用

将 Amazon Bedrock 与 Elasticsearch 和 Langchain 结合使用

Amazon Bedrock 是一项完全托管的服务&#xff0c;通过单一 API 提供来自 AI21 Labs、Anthropic、Cohere、Meta、Stability AI 和 Amazon 等领先 AI 公司的高性能基础模型 (FMs) 选择&#xff0c;以及广泛的 构建生成式 AI 应用程序所需的功能&#xff0c;简化开发&#xff0c;…
阅读更多...
最新文章

Copyright @ 2022~2023