EasyExcel多线程批量导出数据，动态表头，静态资源访问

已于 2023-12-27 17:03:11 修改
阅读量1.1k 收藏 14
点赞数 9
文章标签： java easyexcel mysql
于 2023-12-27 15:04:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ai_haibin/article/details/135245524
版权

1.导入依赖

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>3.1.1</version>
        </dependency>

2.建立实体

@Data
public class ActResultLogVO implements Serializable {
    private static final long serialVersionUID = 1L;

    @ExcelProperty(value = "onlineseqid",index = 0)
    private String onlineseqid;

    @ExcelProperty(value = "businessid",index = 1)
    private String businessid;

    @ExcelProperty(value = "becifno",index = 2)
    private String becifno;

    @ExcelProperty(value = "ivisresult",index = 3)
    private String ivisresult;

    @ExcelProperty(value = "createdby",index = 4)
    private String createdby;

    @ExcelProperty(value = "createddate",index = 5)
    private LocalDate createddate;

    @ExcelProperty(value = "updateby",index = 6)
    private String updateby;

    @ExcelProperty(value = "updateddate",index = 7)
    private LocalDate updateddate;

    @ExcelProperty(value = "risklevel",index = 8)
    private String risklevel;
    /**
     * 分页开始数量
     */
    private Integer start;
    /**
     *  分页 size
     */
    private Integer size;
}

3.多线程异步导出

	@Async
	@Transactional
    public  void exportExcel(String filePath) {
    	//filePath 文件路径
        ExcelWriter writer = EasyExcel.write(filePath, ActResultLogVO.class).build();
        // 根据数据读写速度来调整，一般来说读的逻辑复杂，比较慢，如果读比写快，这里设为1
        int N = 2;
        // 大小设置为2就可以，作为缓冲
        BlockingQueue<List<ActResultLogVO>> queue = new ArrayBlockingQueue<>(2);
        AtomicInteger start = new AtomicInteger(0);
        AtomicInteger num = new AtomicInteger(0);
        AtomicInteger sheet = new AtomicInteger(1);
        // 分页大小可以适当调整
        int pageSize = 100000;
        //开启多个线程分页查数据
        for (int i = 0; i < N; i++) {
            executorService.submit(() -> {
                while (true) {
                    //自增
                    int startNum= start.getAndAdd(pageSize);
                    try {
                        long l = System.currentTimeMillis();
                        logger.info("[多线程，分页查询] 线程：{}，开始执行查询：startNum :{},时间：{}",Thread.currentThread().getName(),startNum,l);
                        List<ActResultLogVO> list = selectActResultLogVOPage(startNum, pageSize);
                        logger.info("[多线程，分页查询] 线程：{}，执行查询完成 startNum :{} 用时：{}",Thread.currentThread().getName(),startNum,System.currentTimeMillis()-l);
                        if (CollectionUtils.isEmpty(list)) {
                            //读到没数据也要放入空集合
                            queue.put(Collections.EMPTY_LIST);
                            break;
                        }
                        queue.put(list);
                    } catch (Exception e) {
                        //异常情况也要放入空集合，防止写线程无法退出循环
                        try {
                            queue.put(Collections.EMPTY_LIST);
                        } catch (InterruptedException ex) {
                            throw new RuntimeException(ex);
                        }
                        throw new RuntimeException(e);
                    }
                }
            });
        }
        Future<?> submit = executorService.submit(() -> {
            int count = 0;
            while (true) {
                List<ActResultLogVO> list = null;
                try {
                    list = queue.take();
                } catch (InterruptedException e) {
                    Thread.interrupted();
                }
                if (CollectionUtils.isEmpty(list)) {
                    count++;
                    // 当获取到两次空集合时，说明已经读完
                    if (count == N) {
                        break;
                    }
                    continue;
                }
                if(num.get()>=500000){
                    sheet.getAndAdd(1);
                    num.getAndSet(0);
                }
                num.getAndAdd(list.size());
                long l = System.currentTimeMillis();
                logger.info("[多线程，写入Excel] 线程：{}，开始执行写入：sheet :{},num:{}时间：{}",Thread.currentThread().getName(),sheet.get(),num.get(),l);
                writer.write(list, EasyExcel.writerSheet("Sheet"+sheet).build());
                logger.info("[多线程，写入Excel] 线程：{}，开始执行写入结束：sheet :{},num:{},时间：{}",Thread.currentThread().getName(),sheet.get(),num.get(),System.currentTimeMillis()-l);
            }
            writer.finish();
        });
        try {
            // 阻塞等待完成，异步处理也可以去掉这段代码
            submit.get();
        } catch (Exception e) {
        }
    }

