项目实战--批量插入数据接口优化过程详解

已于 2024-08-03 08:56:16 修改
阅读量525 收藏 3
点赞数 6
分类专栏： Java Javaweb mybatis 文章标签： mybatis java sql mysql
于 2024-07-31 14:21:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40623672/article/details/140818320
版权

批量插入数据接口优化

一、前言

最近在项目上遇到批量插入接口先响应缓慢然后抛出异常的问题，主要是将APP的业务数据和用户点击/操作的行为数据插入MySQL，且每次需要插入超过 10w+ 的数据量并且字段较多，导致使用循环插入的方式（即MyBatis的<foreach collection=“behaverList” item=“behaver” separator=“,”>…</foreach>）插入数据插入的效率不高甚至抛出异常。
项目是从 JDBC 升级到 MyBatis / MyBatis Plus ，那就依次记录实现及优化过程。
在这里插入图片描述

二、建表

数据库版本 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;

三、JDBC插入

3.1 jdbc普通循环插入

/**
 * JDBC - 普通插入（循环遍历一条一条插入）
 */
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");
    }
}

执行结果：
在这里插入图片描述

3.2 jdbc批处理插入

批量插入+ 手动事务提交减少磁盘的写入次数可以提高插入速度，在配置 MySQL 的 url 时需要加上 rewriteBatchedStatements=true 开启允许重写批量提交。分片大小为 1000（参考 MP 框架的默认分片大小）避免一次性提交的数据量过大

/**
 * JDBC - 批处理插入
 */
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");
    }
}

执行结果：
在这里插入图片描述
可见使用批处理+手动提交的方式插入 10w 条数据的执行时间大概在 1s 左右，速度明显提高。

四、MyBatis批量插入

4.1 foreach动态拼接插入

使用<foreach>标签：此方式 MyBatis 和 MyBatis Plus 两个框架均可用
mapper.xml：

<?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="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>

service层调用：

@Service
public class FeeServiceImpl extends ServiceImpl<FeeMapper, Fee> implements FeeService {

    @Resource
    private FeeMapper feeMapper;

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

测试代码：

@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;
    }
}

ps：这里运行会报错，因为默认情况下 MySQL 可执行的最大 SQL 语句大小为 4194304 即 4MB，这里使用动态 SQL 拼接后的大小会远大于默认值，故报错。
在这里插入图片描述

解决方式，设置 MySQL 的默认 sql 大小为 10MB：

set global max_allowed_packet=10*1024*1024;

测试结果：
在这里插入图片描述
可见增大默认 SQL 大小后，插入的时间在 3s 左右，但这种方式的弊端明显，即无法确定 SQL 大小，也不能总更改默认的 SQL 大小，既不实用，也会引起项目异常。

4.2 批处理插入

在配置文件的数据库配置 url 中加上rewriteBatchedStatements=true

# 配置数据库
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

service层加入批处理代码：

@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 的批处理，分片量增加为100000
        if (i % 100000 == 0) {
            sqlSession.commit();
            sqlSession.clearCache();
        }
    }
    sqlSession.commit();
    sqlSession.clearCache();
    return res;
}

测试类：

@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;
    }
}

测试结果：
在这里插入图片描述
可见插入效率在 1s 左右。

五、MyBatis Plus批处理插入

5.1 MyBatis Plus 自带批处理

使用MyBatis Plus 自带的saveBatch()批处理方法完成批量插入，配置文件同上，需要开启允许重写批量处理提交。

@SpringBootTest
public class MPDemo {

    @Resource
    private FeeService feeService;

    @Test
    public void mpDemo4() {
        // 获取 10w 条测试数据
        List<Fee> feeList = getFeeList();
        // 开始时间
        long start = System.currentTimeMillis();
        // MyBatis Plus 自带的批处理插入
        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;
    }
}

测试结果：
在这里插入图片描述
可见使用 MP 自带的批处理方法执行时间在 2s 左右，虽然比自定义实现的批处理方法差一点点，但它可开箱即用，所以这是一种最好的选择。

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

