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

已于 2023-12-27 17:03:11 修改
阅读量1.2k 收藏 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 动态表头 导出
11-20
【EasyExcel 动态表头 导出】是一种在Java编程环境下，利用阿里巴巴开源的EasyExcel库实现的高效、灵活的Excel数据导出功能。EasyExcel不仅提供了简单易用的API，而且支持动态表头，使得在导出Excel时可以根据业务...
Java核心技术 典型案例与面试实战系列二(Spring Boot)
12-15
光阴似箭、岁月如梭转眼间已至2020年末 想到这一年发生的糟心事不由得感慨万千、思绪横飞特别是互联网方面内卷依旧 竞争依旧激烈、就业环境依旧严酷因此巩固自身核心竞争力扎实自身技术根基 势在必行！！！ 故而，debug也趁此机会撸了一套新的实战课程：《Java核心技术-典型案例与面试实战系列二(基于Spring Boot2.0)》 顾名思义，这是debug为诸位规划的实战系列课程，其课程内容、学习收益、课程目录、技术栈等内容参见下图：  其课程的思维导图如下所示： 剩下的即为本课程相关技术在实战期间的效果图：      
EasyExcel导出excel设置单元格为文本格式解决方案【建议收藏】
最新发布
乐于分享，共同成长
06-17 829
EasyExcel导出excel设置单元格为文本格式解决方案【建议收藏】
基于EasyExcel多线程分页导出excel
qq_28452049的博客
05-31 8339
基于EasyExcel多线程分页导出excelMaven依赖线程池配置导出代码 第七更，基于EasyExcel 多线程分页导出excel 在项目中，BA要求全量导出表中数据，估计有十几万条，同事使用的是EasyPoi导致内存泄漏，我帮他优化，使用阿里的EasyExcel，解决了内存泄漏问题，但是导出17万数据仍需要84秒（本地测试），于是想到了多线程优化，最终测试时间为40秒，服务器上速度会更快，代码如下 Maven依赖 <dependencies> <dependen
多线程导出excel （千万级数据导出）
fp19930214的博客
10-28 1万+
多线程导出excel 公司项目需求，数据库有上千万条数据需要导出excel，使用EasyExcel导出，数据量不大时，没什么问题，但数据量超过上百网时，mysql出现连接超时，，虚拟机内存也会出现问题，后来考虑使用多线程分批导出多个excel，再把多个excel压缩成zip包发送到浏览器， 配置线程池 项目使用springboot框架，所以线程池也是用springboot配置 @Confi...
EasyExcel 设置单元格格式为 文本
Colourful.的博客
11-23 6176
1.通过WriteCellStyle 的dataFormat属性和BuiltinFormats指定字体格式 这种单元格有内容时字体才会生效，无内容时还是"常规"格式 private static WriteHandler templateWriteHandler; static { //表头样式 WriteCellStyle headWriteCellStyle = new WriteCellStyle(); //字体
使用easyExcel，多线程，导出excel
热门推荐
搬砖的鱼的博客
03-19 1万+
用easyExcel，多线程，生产者-消费者模式写入excel 阿里easyexcel 插件 easyexcel 项目git地址为: https://github.com/alibaba/easyexcel 官网地址：https://alibaba-easyexcel.github.io 写excel类 public class WriteExcel { public static voi...
easyexcel 动态导出复杂表头.zip
05-11
总结起来，EasyExcel的动态导出复杂表头功能为企业级的Excel操作提供了强大的支持，使开发者能够高效、灵活地处理数据导出需求。通过研究提供的代码示例，你可以进一步提升在Excel处理方面的能力。
多线程导出Excel(百万级别)_Java版优化.zip
09-10
用开源 Apache POI 技术导出Excel，解决导出大数据出现OOM、栈溢出问题，此资源可实现百万级数据多线程分批导出Excel文件，不会内存溢出，生产环境已很稳定的使用者，所以用到的技术很核心、值得参考
Java导出数据到Excel文件中（支持多表头）
08-17
在Excel中，多级表头允许我们在工作表的列上设置多个层次的标题，以更清晰地组织和展示数据。例如，一级表头通常代表数据的主要类别，如"学号"、"姓名"，而二级表头则表示细分的类别，如"语文"、"数学"、"英语"，...
easyexcel的导入和导出
qq_44813770的博客
05-08 555
easyexcel的导入和导出的实际运用
EasyExcel的导入导出使用
weimenglala的博客
01-18 9251
EasyExcel导入导出的使用
EasyExcel带格式多线程导出百万数据（实测好用）
Java精选
03-05 3243
前言以下为结合实际情况作的方案设计，导出阈值以及单sheet页条数都可以根据实际情况调整大佬可直接跳过新手教程，直接查看文末代码背景说明针对明细报表，用户会选择针对当前明细数据进行导出，便于本地或者线下进行处理或者计算等需求。不过一般在这种大数据量的导出任务下，会引发以下问题：响应时间较慢；内存资源占用过大，基本上一个大数据量的导出会消耗可视化服务的所有资源，引起内存回收，其它接口无响应；考虑到单...
使用easyexcel导出数据
shenxiaomo1688的博客
06-04 423
这里使用a标签并将target赋值为_blank这样可以在一个新的空标签页中进行导出，不影响原来的页面。
easy-excel批量导出数据
weixin_44699742的博客
11-20 1712
easy-excel高级使用
easyExcel导入导出
weixin_42653892的博客
01-21 8782
easyExcel 导出添加下拉框(已解决大数据下拉问题)，单元格合并，多sheet页导出等。导入通过注解解析字典值或校验唯一性，通过自定义的批量方法每500条插入一次
easyexcel 简单导出
cjy8866的博客
11-08 251
easyexcel 简单导出
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、付费专栏及课程。

余额充值