EasyExcel实现100w数据导入导出

于 2024-08-09 16:43:56 发布
阅读量552 收藏 7
点赞数 4
分类专栏： Java Spring系列 文章标签： spring boot easyexcel
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46689011/article/details/141063679
版权

EasyExcel实现100w数据导入导出

他山之石，可以攻玉

参考文章链接：百万数据的导入导出解决方案

个人功能实现github代码地址：batchExcelData-import-export

前置准备

Java17 SpringBoot3

100w数据生成SQL

CREATE TABLE `student_info` (
	`id` INT ( 11 ) NOT NULL AUTO_INCREMENT,
	`student_id` INT NOT NULL,
	`name` VARCHAR ( 20 ) DEFAULT NULL,
	`course_id` INT NOT NULL,
	`class_id` INT ( 11 ) DEFAULT NULL,
	`create_time` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
	PRIMARY KEY ( `id` ) 
) ENGINE = INNODB AUTO_INCREMENT = 1 DEFAULT CHARSET = utf8;
CREATE TABLE `course` (
	`id` INT ( 11 ) NOT NULL AUTO_INCREMENT,
	`course_id` INT NOT NULL,
	`course_name` VARCHAR ( 40 ) DEFAULT NULL,
	PRIMARY KEY ( `id` ) 
) ENGINE = INNODB AUTO_INCREMENT = 1 DEFAULT CHARSET = utf8;

DELIMITER //
CREATE FUNCTION rand_string ( n INT ) RETURNS VARCHAR (255) #该函数会返回一个字符串
BEGIN
	DECLARE
		chars_str VARCHAR ( 100 ) DEFAULT 'abcdefghijklmnopqrstuvwxyzABCDEFJHIJKLMNOPQRSTUVWXYZ';
	DECLARE
		return_str VARCHAR ( 255 ) DEFAULT '';
	DECLARE
		i INT DEFAULT 0;
	WHILE i < n DO
			SET return_str = CONCAT(return_str,SUBSTRING( chars_str, FLOOR(1+RAND()* 52), 1 ));
			SET i = i + 1;
		END WHILE;
	RETURN return_str;
END // 
DELIMITER;


#函数2：创建随机数函数
DELIMITER //
CREATE FUNCTION rand_num (from_num INT ,to_num INT) RETURNS INT(11)
BEGIN
DECLARE i INT DEFAULT 0;
SET i = FLOOR(from_num +RAND()*(to_num - from_num+1)) ;
RETURN i;
END //
DELIMITER ;

show variables like 'log_bin_trust_function_creators';

set global log_bin_trust_function_creators=1;




# 存储过程1：创建插入课程表存储过程
DELIMITER //
CREATE PROCEDURE insert_course( max_num INT )
BEGIN
DECLARE i INT DEFAULT 0;
SET autocommit = 0; #设置手动提交事务
REPEAT #循环
SET i = i + 1; #赋值
INSERT INTO course (course_id, course_name ) VALUES
(rand_num(10000,10100),rand_string(6));
UNTIL i = max_num END REPEAT;
COMMIT; #提交事务
END //
DELIMITER ;

# 存储过程2：创建插入学生信息表存储过程
DELIMITER //
CREATE PROCEDURE insert_stu( max_num INT )
BEGIN
DECLARE i INT DEFAULT 0;
SET autocommit = 0; #设置手动提交事务
REPEAT #循环
SET i = i + 1; #赋值
INSERT INTO student_info (course_id, class_id ,student_id ,NAME ) VALUES
(rand_num(10000,10100),rand_num(10000,10200),rand_num(1,200000),rand_string(6));
UNTIL i = max_num
END REPEAT;
COMMIT; #提交事务
END //
DELIMITER ;


CALL insert_course(100); -- 0.038
CALL insert_stu(1000000); -- 341.03s

pom

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
            <version>3.5.7</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>2.0.47</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>3.1.0</version>
        </dependency>