第一层源码：
在这里插入图片描述
可见带上一个默认参数 batchSize = 1000，即分片大小 1000，也是上文jdbc借鉴的分片大小。接着进入 executeBatch() 方法：
在这里插入图片描述
可见 Lambda 表达式功能跟上面的实现批处理插入方式类似，先逐条插入数据，当达到分片大小后，提交并刷新，从而达到批处理的效果。再深入到下一个 executeBatch() 方法会看到底层使用的也是批处理模式。
在这里插入图片描述
因此 MP 自带的批处理方法和上文中实现的批处理方法类似但更易用。

六、MyBatis-Plus + ThreadPoolTaskExecutor

使用 Spring Boot + MyBatis-Plus + ThreadPoolTaskExecutor 构建一个快速、稳定且能够处理百万级数据批量插入的接口。

6.1 项目创建及依赖配置（pom.xml）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.icoderoad</groupId>
    <artifactId>batch-insertion</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Batch Insertion</name>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <!-- Spring Boot Web 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- MyBatis-Plus 依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>

        <!-- 数据库驱动 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- 线程池依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

6.2 配置文件（application.yml）

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db_name?useUnicode=true&characterEncoding=UTF-8&useSSL=false
    username: username
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver

  task:
    executor:
      core-pool-size: 100
      max-pool-size: 300
      queue-capacity: 99999

6.3 实体类

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("data_table")
public class DataEntity {
    private Long id;
    private String name;
    private String description;
}

6.4 Mapper 接口

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.icoderoad.entity.DataEntity;

public interface DataMapper extends BaseMapper<DataEntity> {
}

6.5 DataService 接口类

import java.util.List;
import com.icoderoad.entity.DataEntity;

public interface DataService {

    void batchInsertData(List<DataEntity> dataList);
}

6.6 服务类

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.icoderoad.entity.DataEntity;
import com.icoderoad.mapper.DataMapper;
import com.icoderoad.service.DataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

@Service
public class DataServiceImpl extends ServiceImpl<DataMapper, DataEntity> implements DataService {

    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;