4.动态表头

 	 @Autowired
    @Qualifier("excelThreadPool")
    private ExecutorService executorService;
 
 	@Async
    @Transactional
    public void exportExcel（String filePath,LinkedHashMap<String, DynamicExcelData> nameMap) {
        // 指定写入的文件
        ExcelWriter writer = EasyExcel.write(filePath).head(ExcelUtils.getHead(nameMap)).build();
        // 根据数据读写速度来调整，一般来说读的逻辑复杂，比较慢，如果读比写快，这里设为1
        int N = 2;
        // 大小设置为2就可以，作为缓冲
        BlockingQueue<List<Map<String,Object>>> queue = new ArrayBlockingQueue<>(2);
        AtomicInteger num = new AtomicInteger(0);
        AtomicInteger sheet = new AtomicInteger(1);
     
        // 分页大小可以适当调整
        int pageSize = ExcelConstants.SELECT_TO_DB_ROWS_MYBATIS;
        //开启多个线程分页查数据
        getData(lvnengAllCardBillVo,queue,pageSize);
        Future<?> submit = executorService.submit(() -> {
            int count = 0;
            while (true) {
                List<Map<String,Object>> list = null;
                try {
                    list = queue.take();
                } catch (InterruptedException e) {
                    Thread.interrupted();
                }
                if (CollectionUtils.isEmpty(list)) {
                    count++;
                    // 当获取到两次空集合时，说明已经读完
                    if (count == N) {
                        break;
                    }
                    continue;
                }
                if(num.get()>=600000){
                    sheet.getAndAdd(1);
                    num.getAndSet(0);
                }
                num.getAndAdd(list.size());
                List<List<String>> dataList = ExcelUtils.getDataList(nameMap, list);
                writer.write(dataList, EasyExcel.writerSheet("Sheet"+sheet).build());
            }
            writer.finish();
        });
        try {
            // 阻塞等待完成，异步处理也可以去掉这段代码
            submit.get();
        } catch (Exception e) {
        }
    }

public void getData(ActResultLogVO actResultLogVO,BlockingQueue<List<Map<String,Object>>> queue,int pageSize) {
        // 根据数据读写速度来调整，一般来说读的逻辑复杂，比较慢，如果读比写快，这里设为1
        int N = 2;
        AtomicInteger start = new AtomicInteger(0);
        for (int i = 0; i < N; i++) {
            executorService.submit(() -> {
                while (true) {
                    //自增
                    int startNum = start.getAndAdd(pageSize);
                    List<Map<String, Object>> list = new ArrayList<>();
                    try {
                        ActResultLogVO actResultLogVO1 = DeepCopyUtil.deepCopy(actResultLogVO);
                        actResultLogVO1.setStart(startNum);
                        List<Map<String, Object>> list = selectactResultLogVOPage(actResultLogVO1);
                        if (CollectionUtils.isEmpty(list)) {
                            //读到没数据也要放入空集合
                            queue.put(Collections.EMPTY_LIST);
                            break;
                        }
                        queue.put(list);

                    } catch (Exception e) {
                        //异常情况也要放入空集合，防止写线程无法退出循环
                        try {
                            queue.put(Collections.EMPTY_LIST);
                        } catch (InterruptedException ex) {
                            throw new RuntimeException(ex);
                        }
                        throw new RuntimeException(e);
                    }
                }
            });

        }
        logger.info("查询数据完成");
    }

@Configuration
public class ThreadPoolConfig {
    @Bean("excelThreadPool")
    public  ExecutorService buildExcelThreadPool() {
        int cpuNum = Runtime.getRuntime().availableProcessors();
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(1000);
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("excel-pool-%d").build();
        return new ThreadPoolExecutor(10 * cpuNum, 30 * cpuNum,
                1, TimeUnit.MINUTES, workQueue, threadFactory);
    }
}

public class ExcelConstants {
    public static final Integer PER_SHEET_ROW_COUNT = 100*10000;
    public static final Integer PER_WRITE_ROW_COUNT = 20*10000;
    public static final Integer SHEET_WRITE_ROW_COUNT = 50*10000;
    public static final Integer SELECT_TO_DB_ROWS = 10*10000;
    public static final Integer SELECT_TO_DB_ROWS_MYBATIS = 5*10000;
}

