大批量数据Excel导出经验总结

最新推荐文章于 2024-05-04 04:08:20 发布
最新推荐文章于 2024-05-04 04:08:20 发布
阅读量9.2k 收藏 51
点赞数 5
分类专栏： JAVA相关笔记 工作总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/panyongcsd/article/details/93853687
版权

文章目录

背景

目前系统中有一些接口做数据的导出，一开始数据量很小，所以在设计的时候性能什么的都没考虑到；随着数据量的不断增加，逐渐出现了一些问题：

  • 耗时增加；
  • SQL执行时间过长，占用数据库连接；
  • 内存占用过高，导致FullGC频繁。

以及老版POI接口的问题：

  • Excel写入过慢；
  • 每个Sheet仅支持65536条数据；
  • 容易导致OOM。

方案

为了解决以上问题，引入POI的SXSSFWorkbook，设计了一个基于生产-消费者模式的方案：

  1. 先查询条件下的数据总量T；
  2. 根据总量T，将SQL查询任务分片(每片任务量1W)，得到任务数量N=T/1W；
  3. 将N个SQL查询任务交予线程池执行，得到异步结果集合List<Future<T>>；
  4. 遍历异步结果集合，将每个异步结果交给生产者线程(数量N)处理；
  5. 生产者线程阻塞在异步任务线程，等待其执行完成，然后将结果放入阻塞队列(阻塞队列长度10，以此限制同时存在于内存中的结果数量)；如果阻塞队列已满，则休眠一段时间，否则取出存入阻塞队列；
  6. 消费者线程(基于POI的特性，只设置一条线程)在阻塞队列中取出1组数据(每组数据<=1W条)，利用POI生成Cell并写入数据，在处理完1组数据后，将数据从内存flush到硬盘以节省内存，并将该组数据的引用置空便于GC；
  7. 消费者线程在消费完所有的任务数据后结束，主线程将所有的Row数据写入到Response中，Excel导出完成。

效果

数据量(单位：万条)耗时(单位：秒)
12.61
35.26
55.78
1010.51
2018.31
5045.43

实现

主线程
public void getFinanceMonthly(@RequestParam("startDate") String startDateStr, @RequestParam("endDate") String endDateStr, HttpServletResponse response) {
            //......省略前置操作


            Long dataQueryStartTS = System.currentTimeMillis();
            log.info("查询并构建数据开始");

            //获取当前条件下数据总条数
            Integer total = orderQueryService.getFinanceMonthlyStatTotal(startDate, endDate);
            //......省略一些操作
            InputStream fs = new ClassPathResource("template/orderFinanceStatistics.xlsx").getInputStream();
            XSSFWorkbook wb = new XSSFWorkbook(fs);
            //引入SXSSFWorkbook，利用其高效的Excel数据处理特性
            SXSSFWorkbook sxssfWorkbook = new SXSSFWorkbook(wb, 1000);
            //......省略一些操作

            //根据总条数设置任务数量和生产者、消费者个数
            Integer taskCount = total % BATCH_AMOUNT == 0 ? total / BATCH_AMOUNT : (total / BATCH_AMOUNT) + 1;

            //把任务分片后交给线程池执行并得到Future集合
            ExecutorService sqlTaskExecutorService = Executors.newFixedThreadPool(5);
            List<Future<List<OrderFinanceStatisticsDTO>>> futureResultList = new ArrayList<>(taskCount);
            for (int i = 1; i <= taskCount; i++){
                StatisticsTask task = new StatisticsTask(orderQueryService, i, startDate, endDate);
                Future<List<OrderFinanceStatisticsDTO>> futureResult = sqlTaskExecutorService.submit(task);

                futureResultList.add(futureResult);
            }
            sqlTaskExecutorService.shutdown();

            //遍历Future集合,交给生产者处理，等待结果后放入阻塞队列
            ArrayBlockingQueue<List<OrderFinanceStatisticsDTO>> queue = new ArrayBlockingQueue<>(10);
            ExecutorService producerExecutorService = Executors.newFixedThreadPool(5);
            for (int i = 0; i < taskCount; i++) {
                Producer producer = new Producer(queue, futureResultList.get(i), "producer_"+i);
                producerExecutorService.submit(producer);
            }
            producerExecutorService.shutdown();

            //消费者开始消费阻塞队列中数据
            log.info("开始写入数据");
            Long dataWriteStartTS = System.currentTimeMillis();
            Consumer consumer = new Consumer(queue, sxssfWorkbook, total);
            consumer.start();
            //确保主线程的后续操作在消费者线程结束(即数据都写入row)后再执行
            consumer.join();
            log.info(String.format("数据写入结束,耗时：%s ms", System.currentTimeMillis() - dataWriteStartTS));

            sxssfWorkbook.write(writer);
            writer.flush();
            sxssfWorkbook.dispose();

            Long dataQueryEndTS = System.currentTimeMillis();
            log.info(String.format("数据查询构建成功，耗时：%s ms", dataQueryEndTS - dataQueryStartTS));
			}catch (IOException e){
			//......省略一些操作
        }
    }