    @Transactional
    public void batchInsertData(List<DataEntity> dataList) {
        // 分批插入数据
        int batchSize = 1000;  // 每批插入的数量

        List<Future<?>> futures = new ArrayList<>();

        for (int i = 0; i < dataList.size(); i += batchSize) {
            List<DataEntity> subList = dataList.subList(i, Math.min(i + batchSize, dataList.size()));
            futures.add(taskExecutor.submit(new Callable<Void>() {
                @Override
                public Void call() throws Exception {
                    baseMapper.insertBatchSomeColumn(subList);
                    return null;
                }
            }));
        }

        for (Future<?> future : futures) {
            try {
                future.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

6.7 Executor 配置类

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
public class ExecutorConfig {

    @Value("${spring.task.executor.core-pool-size}")
    private int corePoolSize;

    @Value("${spring.task.executor.max-pool-size}")
    private int maxPoolSize;

    @Value("${spring.task.executor.queue-capacity}")
    private int queueCapacity;

    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        return executor;
    }
}

6.8 控制器类

import com.icoderoad.entity.DataEntity;
import com.icoderoad.service.DataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

@RestController
public class DataController {

    @Autowired
    private DataService dataService;

    @PostMapping("/batchInsert")
    public String batchInsert(@RequestBody List<DataEntity> dataEntities) {
        dataService.batchInsertData(dataEntities);
        return "Batch insertion successful";
    }

    public static void main(String[] args) {
        List<DataEntity> dataList = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 1000000; i++) {
            DataEntity dataEntity = new DataEntity();
            dataEntity.setName("Name " + i);
            dataEntity.setDescription("Description " + random.nextInt());
            dataList.add(dataEntity);
        }
    }
}

七、总结

通过以上的优化和完善步骤，充分利用Spring Boot的强大功能、MyBatis-Plus的便捷高效操作以及ThreadPoolTaskExecutor 的高效并发处理能力，经验证可实现百万级数据的批量插入，在实际应用中，还可根据具体的业务需求和性能要求，对代码进行进一步的优化和调整。

Android图像处理值Region
gu_solo的博客
03-23 1057
Region.op：当两个区域重合时该如何处理，有6个取值： DIFFERENCE:：从region1中减去region2 INTERSECT：区region1和region3部分 REPLACE：用region2替换region1 REVERCE_DIFFERENCE：从region2中减去region1 UNION：合并region1和region2 XOR：取region1和re
opengl api
gangyanliang的专栏
08-22 1227
OpenGL库函数列表 OpenGl核心函数库   glAccum 操作累加缓冲区 glAddSwapHintRectWIN 定义一组被SwapBuffers拷贝的三角形 glAlphaFunc允许设置alpha检测功能 glAreTexturesResident 决定特定的纹理对象是否常驻在纹理内存中 glArrayElement 定义一个被用于顶点渲染的数组成分 glBegin
OPENGL中的帧缓存区概述
weixin_30732825的博客
02-19 387
（1）帧缓存介绍 OPENGL系统的帧缓冲区是由所有存储着像素信息的缓冲区组成的，包括：颜色缓冲区、深度缓冲区、模板缓冲区、累积缓冲区。可以使用glGetIntegerv()查询特定画面可用的缓冲区的存储信息。 颜色缓冲区是用于绘图的缓冲区，它包含了颜色索引或者RGB颜色数据，还可能有alpha数据。若OPENGL支持立...
OpenGL库函数列表
水云间
06-30 1256
<br />OpenGl核心函数库 glAccum 操作累加缓冲区<br />glAddSwapHintRectWIN 定义一组被SwapBuffers拷贝的三角形<br />glAlphaFunc允许设置alpha检测功能<br />glAreTexturesResident 决定特定的纹理对象是否常驻在纹理内存中<br />glArrayElement 定义一个被用于顶点渲染的数组成分<br />glBegin,glEnd 定义一个或一组原始的顶点<br />glBindTexture 允许建立一个绑定
OpenGL帧缓冲区
weixin_34232744的博客
11-19 421
在OpenGL窗口中, 左下角的像素为(0, 0). 一般而言, 像素(x, y)占据的矩形区域左下角为(x, y), 右上角为(x+1, y+1). 10.1 缓存及其用途 1) 颜色缓存, 左前,右前,左后,右后和任意数量的辅助颜色缓存;2) 深度缓存3) 模板缓存4) 累积缓存 注意:X窗口系统,RGBA模式至少保证1个颜色缓冲区,模板缓冲区,深度缓冲区,累计缓冲区颜色索引模式至...
WARNING: The scripts pip, pip3 and pip3.9 are installed in '/home/lgc/.local/bin' which is not on PATH. Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
07-07
关于您的问题，您可以通过将'/home/lgc/.local/bin'目录添加到您的PATH环境变量中来解决此警告。这样做的方法会因操作系统而有所不同，下面是一些常见操作系统的解决方法： 对于Linux和macOS用户： 1. 打开终端。 2...
Inconsolata-LGC：Inconsolata LGC扩展
02-05
Inconsolata-LGC：Inconsolata LGC扩展
Opengl LGC_Lsys.rar
02-27
一个用opengl编写的植物根生长系统。
LGC算法-SCI经典
09-16
LGC算法，全称为Learning with Local and Global Consistency，是一种图学习算法，主要用于图上的半监督学习。该算法利用图的结构特征来传播标签信息，使具有相似结构的节点标签趋于一致。LGC算法的提出，是为了更好...
OpenGL实现的植物根系生长模拟系统
标题中的“Opengl LGC_Lsys.rar”指的是一个利用OpenGL图形库编写的程序文件包。OpenGL（Open Graphics Library）是一个跨语言、跨平台的应用程序编程接口（API），用于渲染2D和3D矢量图形。该库广泛应用于计算机...
Opengl纹理映射
wymhhgg99的专栏
01-11 1446
9.4 纹理对象 使用纹理对象来存储纹理数据的步骤: 1) 生成纹理对象名称 2) 将纹理对象绑定到纹理数据(包括图像数据数组和纹理属性), 即创建纹理对象. 3) 如果OpenGL实现高性能纹理工作集, 应检查是否有足够的空间来存储所有的纹理对象. 如没有足够空间, 应设置每个纹理对象的优先级, 以确保最常用的纹理留在工作集中 4) 绑定和重新绑定纹理对象, 以便可以将其中的纹理
opengl函数
鶸者为何战斗
06-03 769
1.glAccum--操作在多重缓冲区中进行; 2.glAlphaFunc--指定Alpha测试函数; 3.glBegin--开始操纵一组点进行画图; 4.glBitmap--再设备上画一指定属性的位图文件; 5.glBlendFunc--指定象素的算法; 6.glCallList-- 执行一个显示列表; 7.glCallLists-- 执行一组显示列表; 8.glClear--在视
帧缓冲区
依文依叶
07-04 3586
1.帧缓存包括颜色、scissor、alpha、stencil、depth这些缓存，所以帧缓存不是一片缓存，而是所有这些缓存的组合，帧缓存它对应了屏幕上的每一个pixel（不是真正的pixel，而是一个fragment所对应的位置）的各种这些信息（颜色、ZBUFFER、等等），几何体的fragment时没有帧缓存的，帧缓存时屏幕上的，一个缓存的一位就对应一个位片面。 Colorbuffer是最终
OpenGL系列教程之十一：OpenGL网格化
10-22 9492
网格化是将凹多边形或有边相交的多边形划分成凸多边形。由于openGL渲染时只接受凸多边形，这些非凸多边形在渲染之前必须先被网格化。 第一行中第一个图形是4条边的凹多边形，第二个图形中间有个洞，第三个图形有相交的边 下载：tessellation.zip，stencilTest.zip 概述 网格化基本的步骤是将所有非凸多边形的顶点坐标
WPF【11_4】WPF实战-重构与美化(MVVM 架构)
keke10的专栏
05-27 930
点击刷新， UI 则会通过发送事件的方式通知视图模型，而视图模型在收到刷新请求以后，就会去数据库提取数据，然后重新把数据提供给视图。最后，视图与模型之间由于加入了视图模型，所以产生了系统的分层，而数据也得到了有效的隔离，它们之间则是一个间接引用的关系。虽然对于一个 WPF 项目来说，仅仅使用 Model 和 View， 甚至只使用 View 也能完成各种各样复杂的功能，比如说上一章我们的实战项目只有 View， 同样也可以完成客户预约系统的开发。而视图模型作为业务逻辑的载体，也会承担与数数据库的沟通工作。
springboot--实战--大事件--用户接口开发
最新发布
m0_73856804的博客
05-27 2015
定义了一种简洁的、自包含的格式，用于通信双方以JSON数据格式安全的传输信息。组成：第一部分：Header（头），记录令牌类型、签名算法等。例如,算法用于防篡改第二部分：Payload（有效载荷），携带一些自定义信息，默认信息。例如。而外在表示为一段无规律的64个可打印字符原因：借助base64编码方式（Base64：是一种基于64个可打印字符（A-Z a-z 0-9 + /）来表示二进制数据的编码方式）来完成，将json字符串变为64个可打印字符，
21. 自动化测试框架开发之Excel配置文件的测试用例改造
Tom的专栏
05-20 1416
本文介绍了如何通过Excel配置文件实现自动化测试用例的改造。首先，测试框架的核心架构依赖于unittest、paramunittest、页面对象模型和Excel数据读取器。其次，通过ExcelReader加载Excel数据，支持参数化测试。测试用例参数化方案包括使用paramunittest和subTest，后者支持单测试方法管理多组数据，失败时继续执行后续用例。关键技术点包括数据驱动流程和异常处理机制，确保测试失败时自动截图并保留异常堆栈。Excel数据规范要求第一行为标题行，列名与代码参数对应。工程实
SpringMVC（结合源码浅析工作流程）
weixin_45865163的博客
05-23 917
Spring MVC是基于前端控制器（）设计模式的 Web 框架，在 Web 应用中指一个统一的入口，用来接收所有客户端请求，并统一进行分发、处理。在SpringMVC中，前端控制器就是Controller。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

容若只如初见

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值