@Data
public class DynamicExcelData {
    //列名
    private String name;
    //默认值
    private String defaultValue;

    public DynamicExcelData(String name, String defaultValue) {
        this.name = name;
        this.defaultValue = defaultValue;
    }
}

5,用到的util

5.1 EasyUtils

public class ExcelUtils {

    public static void dynamicExportByURL(String filePath,
                                     LinkedHashMap<String, DynamicExcelData> nameMap,
                                     List<Map<String, Object>> list,
                                     String sheetName) throws IOException {
        //首先判断是否有数据，没有就返回
        if(CollUtil.isEmpty(list)){
            return;
        }
        //这里的map使用LinkedHashMap，实现字段的顺序功能
        if(nameMap==null){
            throw new RuntimeException("请填写好映射表数据");
        }
        File file = getFile(filePath);
        dynamicExportByURL(file,nameMap,list,sheetName);
    }

    public static void dynamicExport(HttpServletResponse response,
                                     LinkedHashMap<String, DynamicExcelData> nameMap,
                                     List<Map<String, Object>> list,
                                     String sheetName) throws IOException {
        //首先判断是否有数据，没有就返回
        if(CollUtil.isEmpty(list)){
            return;
        }
        //这里的map使用LinkedHashMap，实现字段的顺序功能
        if(nameMap==null){
            throw new RuntimeException("请填写好映射表数据");
        }
        response.setHeader("Access-Control-Expose-Headers", "Content-Disposition");
        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        response.setCharacterEncoding("utf-8");
        //使用EasyExcel write进行写出
        EasyExcel.write(response.getOutputStream()).head(getHead(nameMap)).sheet(sheetName).doWrite(getDataList(nameMap,list));
    }


    public static ArrayList<List<String>> getHead(LinkedHashMap<String, DynamicExcelData> nameMap) {
        //获取表头
        ArrayList<List<String>> head = new ArrayList<>();
        for (Map.Entry<String, DynamicExcelData> titleMap : nameMap.entrySet()) {
            DynamicExcelData data = titleMap.getValue();
            head.add(Collections.singletonList(data.getName()));
        }
        return head;
    }