<!--        <dependency>-->
<!--            <groupId>org.mybatis.spring.boot</groupId>-->
<!--            <artifactId>mybatis-spring-boot-starter</artifactId>-->
<!--            <version>3.0.0</version>-->
<!--        </dependency>-->


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mysql_study_db?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
    username: root
    password: root123
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 初始连接数
      initialSize: 5
      # 最小连接池数量
      minIdle: 10
      # 最大连接池数量
      maxActive: 20
      # 配置获取连接等待超时的时间
      maxWait: 60000
      # 配置连接超时时间
      connectTimeout: 30000
      # 配置网络超时时间
      socketTimeout: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 300000
      # 配置一个连接在池中最大生存的时间，单位是毫秒
      maxEvictableIdleTimeMillis: 900000
      # 配置检测连接是否有效
      validationQuery: SELECT 1 FROM DUAL
  # 增加上传文件的大小限制
  servlet:
    multipart:
      max-file-size: 50MB
      max-request-size: 50MB

mybatis-plus:
  configuration:
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 配置MyBatis日志
    mapper-locations: classpath:mapper/*.xml
server:
  port: 7777

导出：

思路：不能写到一个Sheet就写多个，不能一次性读取100w就分批次读取，不能一行行写Excel就达到一定数量就写

写100w数据到excel中 导出所用时间:41秒
写10个sheet 每个10w 每次写2w

业务代码

  @GetMapping("/export")
    public String exportExcel(HttpServletResponse response) {
        {
            OutputStream outputStream = null;
            try {
                long startTime = System.currentTimeMillis();
                System.out.println("导出开始时间:" + startTime);

                outputStream = response.getOutputStream();
                String fileName = new String(("excel100w.xlsx").getBytes(), "UTF-8");
                // 创建ExcelWriter
//                ExcelWriter excelWriter = EasyExcel.write(fileName, StudentInfo.class).build();//本地文件
                ExcelWriter excelWriter = EasyExcel.write(outputStream, StudentInfo.class).build();//浏览器
                //模拟统计查询的数据数量这里模拟100w
                //记录总数:实际中需要根据查询条件进行统计即可
                Integer totalCount = Math.toIntExact(service.findCount());
                //每一个Sheet存放10w条数据
//                Integer sheetDataRows = ExcelConstants.PER_SHEET_ROW_COUNT;
                Integer sheetDataRows = 100000;
                //每次写入的数据量2w
//                Integer writeDataRows = ExcelConstants.PER_WRITE_ROW_COUNT;
                Integer writeDataRows = 20000;
                //计算需要的Sheet数量
                Integer sheetNum = totalCount % sheetDataRows == 0 ? (totalCount / sheetDataRows) : (totalCount / sheetDataRows + 1);
                //计算一般情况下每一个Sheet需要写入的次数(一般情况不包含最后一个sheet,因为最后一个sheet不确定会写入多少条数据)
                Integer oneSheetWriteCount = sheetDataRows / writeDataRows;
                //计算最后一个sheet需要写入的次数
                Integer lastSheetWriteCount = totalCount % sheetDataRows == 0 ? oneSheetWriteCount : (totalCount % sheetDataRows % writeDataRows == 0 ? (totalCount / sheetDataRows / writeDataRows) : (totalCount / sheetDataRows / writeDataRows + 1));

                //开始分批查询分次写入
                //注意这次的循环就需要进行嵌套循环了,外层循环是Sheet数目,内层循环是写入次数
                for (int sheetIndex = 0; sheetIndex < sheetNum; sheetIndex++) {
                    long s1 = System.currentTimeMillis();
                    log.info("sheet:{} start", sheetIndex + 1);
                    // 创建新的 sheet
                    WriteSheet writeSheet = EasyExcel.writerSheet("Sheet" + (sheetIndex + 1)).build();


                    //循环写入次数: j的自增条件是当不是最后一个Sheet的时候写入次数为正常的每个Sheet写入的次数,如果是最后一个就需要使用计算的次数lastSheetWriteCount
                    for (int j = 0; j < (sheetIndex != sheetNum - 1 ? oneSheetWriteCount : lastSheetWriteCount); j++) {
                        //分页查询一次2w
                        List<StudentInfo> stuList = service.findByPage(j + 1 + oneSheetWriteCount * sheetIndex, writeDataRows);
                        if (!CollectionUtils.isEmpty(stuList)) {
                            //写数据
                            excelWriter.write(stuList, writeSheet);
                        }

                    }
                    long s2 = System.currentTimeMillis();
                    log.info("sheet:{} end {} ms", sheetIndex + 1, s2 - s1);
                }

                // 下载EXCEL
                response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
                response.setCharacterEncoding("utf-8");
                response.setHeader("Content-Disposition", "attachment;filename=" + fileName);
                excelWriter.finish();
                outputStream.flush();
                //导出时间结束
                long endTime = System.currentTimeMillis();
                System.out.println("导出结束时间:" + endTime + "ms");
                System.out.println("导出所用时间:" + (endTime - startTime) / 1000 + "秒");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (outputStream != null) {
                    try {
                        outputStream.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        return "success";
    }

结果

导出开始时间:1723191448429
2024-08-09T16:17:28.744+08:00  INFO 18552 --- [nio-7777-exec-1] com.alibaba.druid.pool.DruidDataSource   : {dataSource-1} inited
2024-08-09T16:17:29.114+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:1 start
2024-08-09T16:17:32.155+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:1 end 3041 ms
2024-08-09T16:17:32.155+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:2 start
2024-08-09T16:17:34.787+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:2 end 2632 ms
2024-08-09T16:17:34.787+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:3 start
2024-08-09T16:17:37.695+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:3 end 2908 ms
2024-08-09T16:17:37.695+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:4 start
2024-08-09T16:17:40.722+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:4 end 3027 ms
2024-08-09T16:17:40.722+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:5 start
2024-08-09T16:17:44.782+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:5 end 4060 ms
2024-08-09T16:17:44.782+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:6 start
2024-08-09T16:17:50.179+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:6 end 5397 ms
2024-08-09T16:17:50.179+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:7 start
2024-08-09T16:17:56.353+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:7 end 6174 ms
2024-08-09T16:17:56.354+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:8 start
2024-08-09T16:18:02.744+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:8 end 6391 ms
2024-08-09T16:18:02.744+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:9 start
2024-08-09T16:18:09.716+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:9 end 6972 ms
2024-08-09T16:18:09.716+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:10 start
2024-08-09T16:18:16.214+08:00  INFO 18552 --- [nio-7777-exec-1] c.c.controller.StudentInfoController     : sheet:10 end 6498 ms
导出结束时间:1723191507222ms
导出所用时间:58秒

ps：使用分页查询的时候要注意引入MyBatisPlus的分页插件

导入：

思路：分批读取+JDBC分批插入+手动事务控制
ps:JDBC连接MySQL时，如果要使用批处理功能，需要在url 中加入参数?rewriteBatchedStatements=true

业务代码

    /**
     * the request was rejected because its size (45665808) exceeds the configured maximum (10485760)
     * <p>
     * spring.servlet.multipart.max-file-size=50MB
     * spring.servlet.multipart.max-request-size=50MB
     *
     *
     *    ΔJDBC连接MySQL时，如果要使用批处理功能，需要在url 中加入参数?rewriteBatchedStatements=true
     * 1 没加 ------总耗时:159188ms------
     * 2 加了 43533ms
     *
     *  3.65倍
     *
     * @param file
     * @return
     */
    @PostMapping("/import")
    public String importExcel(@RequestParam("file") MultipartFile file) {
        //记录开始读取Excel时间,也是导入程序开始时间
        long startReadTime = System.currentTimeMillis();
        System.out.println("------开始读取Excel的Sheet时间(包括导入数据过程):" + startReadTime + "ms------");
        //读取所有Sheet的数据.每次读完一个Sheet就会调用这个方法
        try {
            EasyExcel.read(file.getInputStream(), StudentInfo.class, new EasyExceGeneralDatalListener(service)).doReadAll();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        long endReadTime = System.currentTimeMillis();
        System.out.println("------结束读取Excel的Sheet时间(包括导入数据过程):" + endReadTime + "ms------");

        System.out.println("------总耗时:" + (endReadTime-startReadTime) + "ms------");
        return "success";
    }

EasyExcel监听器

package com.coding.entity.listener;

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.coding.entity.StudentInfo;
import com.coding.service.StudentInfoService;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;



// 事件监听
public class EasyExceGeneralDatalListener extends AnalysisEventListener<StudentInfo> {
    /**
     * 处理业务逻辑的Service,也可以是Mapper
     */
    private StudentInfoService service;

    /**
     * 用于存储读取的数据
     */
    private List<StudentInfo> dataList = new ArrayList<StudentInfo>();

    public EasyExceGeneralDatalListener() {
    }

    public EasyExceGeneralDatalListener(StudentInfoService service) {
        this.service = service;
    }

    /**
     * easyexcel invoke 报错 class java.util.LinkedHashMap cannot be cast to class com.coding.entity.StudentInfo (java.util.LinkedHashMap is in module java.base of loader 'bootstrap'; com.coding.entity.StudentInfo is in unnamed module of loader 'app')

      EasyExcel.read(fileName, StudentInfo.class, listener).sheet().doRead();
     */
    @Override
    public void invoke(StudentInfo data, AnalysisContext context) {
        //数据add进入集合
        dataList.add(data);
        //size是否为100000条:这里其实就是分批.当数据等于10w的时候执行一次插入
        if (dataList.size() >= 100000) {
            //存入数据库:数据小于1w条使用Mybatis的批量插入即可;
            saveData();
            //清理集合便于GC回收
            dataList.clear();
        }
    }

    /**
     * 保存数据到DB
     *
     * @param
     * @MethodName: saveData
     * @return: void
     */
    private void saveData() {
        service.import2DBFromExcel10w(dataList);
        dataList.clear();
    }

    /**
     * Excel中所有数据解析完毕会调用此方法
     *
     * @param: context
     * @MethodName: doAfterAllAnalysed
     * @return: void
     */
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        saveData();
        dataList.clear();
    }
}