任务
public class StatisticsTask implements Callable<List<OrderFinanceStatisticsDTO>> {

    private OrderQueryService orderQueryService;
    private Integer page;
    private Date startDate;
    private Date endDate;

    /**
     * 初始化任务类
     * @param orderQueryService
     * @param page
     * @param startDate
     * @param endDate
     */
    public StatisticsTask(OrderQueryService orderQueryService, Integer page, Date startDate, Date endDate) {
	    //对数据进行分页查询
        this.orderQueryService = orderQueryService;
        this.page = (page - 1) * StatisticsController.BATCH_AMOUNT;
        this.startDate = startDate;
        this.endDate = endDate;
    }

    @Override
    public List<OrderFinanceStatisticsDTO> call() throws Exception {

        return orderQueryService.getFinanceMonthlyStat(startDate, endDate, page);
    }
}
生产者
public class Producer extends Thread {
    private static final Logger log = LoggerFactory.getLogger(Producer.class);

    //阻塞队列，防止多线程问题以及限制内存使用量
    private ArrayBlockingQueue<List<OrderFinanceStatisticsDTO>> queue;
    private Future<List<OrderFinanceStatisticsDTO>> futureResult;

    public Producer(ArrayBlockingQueue<List<OrderFinanceStatisticsDTO>> queue, Future<List<OrderFinanceStatisticsDTO>> futureResult, String threadName) {
        super(threadName);
        this.queue = queue;
        this.futureResult = futureResult;
    }

    @Override
    public void run() {
        Long startTime = System.currentTimeMillis();
        while (true) {
            try {
                if (futureResult.isCancelled()) {
                    break;
                }
                if (futureResult.isDone()) {
				    //如果队列已满，生产者休眠300ms
                    if (queue.remainingCapacity() < 1) {
                        log.info(String.format("生产者线程[%s]: 队列已满，休眠300ms", this.getName()));
                        Thread.sleep(300);
                        continue;
                    }
                    List<OrderFinanceStatisticsDTO> orderFinanceStatisticsDTOList = futureResult.get();

                    Long endTime = System.currentTimeMillis();
                    log.info(String.format("生产者线程[%s]成功获取1W条数据，耗时：[%s]ms", this.getName(), (endTime - startTime)));
					//将数据放入阻塞队列
                    queue.put(orderFinanceStatisticsDTOList);
                    log.info(String.format("生产者线程[%s]成功入队1W条数据，在队列阻塞：[%s]ms", this.getName(), System.currentTimeMillis() - endTime));
                    break;
                } else {
                    log.info(String.format("生产者线程[%s]: 查询未结束，休眠300ms", this.getName()));
                    Thread.sleep(300);
                }
            } catch (InterruptedException | ExecutionException e) {
                log.error(String.format("生产者线程[%s]失败-->", this.getName()), e);
                break;
            }
        }
    }
}
消费者
public class Consumer extends Thread{
    private static final Logger log = LoggerFactory.getLogger(Consumer.class);

    private ArrayBlockingQueue<List<OrderFinanceStatisticsDTO>> queue;
    private Integer count;
    private Integer total;
    private SXSSFWorkbook sxssfWorkbook;
    private Integer times;