    public static List<List<String>> getDataList(LinkedHashMap<String, DynamicExcelData> nameMap, List<Map<String, Object>> list) {
        //先初始化一下传入
        int size = list.size();
        List<List<String>> dataList = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            dataList.add(new ArrayList<>());
        }
        //数据重组
        for (int i = 0; i < list.size(); i++) {
            Map<String, Object> map = list.get(i);
            List<String> columns = dataList.get(i);
            for (Map.Entry<String, DynamicExcelData> sortNameEntry : nameMap.entrySet()) {
                String key = sortNameEntry.getKey();
                Object value = map.get(key);
                columns.add(value != null ? String.valueOf(value) : sortNameEntry.getValue().getDefaultValue());
            }
        }
        return dataList;
    }

    public static File getFile(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.createNewFile();
        }
        return file;
    }



    public static void dynamicExportByURL(File file,LinkedHashMap<String, DynamicExcelData> nameMap,  List date,String sheetName) {

        long startTime = 0;
        ExcelWriter excelWriter = null;
        try {
            startTime = System.currentTimeMillis();
            // 获取 sheet 的个数
            int sheetNum = getSheetNum(date.size());
            // 获取每个sheet 写入的次数
            int writeNumPerSheet = getWriteNumPerSheet();
            // 最后一个 sheet 写入的数量
            int writeNumLastSheet = date.size() - (sheetNum - 1) * ExcelConstants.PER_SHEET_ROW_COUNT;
            // 最后一个 sheet 写入的次数
            int writeNumPerLastSheet = writeNumLastSheet % ExcelConstants.PER_WRITE_ROW_COUNT == 0 ? writeNumLastSheet / ExcelConstants.PER_WRITE_ROW_COUNT : writeNumLastSheet / ExcelConstants.PER_WRITE_ROW_COUNT + 1;
            // 指定写入的文件
            excelWriter = EasyExcel.write(file).head(getHead(nameMap)).build();
         
            for (int i = 0; i < sheetNum; i++) {
                String sheet = sheetName + i;
                WriteSheet writeSheet = EasyExcel.writerSheet(i, sheet).build();
                int writeNum = i == sheetNum - 1 ? writeNumPerLastSheet : writeNumPerSheet; // 每个sheet 写入的次数
                int endEndNum = i == sheetNum - 1 ? date.size() : (i + 1) * ExcelConstants.PER_SHEET_ROW_COUNT; // 每个sheet 最后一次写入的最后行数
                for (int j = 0; j < writeNum; j++) {
                    long l = System.currentTimeMillis();
                    int startNum = i * ExcelConstants.PER_SHEET_ROW_COUNT + j * ExcelConstants.PER_WRITE_ROW_COUNT;
                    int endNum = j == writeNum - 1 ? endEndNum : i * ExcelConstants.PER_SHEET_ROW_COUNT + (j + 1) * ExcelConstants.PER_WRITE_ROW_COUNT;
                    excelWriter.write(getDataList(nameMap,date.subList(startNum, endNum)), writeSheet);

                }
            }
        } catch (Exception e) {
     
        } finally {
            // 需要放入 finally 中
            if (excelWriter != null) {
                excelWriter.finish();
            }
        }
    }

    public static void writeExcel(String filePath, Class clazz, List date,String sheetName) throws Exception{
        File file = getFile(filePath);
        long startTime = System.currentTimeMillis();
        // 获取 sheet 的个数
        int sheetNum = getSheetNum(date.size());
        // 获取每个sheet 写入的次数
        int writeNumPerSheet = getWriteNumPerSheet();
        // 最后一个 sheet 写入的数量
        int writeNumLastSheet = date.size() - (sheetNum - 1) * ExcelConstants.PER_SHEET_ROW_COUNT;
        // 最后一个 sheet 写入的次数
        int writeNumPerLastSheet = writeNumLastSheet % ExcelConstants.PER_WRITE_ROW_COUNT == 0 ? writeNumLastSheet / ExcelConstants.PER_WRITE_ROW_COUNT : writeNumLastSheet / ExcelConstants.PER_WRITE_ROW_COUNT + 1;
        // 指定写入的文件
        ExcelWriter excelWriter = EasyExcel.write(file, clazz).build();

        for (int i = 0; i < sheetNum; i++) {
            String sheet = sheetName + i;
            WriteSheet writeSheet = EasyExcel.writerSheet(i, sheet).build();
            int writeNum = i == sheetNum - 1 ? writeNumPerLastSheet : writeNumPerSheet; // 每个sheet 写入的次数
            int endEndNum = i == sheetNum - 1 ? date.size() : (i + 1) * ExcelConstants.PER_SHEET_ROW_COUNT; // 每个sheet 最后一次写入的最后行数
            for (int j = 0; j < writeNum; j++) {
                long l = System.currentTimeMillis();
                int startNum = i * ExcelConstants.PER_SHEET_ROW_COUNT + j * ExcelConstants.PER_WRITE_ROW_COUNT;
                int endNum = j == writeNum - 1 ? endEndNum : i * ExcelConstants.PER_SHEET_ROW_COUNT + (j + 1) * ExcelConstants.PER_WRITE_ROW_COUNT;
                excelWriter.write(date.subList(startNum, endNum), writeSheet);
            }
        }
        // 需要放入 finally 中
        if (excelWriter != null) {
            excelWriter.finish();
        }
    }

    public static int getSheetNum(int dateSize){
        return dateSize % ExcelConstants.PER_SHEET_ROW_COUNT == 0 ? (dateSize / ExcelConstants.PER_SHEET_ROW_COUNT) : (dateSize / ExcelConstants.PER_SHEET_ROW_COUNT + 1);
    }

    public static int getWriteNumPerSheet(){
        return ExcelConstants.PER_SHEET_ROW_COUNT % ExcelConstants.PER_WRITE_ROW_COUNT == 0 ? (ExcelConstants.PER_SHEET_ROW_COUNT / ExcelConstants.PER_WRITE_ROW_COUNT) : (ExcelConstants.PER_SHEET_ROW_COUNT / ExcelConstants.PER_WRITE_ROW_COUNT + 1);
    }

    public static  List<String> objectToList(Object obj){
        ArrayList<String> list = new ArrayList<>();
        //获取obj类中的所有字段
        Field[] fields = obj.getClass().getDeclaredFields();
        //遍历所有属性
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                list.add(field.get(obj).toString());
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
        return list;
    }


    public static Map<String,Object> objectToMap(Object obj){
        HashMap<String, Object> map = new HashMap<>();
        //获取obj类中的所有字段
        Field[] fields = obj.getClass().getDeclaredFields();
        //遍历所有属性
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                map.put(field.getName(),field.get(obj));
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }
        return map;
    }


    /**
     * 通过反射方式将头部作为公共部分进行设置
     */
    public static List<List<String>> setTitles(Class clazz) {
        List<List<String>> titles = new ArrayList<List<String>>();
        for (Field declaredField : clazz.getDeclaredFields()) {
            ExcelProperty annotation = declaredField.getAnnotation(ExcelProperty.class);
            if (null != annotation) {
                titles.add(Arrays.asList(annotation.value()));
            }
        }
        return titles;
    }
}