JDBC批处理 事务

   @Override
    public void import2DBFromExcel10w(List<StudentInfo> dataList) {
        //结果集中数据为0时,结束方法.进行下一次调用
        if (dataList.size() == 0) {
            return ;
        }
        //JDBC分批插入+事务操作完成对10w数据的插入
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            long startTime = System.currentTimeMillis();
            System.out.println(dataList.size() + "条,开始导入到数据库时间:" + startTime + "ms");
            conn = JDBCDruidUtils.getConnection();
            //控制事务:默认不提交
            conn.setAutoCommit(false);
            String sql = "insert into student_info (student_id,name,course_id,class_id,create_time) values(?,?,?,?,?)";
            ps = conn.prepareStatement(sql);
            //循环结果集:这里循环不支持"烂布袋"表达式
            for (int i = 0; i < dataList.size(); i++) {
                StudentInfo item = dataList.get(i);
                ps.setInt(1, item.getStudentId());
                ps.setString(2, item.getName());
                ps.setInt(3, item.getCourseId());
                ps.setInt(4, item.getClassId());
                ps.setDate(5, new Date(System.currentTimeMillis()));

                //将一组参数添加到此 PreparedStatement 对象的批处理命令中。
                ps.addBatch();
            }
            //执行批处理
            ps.executeBatch();
            //手动提交事务
            conn.commit();
            long endTime = System.currentTimeMillis();
            System.out.println(dataList.size() + "条,结束导入到数据库时间:" + endTime + "ms");
            System.out.println(dataList.size() + "条,导入用时:" + (endTime - startTime) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关连接
            JDBCDruidUtils.close(conn, ps);
        }


    }