    public Consumer(ArrayBlockingQueue<List<OrderFinanceStatisticsDTO>> queue, SXSSFWorkbook sxssfWorkbook, Integer total) {
        this.queue = queue;
        this.total = total;
        this.count = 0;
        this.sxssfWorkbook = sxssfWorkbook;
        this.times = 1;
    }

    @Override
    public void run() {
        try {
            while (true) {
                if (count >= total){
                    break;
                }
                log.info(String.format("消费者第[%s]次从队列中取出数据，准备写入Excel", this.times));
                Long dataWriteStartTS = System.currentTimeMillis();
                List<OrderFinanceStatisticsDTO> financeStatisticsDTOList = queue.take();
                log.info(String.format("消费者线程[%s]成功获取1W条数据，在队列阻塞：[%s]ms", this.getName(), System.currentTimeMillis() - dataWriteStartTS));

                //根据总条数确定消费者本次写入数据时的sheet和开始行数
                int index = count % StatisticsController.MAX_ROW_SHEET == 0 ? (count + 2) : (count % StatisticsController.MAX_ROW_SHEET + 2);
                count += financeStatisticsDTOList.size();
                Integer sheetNum = count / StatisticsController.MAX_ROW_SHEET;
                Sheet sheet = sxssfWorkbook.getSheetAt(sheetNum);
                writeExcel(financeStatisticsDTOList, sheet, index);

                Long dataWriteEndTS = System.currentTimeMillis();
                log.info(String.format("消费者第[%s]次写入Excel完成，耗时%s ms", this.times, (dataWriteEndTS - dataWriteStartTS)));
                this.times++;
            }
        } catch (InterruptedException e) {
            log.error("消费者[%s]获取队列数据异常-->",e);
        }
    }
	
	private void writeExcel(List<OrderFinanceStatisticsDTO> financeStatisticsDTOList, Sheet sheet, Integer index) {
        if (CollectionUtils.isEmpty(financeStatisticsDTOList)){
            log.info(String.format("消费者[%s]: 数据为空", this.getName()));
            return;
        }

        for (int i = 0; i < financeStatisticsDTOList.size(); i++) {
            Row row = sheet.createRow(index++);
            OrderFinanceStatisticsDTO statisticsDTO = financeStatisticsDTOList.get(i);

            row.createCell(0).setCellValue(statisticsDTO.getOrderDate());
            //.....省略设置表格数据的代码
        }
		//处理完以后将数据引用置空便于GC
        financeStatisticsDTOList.clear();
    }
}
SQL
<select id="getFinanceMonthlyStat" resultMap="OrderFinanceStatisticsMap" timeout="20">
        SELECT
            # .....省略字段和表连接代码
            WHERE
            go.order_time BETWEEN #{monthStartDate} AND #{monthEndDate}
            AND go.`status` IN (3, 4, 5, 6, 7)
            AND go.sales_type IN (1, 2, 4)
            AND go.is_deleted = 'N'
            ORDER BY go.order_time DESC
			# 数据分页
            LIMIT #{page,jdbcType=INTEGER},10000
    </select>

愿景

在此方案的基础上，利用组合方法、模板设计模式，将任务、生产者、消费者更加通用化、框架化；使用者只需实现特定接口并重写SQL任务、数据处理(如果是多表联查也可以不实现)、Excel数据写入等方法，即可轻松接入该方案。

愿景实现

目前已实现愿景，具体使用方式如下所示：

主控制类

下载Controller中，对于SXSSFWorkbook之前的代码需自己完成；对于框架类的使用，只需要构建查询参数并初始化导出框架类启动即可：