5.2 深拷贝

public class DeepCopyUtil {

    public static <T extends Serializable> T deepCopy(T object) {
        try {
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            objectOutputStream.writeObject(object);
            ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
            return (T) objectInputStream.readObject();
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

配置静态资源访问

@Configuration
public class MyStaticConfig extends WebMvcConfigurationSupport {


    @Value("${download.url}")
    private String fileDir;
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/uploads/**").addResourceLocations("classpath:/META-INF/resources/", "classpath:/resources/",
                "classpath:/static/", "classpath:/public/","file:"+fileDir);
    }
}
听者listener
关注
  • 9
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
easyExcel实现大数据导出
11-13
阿里巴巴easyExcel实现大数据导出！！
easyexcel 动态导出复杂表头.zip
05-11
总结起来，EasyExcel的动态导出复杂表头功能为企业级的Excel操作提供了强大的支持，使开发者能够高效、灵活地处理数据导出需求。通过研究提供的代码示例，你可以进一步提升在Excel处理方面的能力。
easyExcel的多线程导出
java程序员的蜕变之路
10-11 846
easyExcel的多线程导入导出。
EasyExcel导出Excel设置单元格文本格式(亲测有效)
最新发布
weixin_45131680的博客
05-23 508
下面是一开始的代码, 是不生效的, 查了好多都是这么设置的, 我也是这么写的但是就是不生效, 然后查了资料好多也说是注册写处理器必须是一个, 不能是多个, 因为我的是注册两个写处理器, 然后我就去掉了一个处理, 但是TMD还是不生效, 后来查了资料, 试了好几次, 终于可以生效了, 下面的写法应该是2.0版本的写法, 因为我的是3.0+, 没有验证这个2.0+是否生效, 就不多说了.: 看下面代码吧, 重写下面任意两个其中的一个方法就可以了, 写入注册几个写处理器都是可以的, 然后就可以导出试一下了.
Java核心技术 典型案例与面试实战系列二(Spring Boot)
12-15
光阴似箭、岁月如梭转眼间已至2020年末 想到这一年发生的糟心事不由得感慨万千、思绪横飞特别是互联网方面内卷依旧 竞争依旧激烈、就业环境依旧严酷因此巩固自身核心竞争力扎实自身技术根基 势在必行！！！ 故而，debug也趁此机会撸了一套新的实战课程：《Java核心技术-典型案例与面试实战系列二(基于Spring Boot2.0)》 顾名思义，这是debug为诸位规划的实战系列课程，其课程内容、学习收益、课程目录、技术栈等内容参见下图：  其课程的思维导图如下所示： 剩下的即为本课程相关技术在实战期间的效果图：      
如何用easyExcel的实现导出以及实现多线程分页数据导出
inteo的博客
06-13 6914
实际的导出效率取决于具体的硬件环境和数据源的复杂度。对于每个线程，我们从指定的数据读取器中读取指定页码的数据，然后写入到指定的数据写入器中，直到读取到的数据为空或空集合为止。需要注意的是，每个线程的页码应该从不同的起始位置开始，以保证每个线程读取的数据不重复，也不遗漏。需要注意的是，在进行大数据量导出时，为了避免内存溢出，可以考虑使用分页查询或按批次查询的方式读取数据，并在写入Excel文件时采用流式写入或多线程写入的方式，这样可以提高导出效率，并避免内存溢出的问题。1.先看一下普通写法。
easyexcel大数据多线程读取后导出
weixin_46591962的博客
03-04 2783
excel数据导出
Java EasyExcel带格式多线程导出百万数据
入门程序猿的博客
09-19 8375
Java结合Alibaba EasyExcel，通过多线程加redis缓存的方式，将明细表数据带有数据格式（字体格式，表头冻结，单元格合并等格式），导出百万数据量，响应时间30s左右。
【SpirngBoot】EasyExcel 多线程 + 分批次查询数据，逐步导出，降低内存占用，通用模板适用于所有的导出
hs598375774的博客
05-25 4765
以上思路即是针对数据量较大情况下处理方式，如有文件服务器可采用异步+多线程方式生成文件上传到文件服务器，用户点击下载弹出下载页面，用户下载文件服务中附件，此文件可重复下载，减轻相同的再次生成文件执行业务代码等流程。将查询到的数据使用 EasyExcel 进行导出，导出时可以采用异步导出的方式，这样可以避免导出数据量过大导致的内存溢出问题。需要注意的是，在使用 inMemory 方式导出数据时，需要注意内存溢出的问题。在 Controller 层中，定义一个导出接口，接口中传入需要导出的数据的查询条件。
多线程导出Excel(百万级别)_Java版优化.zip
09-10
用开源 Apache POI 技术导出Excel，解决导出大数据出现OOM、栈溢出问题，此资源可实现百万级数据多线程分批导出Excel文件，不会内存溢出，生产环境已很稳定的使用者，所以用到的技术很核心、值得参考
Java导出数据到Excel文件中（支持多表头）
08-17
在Excel中，多级表头允许我们在工作表的列上设置多个层次的标题，以更清晰地组织和展示数据。例如，一级表头通常代表数据的主要类别，如"学号"、"姓名"，而二级表头则表示细分的类别，如"语文"、"数学"、"英语"，...
EasyExcel 带格式多线程导出百万数据（亲测牛逼）
竹林幽深
03-20 1887
以下为结合实际情况作的方案设计，导出阈值以及单sheet页条数都可以根据实际情况调整大佬可直接跳过新手教程，直接查看文末代码（1）大数据量导出问题主要是以下三个地方：资源占用内存（也是资源的一个，单独说明）响应时间针对以上三个问题，大方向考虑的是多线程结合数据流写入的方式。多线程：使用空间换时间，主要是加快接口响应时间，但是这里线程数不宜过多，一味加快响应时间提升线程数，资源占用会非常严重，故会考虑线程池，线程池的线程数为10；
spring boot+easyExcel+多线程导出excel文件
丨灬坏蛋er丨的博客
09-22 779
数据导出，提升速度
java-EasyExcel导出excel设置单元格为文本格式（含代码）
热门推荐
gorylee的博客
03-24 1万+
java-EasyExcel导出excel设置单元格为文本格式（含代码）
EasyExcel 批量导出
Mr_Wanter
06-15 3459
上篇写了数据导入，本文补充一下EasyExcel 批量导出包括常规excel和复杂excel
使用EasyExcel导出数据
Leopard锋的博客
12-16 3372
*** 导出Excel流*/// 设置响应头// 获取输出流//创建自定义的表头（可自行判断增减 列）head.add(CollectionUtil.newArrayList("标题1", "标题1"));//0head.add(CollectionUtil.newArrayList("标题2", "标题2"));//1head.add(CollectionUtil.newArrayList("标题3", "标题3"));//2。
easyexcel多线程异步导出
04-09
EasyExcel是一个Java的Excel操作工具，可以方便地进行Excel的读写操作。在EasyExcel中，多线程异步导出是一种将大量数据导出到Excel时的一种优化方式，可以提高导出速度和系统的并发能力。 在EasyExcel中，多线程异步导出可以通过以下步骤实现： 1. 创建一个实现了`AnalysisEventListener`接口的监听器类，用于处理Excel数据的读取。在监听器中，可以定义对读取到的数据进行处理的逻辑。 2. 使用`EasyExcel.read()`方法读取Excel文件，并将监听器对象传入。 3. 在监听器中，通过重写`invoke()`方法来处理每一行读取到的数据。可以将数据存储到数据库、进行业务逻辑处理等。 4. 在需要导出的地方，创建一个实现了`WriteHandler`接口的处理器类，用于处理Excel数据的写入。在处理器中，可以定义对写入数据进行处理的逻辑。 5. 使用`EasyExcel.write()`方法创建一个`ExcelWriter`对象，并将处理器对象传入。 6. 在需要导出的地方，通过调用`ExcelWriter.write()`方法将数据写入到Excel中。 7. 调用`ExcelWriter.finish()`方法完成写入操作，并关闭资源。 通过以上步骤，就可以实现EasyExcel的多线程异步导出功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值