JDBCDruidUtils

package com.coding.util;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @description <JDBC工具类>
 * @author: zhouchaoyu
 * @Date: 2024-08-08
 */
//JDBC工具类
public class JDBCDruidUtils {
    private static DataSource dataSource;

    /*
   创建数据Properties集合对象加载加载配置文件
    */
    static {
        Properties pro = new Properties();
        //加载数据库连接池对象
        try {
            //获取数据库连接池对象
            pro.load(JDBCDruidUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
//            pro.forEach((key, value) -> System.out.println(key + ": " + value));
            dataSource = DruidDataSourceFactory.createDataSource(pro);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /*
    获取连接
     */
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }


    /**
     * 关闭conn,和 statement独对象资源
     *
     * @param connection
     * @param statement
     * @MethodName: close
     * @return: void
     */
    public static void close(Connection connection, Statement statement) {
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 关闭 conn , statement 和resultset三个对象资源
     *
     * @param connection
     * @param statement
     * @param resultSet
     * @MethodName: close
     * @return: void
     */
    public static void close(Connection connection, Statement statement, ResultSet resultSet) {
        close(connection, statement);
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /*
    获取连接池对象
     */
    public static DataSource getDataSource() {
        return dataSource;
    }

}

druid.properties

# Database connection settings
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mysql_study_db?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true&rewriteBatchedStatements=true
username=root
password=root123

# Druid connection pool settings
initialSize=5
minIdle=5
maxActive=20
maxWait=60000
timeBetweenEvictionRunsMillis=60000
minEvictableIdleTimeMillis=300000
validationQuery=SELECT 1
testWhileIdle=true
testOnBorrow=false
testOnReturn=false
poolPreparedStatements=true
maxPoolPreparedStatementPerConnectionSize=20

结果

------开始读取Excel的Sheet时间(包括导入数据过程):1723192568422ms------
100000条,开始导入到数据库时间:1723192572571ms
2024-08-09T16:36:12.611+08:00  INFO 18552 --- [nio-7777-exec-3] com.alibaba.druid.pool.DruidDataSource   : {dataSource-2} inited
100000条,结束导入到数据库时间:1723192575060ms
100000条,导入用时:2489ms
100000条,开始导入到数据库时间:1723192577309ms
100000条,结束导入到数据库时间:1723192579305ms
100000条,导入用时:1996ms
100000条,开始导入到数据库时间:1723192582523ms
100000条,结束导入到数据库时间:1723192584428ms
100000条,导入用时:1905ms
100000条,开始导入到数据库时间:1723192586686ms
100000条,结束导入到数据库时间:1723192588795ms
100000条,导入用时:2109ms
100000条,开始导入到数据库时间:1723192590817ms
100000条,结束导入到数据库时间:1723192592851ms
100000条,导入用时:2034ms
100000条,开始导入到数据库时间:1723192594977ms
100000条,结束导入到数据库时间:1723192597116ms
100000条,导入用时:2139ms
100000条,开始导入到数据库时间:1723192599090ms
100000条,结束导入到数据库时间:1723192601174ms
100000条,导入用时:2084ms
100000条,开始导入到数据库时间:1723192603465ms
100000条,结束导入到数据库时间:1723192605340ms
100000条,导入用时:1875ms
100000条,开始导入到数据库时间:1723192607375ms
100000条,结束导入到数据库时间:1723192609421ms
100000条,导入用时:2046ms
100000条,开始导入到数据库时间:1723192611420ms
100000条,结束导入到数据库时间:1723192613705ms
100000条,导入用时:2285ms
2024-08-09T16:36:53.875+08:00  INFO 18552 --- [nio-7777-exec-3] org.ehcache.core.EhcacheManager          : Cache 'a1eb40dd-8471-4d69-b6c5-5b7cca3a84b6' removed from EhcacheManager.
2024-08-09T16:36:53.875+08:00  INFO 18552 --- [nio-7777-exec-3] org.ehcache.core.EhcacheManager          : Cache 'a1eb40dd-8471-4d69-b6c5-5b7cca3a84b6' removed from EhcacheManager.
------结束读取Excel的Sheet时间(包括导入数据过程):1723192613880ms------
------总耗时:45458ms------
Chancezhou
关注
专栏目录
【案例】--EasyExcel导入导出文件案例
寻梦友的博客
09-15 795
最近项目中，需要对excel、csv等文件进行解析，并做相关的业务功能。在实际业务中，遇到不少难题：(1)、excel、csv格式未知，如果解析并合理存储数据？(2)、对于大文件上传或多文件上传，如何保证系统性能和提高效率？本篇文章，我们主要介绍的是EasyExcel如何解析各类格式的文档，并合理存储数据的技术方案思路。
【实战】EasyExcel实现百万级数据导入导出
最新发布
勤于笔记，成于点滴。
07-02 3611
最近接到一个百万级excel数据导入导出的需求，大概就是我们在进行公众号API群发的时候，需要支持500w以上的openid进行群发，并且可以提供发送openid数据的导出功能。可能有的同学会说，这么大的数据量发送为啥不用标签发送呢。哈哈，标签发送需要提前打标签微信限制50个一批，我们开10个线程也是需要3个小时左右才能打完，这样肯定不能满足客户需求。如果用openid群发就不一样了，微信支持10000个每批，基本上我开5个线程同时发送差不多几分钟搞定。所以，问题就来到了百万级excel数据的导入与导出啦。
【Java】Excel百万级别数据的导入和导出【详细代码】
m0_64210833的博客
06-24 8821
Excel百万级别的数据导入和导出，包含代码和sql文件和相关视频链接，多多学习，百炼成钢。
EasyExcel百万数据导入导出
idooy的学习笔记
01-09 2485
开发中，导入导出功能对于后台管理这样的系统来说太常用了，除了实现该功能外导入导出的性能也需要开发人员进行充分的考虑。个别系统导入导出业务复杂，出现问题的地方就不局限于上面的这几个点，开发中如果是优化的话，那也无法抛开复杂的业务场景而单纯的去讨论导入导出的功能。曾经就亲身经历过业务员导入7W条数据跑好几个小时，同步导出10W条数据接口超时。如果没有业务逻辑从中作梗；单纯的导入和导出10W条数据还是很轻松的。总之，导出导入功能如果追求效率，就需要往多线程上靠；必要的话，还需要进行异步操作。
easyExcel导出百万数据
qq_29751083的博客
05-10 1111
1.由于数据远程调用,大量数据查询导出不符合实际情况,这里采取远程调用接口,将数据写入华为obs,使用追加写入的方式,可以分批查询写入,避免一次查询全部数据造成的内存溢出问题,而且可以边写边读,提高效率。3.当obs写入完成修改写入状态,导出接口发现写入完成后进行最后一次数据读取,然后讲获取的数据导出到excel。2.设计一个进度表记录写入obs文件的进度,导出接口查询进度表,实时读取写入obs的数据。// 追加写入文件内容。
使用EasyExcel实现excel导出，支持百万大数据量导出-----超简单
热门推荐
MCP的博客
02-10 1万+
超简单的EasyExcel实现excel导出，支持百万大数据量导出,通过设置sheet数量，完成分批导出，每个sheet存100万数据，每次查询插入20万数据，避免超时，内存溢出等问题，可以根据服务器配置调整参数设置。
基于EasyExcel实现百万级数据导入导出
爱笑的boy的博客
01-19 1万+
基于EasyExcel实现百万级数据导出
easyExcel百万数据导出测试
qq_42896289的博客
07-19 447
package cn.exrick.manager.controller; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.springframework.web.bind.annotation.RestC
EasyExcel实现百万级数据导入与导出
臻实
04-29 693
EasyExcel实现百万级数据导入与导出
使用easyExcel导出百万级数据
good_luck10的博客
07-17 4798
1：测试数据量两百二十多万，Excel2007，一个Excel多个sheet 2：导入maven依赖包 <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexcel</artifactId> <version>1.1.2-bet...
easyExcel实现大数据导出
11-13
阿里巴巴easyExcel实现大数据导出！！
easyExcel千万级别数据下载
12-27
`EasyExcel`是阿里巴巴开源的一款基于Java的高效、低内存消耗的Excel读写框架，它专门针对大数据量场景进行了优化，能够有效地处理大量数据的导入和导出问题。 `EasyExcel`的核心设计理念是分片读写，即在处理...
【Java】--POI、EasyExcel等导入导出对比
寻梦友的博客
04-16 1750
在很多老项目中，我们经常通过POI框架来进行Excel数据的导入和导出，但这种方式存在很大的缺点：poi框架使用复杂，sax解析模式不容易操作，数据量大起来容易OOM，POI存在并发报错等问题。现有阿里巴巴开源的一个excel处理框架EasyExce，以使用简单、节省内存著称。该项目实现了列表数据的导入，分页列表导出，支持自定义格式，支持模版以及模板和列表的混合导出。她的优点是解决了POI方式存在的问题：通过解压文件的方式加载，一行一行地加载，并且抛弃样式字体等不重要的数据，降低内存的占用。。
EasyExcel实现百万级数据的导入导出
qq_42553489的博客
08-08 6088
EasyExcel实现百万级数据的导入导出
EasyExcel -- Excel百万级数据导入导出
justlpf的专栏
06-09 5318
1.如此大批量数据的导出和导入操作，会占用大量的内存实际开发中还应限制操作人数。2.在做大批量的数据导入时，可以使用jdbc手动开启事务，批量提交。
使用 EasyExcel 实现 百万级数据导入导出
houxian1103的博客
08-19 1977
在项目开发中往往需要使用到数据的导入和导出，导入就是从Excel中导入到DB中，而导出就是从DB中查询数据然后使用POI写到Excel上。大数据的导入和导出，相信大家在日常的开发、面试中都会遇到。很多问题只要这一次解决了，总给复盘记录，后期遇到同样的问题就好解决了。好啦，废话不多说开始正文！1.如此大批量数据的导出和导入操作，会占用大量的内存实际开发中还应限制操作人数。2.在做大批量的数据导入时，可以使用jdbc手动开启事务，批量提交。
EasyExcel实现Excel百万级数据导入导出
weixin_45817985的博客
11-28 880
EasyExcel实现Excel百万级数据导入导出
EasyExcel导出大数据文件（100万条）_easyexcel导出百万数据(1)
2301_79988566的博客
04-29 936
System.out.println(“一万条数据第”+i+“个文件的第”+j+“次查询时间：” + (t4-t3) / 1000D);System.out.println(“一万条数据第”+i+“个文件的第”+j+“次查询时间：” + (t4-t3) / 1000D);System.out.println(“一万条数据第”+i+“个文件的第”+j+“次查询时间：” + (t4-t3) / 1000D);System.out.println(“总耗时：” + (t2 - t1) / 1000D);
使用easyExcel如何实现数据导入和导出
04-11
EasyExcel 是一款针对 Excel 操作的开源 Java 类库，可以方便地实现 Excel 数据的导入和导出。下面是示例代码： 导出数据： 1. 首先需要定义对应的实体类，对应 Excel 中的每一列，例如： ```java @Data public class User { @ExcelProperty("用户ID") private Long id; @ExcelProperty("用户名") private String username; @ExcelProperty("性别") private String gender; // ... } ``` 2. 在需要导出数据的方法中使用 EasyExcel 的 API 进行导出操作： ```java public void exportUser(HttpServletResponse response) { List<User> userList = userService.listUsers(); try { EasyExcel.write(response.getOutputStream(), User.class).sheet("用户列表").doWrite(userList); } catch (IOException e) { e.printStackTrace(); } } ``` 导入数据： 1. 定义导入时需要的实体类，同样需要用 `@ExcelProperty` 注解来定义每个属性对应的列： ```java @Data public class UserImport { @ExcelProperty("用户ID") private Long id; @ExcelProperty("用户名") private String username; @ExcelProperty("性别") private String gender; // ... } ``` 2. 在需要导入数据的方法中使用 EasyExcel 的 `read()` 方法进行数据读取： ```java public void importUser(MultipartFile file) { try { List<UserImport> userList = EasyExcel.read(file.getInputStream(), UserImport.class, new ReadListener()).sheet().headRowNumber(1).doReadSync(); // 处理导入的数据 } catch (IOException e) { e.printStackTrace(); } } ``` 以上就是使用 EasyExcel 进行数据导入和导出的基本操作，需要注意的是，如果导出大量数据，建议采用分页导出的方式，避免内存溢出的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值