@RequestMapping(value = "/monthly", method = RequestMethod.GET)
    public void getFinanceMonthly(@RequestParam("startDate") String startDateStr, @RequestParam("endDate") String endDateStr,
                                  HttpServletResponse response) {

        ServletOutputStream writer = null;
        log.info(String.format("getFinanceMonthly(),日期:{%s}--{%s}", startDateStr, endDateStr));

            Date startDate = new Date(startDateStr);
            Date endDate = new Date(endDateStr);

            Long dataQueryStartTS = System.currentTimeMillis();
            log.info("查询并构建数据开始");

            //获取当前条件下数据总条数
            Integer total = orderQueryService.getFinanceMonthlyStatTotal(startDate, endDate);
            if (total == null || total == 0) {
                writer.write("数据为空".getBytes("gbk"));
                writer.flush();
                return;
            }
            
            String fileName = String.format("Monthly_Finance_%s.xlsx", endDateStr);
            InputStream fs = new ClassPathResource("template/orderFinanceStatistics.xlsx").getInputStream();
            XSSFWorkbook wb = new XSSFWorkbook(fs);
            SXSSFWorkbook sxssfWorkbook = new SXSSFWorkbook(wb, 1000);
            response.setCharacterEncoding("utf-8");
            response.setContentType("application/vnd.ms-excel");
            response.setHeader("Content-Disposition", "attachment;fileName="
                    + new String(fileName.getBytes("UTF-8"), "ISO8859-1"));

            //根据总条数设置任务数量和生产者、消费者个数
            Integer taskCount = total % BATCH_AMOUNT == 0 ? total / BATCH_AMOUNT : (total / BATCH_AMOUNT) + 1;

           //构建框架的请求参数
            Map<String, String> businessParams = new HashMap<>();
            businessParams.put("startDate", startDateStr);
            businessParams.put("endDate", endDateStr);
			//初始化导出框架
            ExportConfigThread configThread = new ExportConfigThread("财务统计", total, BATCH_AMOUNT, businessParams,
                    sxssfWorkbook, orderQueryService, writerExcelService);
			//启动导出线程并使主线程等待该线程完成
            configThread.start();
            configThread.join();

            Long dataWriteStartTS = System.currentTimeMillis();
            log.info(String.format("数据写入结束,耗时：%s ms", System.currentTimeMillis() - dataWriteStartTS));

            sxssfWorkbook.write(writer);
            writer.flush();
            sxssfWorkbook.dispose();

            Long dataQueryEndTS = System.currentTimeMillis();
            log.info(String.format("数据查询构建成功，耗时：%s ms", dataQueryEndTS - dataQueryStartTS));
        }catch (IOException e){
            log.error("writer() 异常-->",e);
        } catch (InterruptedException e) {
            log.error("消费者异常--->",e);
        } finally {
            if (writer != null){
                try {
                    writer.close();
                } catch (IOException e) {
                    log.error("关闭writer 异常-->",e);
                }
            }
        }
    }
实现数据查询接口
public interface TaskService<T> {
    /**
     * 查询数据，可以只查左表(需在下面的方法中进行数据的关联处理)；也可以关联查询
     * @param businessParams
     * @param offset
     * @param limit
     * @return
     */
    List<T> queryData(Map<String, String> businessParams, Integer offset, Integer limit);

    /**
     * 如果在SQL里进行了多表联查，那么该方法只需要实现空方法体即可
     * 否则请在该方法中对数据进行关联处理
     * @param majorDataList
     * @param businessParams
     * @return
     */
    List<T> processData(List<T> majorDataList, Map<String, String> businessParams);
}

public interface OrderQueryService extends TaskService<OrderFinanceStatisticsDTO>;

@Override
    public List<OrderFinanceStatisticsDTO> queryData(Map<String, String> businessParams, Integer offset, Integer limit) {

        return getFinanceMonthlyStat(new Date(businessParams.get("startDate")), new Date(businessParams.get("endDate")), offset);
    }

    @Override
    public List<OrderFinanceStatisticsDTO> processData(List<OrderFinanceStatisticsDTO> majorDataList, Map<String, String> businessParams) {
        //Do nothing
        return null;
    }
实现Excel数据操作接口
public interface WriterService<T> {
    void  write2Rows(List<T> list, Sheet sheet, Integer index);
}

@Component
public class WriterExcelServiceImpl implements WriterService<OrderFinanceStatisticsDTO> {
    @Override
    public void write2Rows(List<OrderFinanceStatisticsDTO> financeStatisticsDTOList, Sheet sheet, Integer index) {
        if (CollectionUtils.isEmpty(financeStatisticsDTOList)){
            return;
        }

        for (int i = 0; i < financeStatisticsDTOList.size(); i++) {
            Row row = sheet.createRow(index++);
            OrderFinanceStatisticsDTO statisticsDTO = financeStatisticsDTOList.get(i);

            row.createCell(0).setCellValue(statisticsDTO.getOrderDate());
            row.createCell(1).setCellValue(statisticsDTO.getOrderId());
            row.createCell(2).setCellValue(statisticsDTO.getProductName());
            row.createCell(3).setCellValue(statisticsDTO.getProductCombinationName());
            row.createCell(4).setCellValue(statisticsDTO.getCustomName());
            row.createCell(5).setCellValue(statisticsDTO.getPayMoney());
            row.createCell(6).setCellValue(statisticsDTO.getProductPayMoney());
            row.createCell(7).setCellValue(statisticsDTO.getFreight());
            row.createCell(8).setCellValue(statisticsDTO.getPaymentType() == null ? ""
                    : statisticsDTO.getPaymentType().getDesc());
            row.createCell(9).setCellValue(statisticsDTO.getPaymentNo());
            row.createCell(10).setCellValue(statisticsDTO.getRefundMoney());
            row.createCell(11).setCellValue(statisticsDTO.getCostPrice());
            row.createCell(12).setCellValue(statisticsDTO.getStatus());
            row.createCell(13).setCellValue(statisticsDTO.getSendDate());
            row.createCell(14).setCellValue(statisticsDTO.getReceiveDate());
            row.createCell(15).setCellValue(statisticsDTO.getReportDate());
            row.createCell(16).setCellValue(statisticsDTO.getSampleCode());
            row.createCell(17).setCellValue(statisticsDTO.getSupplierName());
            row.createCell(18).setCellValue(statisticsDTO.getSendSupplierName());
            row.createCell(19).setCellValue(statisticsDTO.getSalesType() == null ? ""
                    : statisticsDTO.getSalesType().getName());
            row.createCell(20).setCellValue(statisticsDTO.getThirdOrderCode());
            if (statisticsDTO.getOriginalOrderId() != null) {
                row.createCell(21).setCellValue(statisticsDTO.getOriginalOrderId());
            }
            if (statisticsDTO.getNewOrderId() != null) {
                row.createCell(22).setCellValue(statisticsDTO.getNewOrderId());
            }
            row.createCell(23).setCellValue(statisticsDTO.getOperateType() == null ? ""
                    : statisticsDTO.getOperateType().getValue());
            row.createCell(24).setCellValue(statisticsDTO.getRemark());
            row.createCell(25).setCellValue(statisticsDTO.getSendSampleDate());
            if (statisticsDTO.getOrderTempId() != null) {
                row.createCell(26).setCellValue(statisticsDTO.getOrderTempId());
            }
            if (statisticsDTO.getSettleAmount() != null) {
                row.createCell(27).setCellValue(statisticsDTO.getSettleAmount());
            }
            if (statisticsDTO.getSettleBatchNo() != null) {
                row.createCell(28).setCellValue(statisticsDTO.getSettleBatchNo());
            }
            if (statisticsDTO.getSettleStatusDesc() != null) {
                row.createCell(29).setCellValue(statisticsDTO.getSettleStatusDesc());
            }
        }
    }
}

参考文献

JAVA使用POI如何导出百万级别数据
JAVA笔记-如何将百万级数据高效的导出到Excel表单

忙里偷闲得几回
关注
  • 5
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
导出数据到Excel优化总结
黄爱岗廊坊师范学院信息技术提高班 第七期
10-15 2582
做系统优化两个多月了，优化了几个数据导出的功能，根据测试的结果来看，优化的效果还是很明显的，执行百秒以上的功能优化到了十秒之内，甚至有一个导出csv文件的给优化到了三秒内，所以一些优化经验还是可以借鉴的，下面我就针对我做优化的系统说一下我做的优化点，希望也能给和我一样的优化人员一些参考的价值。         要想解决问题首先得发现问题，第一步要做的就是熟悉整个功能的每个环节，可以用断点调试的方
EasyExcel大数据量导出
羸鹄的博客
02-05 6366
前言 本文使用的技术是Alibaba开源的EasyExcel技术，该技术是针对Apache POI技术的封装和优化，主要解决了POI技术的耗内存问题，并且提供了较好的API使用。不需要大量的代码就可以实现excel的操作功能。亲测可以导出100w条数据 demo源码如有需要接自行下载:https://download.csdn.net/download/weixin_39297312/15080971 代码demo pom依赖 <dependency&gt...
excel导出时数据量过大怎么办
星银色飞行船的博客
11-18 2767
遇到的问题 1. excel中的每个单元格最多能容纳3万多的字节 解决：单元格中超过30000字符的内容使用省略号代替。 2. excel中的行数最多只能容纳1048576行 在excel文档中 摁住ctrl+↓ 就能抵达最后一行 100万的数据量为一个sheet就行了。控制一下 ...
poi导出百万数据到excel
weixin_37586648的博客
12-15 416
poi框架在excel导入导出在java项目中经常会用到，但是之前用 HSSF和XSSF是POI导出都会有数据的瓶颈，大概在导出数据达到3万条以上时间上就很慢，再多的数据基本就无法导出。因此POI 3.8版本开始，提供了一种基于XSSF的低内存占用的API—-SXSSF 。测试导出100万数据组装以及生成excel大概要10分钟左右。效率还是非常高的。话不多少直接上代码。。。。 /** *
大数据最全EasyExcel导出大数据文件（100万条）_easyexcel导出百万数据(1)
最新发布
2401_84187635的博客
05-04 1173
首先准备100万条数据，为了方便，我用mybatis-plus循环100万次插入同一条数据数据，（这是数据库中的所有100万条数据。
C#百万数据导出Demo
10-07
C#导出百万数据到Excel，单Sheet 放置百万数据，使用需要安装office套件，本地测试环境office2016，可应用于 B/S C/S，如果使用B/S请参考附件 office配置 文档
大数据量导出Excel解决方案，以及一些问题
caopeihuaaini的博客
04-20 2140
它可以创建、读取、写入和编辑Excel文件（如XLSX、XLSM和XLTX），并提供了一组易于使用的API，使得处理Excel文件更加简单。3. OpenXML：直接操作底层XML结构，性能较好，但使用OpenXML SDK操作Excel文件的行和列可能显得更复杂。对于新手来说并不友好。但是，当数据量特别大，如几十万或上百万条时，我们就需要考虑如何解决服务器负载问题，以免导致程序崩溃。CSV文件本质上是纯文本文件，不能处理复杂的格式、样式、图表和其他高级Excel功能，仅支持文本和数值类型的数据。
一万条数据要导出EXCEL太慢了10分钟左右
netyou的专栏
06-23 4321
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; using ICSharpCode; using NPOI.XSSF.UserModel; using NPOI.HSSF.UserModel; using NPOI.SS.UserModel; using System.Data; using System.Reflection; using Syste
C#导出数据到Excel（百万级3秒）
10-31
C# datatable直接导出数据到Excel，（数据量百万级只需3秒）
C#大量数据导出到Excel自动分页导出
04-25
C#大量数据导出到Excel，超过65536行时自动分页导出
c++ builder (BCB) Oracle 导出 Excel 表
09-22
通过 odac 访问 oracle 数据库，并将制定的表导出到excel表，通过ole方式导出。
java导出大批量(百万以上)数据的excel文件
08-30
总结来说，Java导出大量数据到Excel文件时，需要关注内存管理、文件分片以及格式兼容性等问题。通过合理的设计和优化，即使面对百万级别的数据，也能确保导出过程高效且稳定。同时，理解并掌握相关API的使用，如...
Java使用POI导出大数据量Excel的方法
08-25
总结来说，Java使用POI的SXSSFWorkbook类可以有效地处理大数据量Excel导出，通过硬盘缓存减少内存使用。理解其工作原理并适当优化，能够在保持性能的同时，避免系统资源的过度消耗。在开发过程中，遇到此类问题时，...
Java 导出大批量数据excel（百万级）.pdf
04-07
目前java框架中能够生成excel文件的的确不少，但是，能够生成大数据量的excel框架，我倒是没发现，一般数据量大了都会出现内存溢出，所以，生成大数据量的excel文件要返璞归真，用java的基础技术,IO流来实现。...
js实现数据导出为EXCEL（支持大量数据导出）
10-15
总结来说，JavaScript实现数据导出为Excel涉及多种技术，包括DOM操作、CSV生成、Base64编码、以及跨浏览器的兼容性处理。对于大量数据，需要特别关注性能优化，如分块处理和服务器端处理，以提供更好的用户体验。
常见的场景优化方案：导出Excel大批量数据的优化过程
weixin_71690375的博客
05-30 2340
团队目前在做一个用户数据看板（下面简称看板），基本覆盖用户的所有行为数据，并生成分析报表，用户行为由多个数据来源组成（餐饮、生活日用、充值消费、交通出行、通讯物流、交通出行、医疗保健、住房物业、运动健康...），看看标红的代码，这个生成Excel的方式是对Excel中的每一个cell进行渲染，逐行的进行数据填充，效率太慢了，根据日志分析发现：基本时间都耗费在数据生成Excel上。目前遇到的主要问题是，随着行为能力逐渐的完善闭环，用户数据沉淀的也越来越多了，同时业务量的也在不断扩大。
EasyExcel导出大数据文件（100万条）
Shu0Shuo的博客
05-09 6670
啊啊啊，脑袋要炸了！！
如何实现百万级数据excel导出功能
ma_nong33的博客
02-05 1799
但它们都存在一个严重的问题就是：非常耗内存，POI有一套SAX模式的API可以一定程度的解决一些内存溢出的问题，但POI还是有一些缺陷，比如07版Excel解压缩以及解压后存储都是在内存中完成的，内存消耗依然很大。这样导出数据的功能，在第一个job周期内执行不完，在第二次job执行时，查询待处理状态，并不会查询出执行中状态的数据，也就是说不会重复执行。其实，在用户的操作界面，增加更多的查询条件，用户通过修改查询条件，多次导数据，可以实现将所有数据都导出的功能，这样可能更合理一些。
C#大量数据导出到Excel(转)
weixin_33728268的博客
08-29 308
工作过程中经常会用到将数据导出到Excel中，一般情况下需要导出的数据都是几百几千条或者上万条，这都没有什么问题，但有时候会遇到特殊的需求，客户要求把几十万条甚至上百万条的数据导出到Excel中，这就比较麻烦了。当数据量很大导出到Excel表格的时候通常会遇到两个问题：一个是内存溢出，由于需要处理的数据量比较大，导致Excel占用的内存过多从而导致数据还没有导出完就因为内存溢出而失败；另一个是每张...
c导出大批量数据到excel
06-11
你可以使用第三方库libxl来将数据导出到Excel文件中。以下是一个简单的例子： ```c #include <stdio.h> #include "libxl.h" int main() { // 创建一个Excel文件 BookHandle book = xlCreateBook(); if (!book) { printf("Failed to create Excel book.\n"); return 1; } // 添加一个新的工作表 SheetHandle sheet = xlBookAddSheet(book, "Sheet1", NULL); if (!sheet) { printf("Failed to add worksheet.\n"); xlBookRelease(book); return 1; } // 在工作表中写入数据 int numRows = 1000; // 假设有1000行数据 int numCols = 10; // 假设有10列数据 for (int row = 0; row < numRows; row++) { for (int col = 0; col < numCols; col++) { char value[16]; sprintf(value, "Data %d,%d", row, col); xlSheetWriteStr(sheet, row, col, value, NULL); } } // 保存Excel文件 if (xlBookSave(book, "data.xlsx")) { printf("Failed to save Excel file.\n"); } // 释放资源 xlBookRelease(book); return 0; } ``` 这个例子中，我们使用了libxl库来创建一个Excel文件，并向其中添加一个名为“Sheet1”的工作表。然后我们使用两个嵌套的循环来在工作表中写入数据。最后，我们调用xlBookSave函数将Excel文件保存到磁盘中。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值