手摸手教学-利用原生POI对excel的导入导出以及阿里的easyexcel的基本操作

最新推荐文章于 2024-05-07 20:12:11 发布
最新推荐文章于 2024-05-07 20:12:11 发布
阅读量395 收藏
点赞数 1
文章标签： java easyexcel poi excel
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/handsomezls/article/details/111224067
版权

文章目录

原生POI对excel的导入导出以及阿里的easyexcel的基本操作

首先是最原始的POI操作excel

  1. 创建一个普通的maven项目

  2. 导入pom的依赖

    <dependencies>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.14</version>
    </dependency>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>3.14</version>
    </dependency>
</dependencies>

  3. 在main/java下创建包com.test.read和com.test.write

  4. 在write包下创建DemoWrite类,写入以下代码

    1. 03版本的excel最多只能存65535行数据
    2. 07版的无限制
    3. HSSF是把所有数据先全部写入缓存，然后再对数据操作，写入磁盘。速度快，但是只能存65535行
    4. XSSF可以写入的数据无限制，但是操作大数据量的时候速度慢，容易内存溢出。报OOM错误
    5. SXSSF super XSSF的意思。默认100条（可配置）存入缓存，如果超出100条，最前面的数据会被写入临时文件。速度快，占内存少。再操作数据。但是仍然可能存在消耗大量内存的情况，比如合并区域、注释。。等
    package com.baidu.write;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.FileOutputStream;
import java.io.IOException;

public class DemoWrite {

    public static void main(String[] args) throws IOException {
        //1.创建工作簿
//        XSSFWorkbook workbook = new HSSFWorkbook();//操作03版本的excel    后缀为xls的文件
        XSSFWorkbook workbook = new XSSFWorkbook();//操作07版本的excel    后缀为xlsx的文件
//        XSSFWorkbook workbook = new SXSSFWorkbook();//操作升级版的07版本的excel    后缀为xlsx的文件
        //2.创建工作表
        XSSFSheet sheet = workbook.createSheet("sheetName");
        //3.创建行
        XSSFRow row = sheet.createRow(0);
        //3.1创建单元格
        row.createCell(0).setCellValue("卡特琳娜");
        row.createCell(1).setCellValue("不详之刃");
        row.createCell(2).setCellValue("中单");

        //创建单元格
        XSSFRow row1 = sheet.createRow(1);
        row1.createCell(0).setCellValue("放逐之刃");
        row1.createCell(1).setCellValue("瑞文");
        row1.createCell(2).setCellValue("上单");
        //输出流
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\demo.xlsx");
        workbook.write(fileOutputStream);
        fileOutputStream.flush();
        //释放资源
        fileOutputStream.close();
        workbook.close();
        System.out.println("写入成功");
    }

}

  5. 读取excel,在read包下创建DemoRead类,写入以下代码

    package com.baidu.read;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.IOException;

public class DemoRead {

    public static void main(String[] args) throws IOException {

        //1.获取工作簿
        XSSFWorkbook workbook = new XSSFWorkbook("D:\\demo.xlsx");
        //2.获取工作表
        XSSFSheet sheet = workbook.getSheetAt(0);//获取第一个sheet
        //3.获取行号--增强for循环 先遍历行,然后遍历获取每一个单元格
//        for (Row row : sheet) {
            System.out.println(row);
//            for (Cell cell : row) {
//                //获取单元格对象
//                String value = cell.getStringCellValue();
//                System.out.println(value);
//            }
//        }

        //3.获取行号 普通for循环
        int lastRowNum = sheet.getLastRowNum();
        for (int i = 0; i <= lastRowNum; i++) {
            XSSFRow row = sheet.getRow(i);
            if (row != null) {
                short lastCellNum = row.getLastCellNum();
                for (int j = 0; j <= lastCellNum; j++) {
                    XSSFCell cell = row.getCell(j);
                    if (cell != null) {
                        String stringCellValue = cell.getStringCellValue();
                        System.out.println(stringCellValue);
                    }
                }
            }
        }

        //释放资源
        workbook.close();
    }

}
其次是POI操作excel对数据库的导入导出

  1. 创建一个普通的maven项目

  2. 导入pom文件中的包

  3. <dependencies>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.14</version>
    </dependency>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>3.14</version>
    </dependency>

    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.26</version>
        <scope>compile</scope>
    </dependency>
    <!--druid连接池-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.9</version>
    </dependency>
    <!--jdbcTemplate-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.1.2.RELEASE</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.1.2.RELEASE</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-nop</artifactId>
        <version>1.7.2</version>
    </dependency>
</dependencies>

  4. 创建数据库和数据表

    -- 创建数据库
CREATE DATABASE `excel` CHARACTER SET 'utf8mb4' COLLATE 'utf8mb4_general_ci';
-- 创建数据表
CREATE TABLE `product` (
  `pid` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `pname` varchar(255) NOT NULL,
  `price` decimal(10,2) DEFAULT NULL,
  `pstock` int(10) DEFAULT NULL,
  PRIMARY KEY (`pid`)
) ENGINE=MyISAM AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4;

  5. 在main-java下分别创建包 dao(操作数据库)、domain(数据表实体类)、service(服务层)、utils(工具类包)、web包。再在dao和service包下分别创建Impl包(去实现dao和service层的接口)

  6. 在resources下创建druid.properties配置文件，代码如下

    driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///excel
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000

  7. 在utils下创建JDBCUtils工具类，代码如下

    package com.baidu.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

/**
 * JDBC工具类 使用Durid连接池
 */
public class JDBCUtils {

    private static DataSource ds;

    static {

        try {
            //1.加载配置文件
            Properties pro = new Properties();
            //使用ClassLoader加载配置文件，获取字节输入流
            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(is);

            //2.初始化连接池对象
            ds = DruidDataSourceFactory.createDataSource(pro);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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


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

  8. 在domain下创建并编写Product类，如下 要记得创建全参构造和无参构造方法

    package com.baidu.domain;

public class Product {

    private Integer pid;
    private String pname;
    private Double price;
    private Integer pstock;

    //全参构造
    public Product(Integer pid, String pname, Double price, Integer pstock) {
        this.pid = pid;
        this.pname = pname;
        this.price = price;
        this.pstock = pstock;
    }

    //无参构造 很重要
    public Product() {
    }

    @Override
    public String toString() {
        return "Product{" +
                "pid=" + pid +
                ", pname='" + pname + '\'' +
                ", price=" + price +
                ", pstock=" + pstock +
                '}';
    }

    public Integer getPid() {
        return pid;
    }

    public void setPid(Integer pid) {
        this.pid = pid;
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public Integer getPstock() {
        return pstock;
    }

    public void setPstock(Integer pstock) {
        this.pstock = pstock;
    }
}

  9. 在web下创建类Show，（这里没有前端页面,用Scanner模拟）代码如下：

    package com.baidu.web;

import com.baidu.domain.Product;
import com.baidu.service.Impl.ProductServiceImpl;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.xssf.usermodel.*;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;


public class Show {

    public static void main(String[] args) throws IOException {
        //通过键盘录入Scanner
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您要选择的功能：1：导入 2：导出 ");
        int num = scanner.nextInt();

        if (num == 1) {
            //1.导入
            //2.读取excel表格中的内容
            System.out.println("请输入您要读取的文件位置（不包含空格）");
            String path = scanner.next();
            List<Product> ProductList = read(path);
   
            //3.将数据写入数据库
            ProductServiceImpl productService = new ProductServiceImpl();
            productService.save(ProductList);
            System.out.println("数据已存入数据库中");
        } else if (num == 2) {
            //1.导出
            //2.读取数据库中的数据
            ProductServiceImpl productService = new ProductServiceImpl();
            List<Product> productList = productService.findAll();
            System.out.println(productList);
            //3.将数据写入excel表格中
            System.out.println("请输入要写入的文件位置");
            String path = scanner.next();
            write(productList,path);
            System.out.println("写入成功");
        } else {
            System.out.println("输入有误,请重新启动");

        }
    }

    //读取数据插入数据库
    public static List<Product> read(String path) throws IOException {

        List<Product> ProductList = new ArrayList<Product>();
        //1.获取工作簿
        XSSFWorkbook xssfWorkbook = new XSSFWorkbook(path);
        //2.获取工作表
        XSSFSheet sheet = xssfWorkbook.getSheetAt(0);

        int lastRowNum = sheet.getLastRowNum();
        for (int i = 1; i < lastRowNum; i++) {
            XSSFRow row = sheet.getRow(i);
            if (row != null) {
                List<String> list = new ArrayList<String>();//定义list集合
                for (Cell cell : row) {
                    if (cell != null) {
                        //首先设置成字符串类型 防止调用getStringCellValue方法的时候出现类型转换异常
                        cell.setCellType(Cell.CELL_TYPE_STRING);
                        String value = cell.getStringCellValue();//获取数据

                        if (value != null && !"".equals(value)) {
                            list.add(value);//数据放入list集合
                        }
                    }
                }

                if (list.size() > 0) {
                    Product product = new Product(Integer.parseInt(list.get(0)), list.get(1), Double.parseDouble(list.get(2)), Integer.parseInt(list.get(3)));
                    ProductList.add(product);
                }
            }
        }
        return ProductList;
    }

    //导出excel表格
    public static List<Product> write(List<Product> productList,String path) throws IOException {
        //1.创建工作簿
        XSSFWorkbook workbook = new XSSFWorkbook();
        //2.创建工作表
        XSSFSheet sheet = workbook.createSheet("商品");

        //设置样式
        XSSFCellStyle cellStyle = workbook.createCellStyle();
        cellStyle.setFillForegroundColor(IndexedColors.PINK.getIndex());
//        cellStyle.setFillPattern(CellStyle.SOLID_FOREGROUND);
        //字体样式
        XSSFFont font = workbook.createFont();
        font.setFontName("楷体");
        font.setColor(IndexedColors.BLUE.getIndex());

        //3.创建行
        XSSFRow row = sheet.createRow(0);
        XSSFCell cell = row.createCell(0);
        cell.setCellValue("商品编号");
        cell.setCellStyle(cellStyle);

        XSSFCell cell1 = row.createCell(1);
        cell1.setCellValue("商品名称");
        cell1.setCellStyle(cellStyle);

        XSSFCell cell2 = row.createCell(2);
        cell2.setCellValue("商品价格(单位:元/斤)");
        cell2.setCellStyle(cellStyle);

        XSSFCell cell3 = row.createCell(3);
        cell3.setCellValue("商品库存(单位:吨)");
        cell3.setCellStyle(cellStyle);

        for (int i = 0; i < productList.size(); i++) {
            XSSFRow row1 = sheet.createRow(i + 1);
            row1.createCell(0).setCellValue(productList.get(i).getPid());
            row1.createCell(1).setCellValue(productList.get(i).getPname());
            row1.createCell(2).setCellValue(productList.get(i).getPrice());
            row1.createCell(3).setCellValue(productList.get(i).getPstock());
        }

        FileOutputStream fileOutputStream = new FileOutputStream(path);
        workbook.write(fileOutputStream);
        fileOutputStream.flush();
        fileOutputStream.close();
        workbook.close();
        return null;
    }

}

  10. 编写service层代码。ProductService

    package com.baidu.service;

import com.baidu.domain.Product;

import java.util.List;

public interface ProductService {

    List<Product> findAll();

    void save(List<Product> productList);

}

  11. 编写service下的Impl包中的ProductService实现类 ProductServiceImpl

    package com.baidu.service.Impl;

import com.baidu.dao.ProductDao;
import com.baidu.dao.impl.ProductDaoImpl;
import com.baidu.domain.Product;
import com.baidu.service.ProductService;

import java.util.List;

public class ProductServiceImpl implements ProductService {

    private ProductDao productDao = new ProductDaoImpl();

    @Override
    public List<Product> findAll() {
        return productDao.findAll();
    }

    @Override
    public void save(List<Product> productList) {
        for (Product product : productList) {
            productDao.save(product);
        }
    }
}

  12. 编写dao层下的ProductDao

    package com.baidu.dao;

import com.baidu.domain.Product;

import java.util.List;

public interface ProductDao {

    void save(Product product);

    List<Product> findAll();
}

  13. 编写dao层下的Impl包中的ProductDao的实现类 ProductDaoImpl

    package com.baidu.dao.impl;

import com.baidu.dao.ProductDao;
import com.baidu.domain.Product;
import com.baidu.utils.JDBCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

public class ProductDaoImpl implements ProductDao {

    JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
    
    @Override
    public void save(Product product) {
        String sql = " INSERT INTO product (pid,pname,price,pstock) VALUES (?,?,?,?) ";
        jdbcTemplate.update(sql, product.getPid(), product.getPname(), product.getPrice(), product.getPstock());
    }

    @Override
    public List<Product> findAll() {
        String sql = " select * from product ";
        return jdbcTemplate.query(sql,new BeanPropertyRowMapper<Product>(Product.class));
    }
}
最后是阿里的easyexcel的简单操作（官方文档已经十分详细 ）

  1. 创建一个maven项目

  2. 导入依赖

    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>2.2.0-beta2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.71</version>
        </dependency>
</dependencies>

  3. 在java目录下创建包com.test.easyexcel,我这里创建的是com.baidu.domain。其实不该在domain下创建，不符合规范。

  4. 在包下创建类DemoData,代码如下

    package com.baidu.domain;

import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;

import java.util.Date;

@Data
public class DemoData {

    //easyExcel
    @ExcelProperty("字符串标题")
    private String string;
    @ExcelProperty("日期标题")
    private Date date;
    @ExcelProperty("数字标题")
    private Double doubleData;

    //忽略这个字段
    @ExcelIgnore
    private String ignore;

}

  5. 创建DemoDataListener类,代码如下

    package com.baidu.domain;

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

// 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
public class DemoDataListener extends AnalysisEventListener<DemoData> {
    private static final Logger LOGGER = LoggerFactory.getLogger(DemoDataListener.class);
    /**
     * 每隔5条存储数据库，实际使用中可以3000条，然后清理list ，方便内存回收
     */
    private static final int BATCH_COUNT = 5;
    List<DemoData> list = new ArrayList<DemoData>();
    /**
     * 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
     */
    private DemoDAO demoDAO;
    public DemoDataListener() {
        // 这里是demo，所以随便new一个。实际使用如果到了spring,请使用下面的有参构造函数
        demoDAO = new DemoDAO();
    }
    /**
     * 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
     *
     * @param demoDAO
     */
    public DemoDataListener(DemoDAO demoDAO) {
        this.demoDAO = demoDAO;
    }
    /**
     * 这个每一条数据解析都会来调用
     *
     * @param data
     *            one row value. Is is same as {@link AnalysisContext#readRowHolder()}
     * @param context
     */
    @Override
    public void invoke(DemoData data, AnalysisContext context) {
        System.out.println(JSON.toJSONString(data));
//        LOGGER.info("解析到一条数据:{}", JSON.toJSONString(data));//未导入LOGGER.info的配置文件 所以用System.out.println输出
        list.add(data);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (list.size() >= BATCH_COUNT) {
            saveData();
            // 存储完成清理 list
            list.clear();
        }
    }
    /**
     * 所有数据解析完成了 都会来调用
     *
     * @param context
     */
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        saveData();
        LOGGER.info("所有数据解析完成！");
    }
    /**
     * 加上存储数据库
     */
    private void saveData() {
        LOGGER.info("{}条数据，开始存储数据库！", list.size());
        demoDAO.save(list);
        LOGGER.info("存储数据库成功！");
    }
}

  6. 创建DemoDAO，代码如下

    package com.baidu.domain;

import java.util.List;

/**
 * 假设这个是你的DAO存储。当然还要这个类让spring管理，当然你不用需要存储，也不需要这个类。
 **/
public class DemoDAO {
    public void save(List<DemoData> list) {
        // 如果是mybatis,尽量别直接调用多次insert,自己写一个mapper里面新增一个方法batchInsert,所有数据一次性插入
    }
}

  7. 在utils包下面创建TestFileUtil工具类。就获取文件路径之类的东西 跳过这一步也没啥影响。因为第8步已经注释掉了相关代码。

    package com.baidu.utils;

import java.io.File;
import java.io.InputStream;

public class TestFileUtil {
    public static InputStream getResourcesFileInputStream(String fileName) {
        return Thread.currentThread().getContextClassLoader().getResourceAsStream("" + fileName);
    }

    public static String getPath() {
        return TestFileUtil.class.getResource("/").getPath();
    }

    public static File createNewFile(String pathName) {
        File file = new File(getPath() + pathName);
        if (file.exists()) {
            file.delete();
        } else {
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
        }
        return file;
    }

    public static File readFile(String pathName) {
        return new File(getPath() + pathName);
    }

    public static File readUserHomeFile(String pathName) {
        return new File(System.getProperty("user.home") + File.separator + pathName);
    }
}

  8. 创建测试类，代码如下。跑每个测试方法即可测试。

    import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.read.metadata.ReadSheet;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.baidu.domain.DemoData;
import com.baidu.domain.DemoDataListener;
import com.baidu.utils.TestFileUtil;
import org.junit.Test;


import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class TestEasyExcel {

    String PATH = "D:\\";

    private List<DemoData> data() {
        List<DemoData> list = new ArrayList<DemoData>();
        for (int i = 0; i < 10; i++) {
            DemoData data = new DemoData();
            data.setString("字符串" + i);
            data.setDate(new Date());
            data.setDoubleData(0.56);
            list.add(data);
        }
        return list;
    }

    //根据list,写入excel
    @Test
    public void simpleWrite() {
        //写法1
        String fileName = PATH + "easy.xlsx";
        EasyExcel.write(fileName, DemoData.class).sheet("zls").doWrite(data());

        System.out.println("执行完毕");
    }

    /**
     * 官方文档提供的方法
     * 最简单的写
     * <p>1. 创建excel对应的实体对象 参照{@link DemoData}
     * <p>2. 直接写即可
     */
    @Test
    public void simpleWriteDemo() {
        // 写法1
        String fileName = TestFileUtil.getPath() + "simpleWrite" + System.currentTimeMillis() + ".xlsx";
        // 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
        // 如果这里想使用03 则 传入excelType参数即可
        EasyExcel.write(fileName, DemoData.class).sheet("模板").doWrite(data());

        // 写法2
        fileName = TestFileUtil.getPath() + "simpleWrite" + System.currentTimeMillis() + ".xlsx";
        // 这里 需要指定写用哪个class去写
        ExcelWriter excelWriter = null;
        try {
            excelWriter = EasyExcel.write(fileName, DemoData.class).build();
            WriteSheet writeSheet = EasyExcel.writerSheet("模板").build();
            excelWriter.write(data(), writeSheet);
        } finally {
            // 千万别忘记finish 会帮忙关闭流
            if (excelWriter != null) {
                excelWriter.finish();
            }
        }
    }

    /**
     * 官方文档提供的方法
     * 最简单的读
     * <p>1. 创建excel对应的实体对象 参照{@link DemoData}
     * <p>2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
     * <p>3. 直接读即可
     */
    @Test
    public void simpleRead() {
        // 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
        // 写法1：
//        String fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
        String fileName = PATH + "easy.xlsx";//路径使用刚才写出来的文件
        // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
        EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();

        // 写法2：不做测试
//        fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
//        ExcelReader excelReader = null;
//        try {
//            excelReader = EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).build();
//            ReadSheet readSheet = EasyExcel.readSheet(0).build();
//            excelReader.read(readSheet);
//        } finally {
//            if (excelReader != null) {
//                // 这里千万别忘记关闭，读的时候会创建临时文件，到时磁盘会崩的
//                excelReader.finish();
//            }
//        }
    }

}

参考教程:
狂神说
传智博学谷–(这是一个小姐姐的教程，值得看看)
其实这也不是教学博客，只是自己看完别人的教程以后的一个总结而已。

最美不过下雨天啊
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Easyexcel对应poi 依赖关系、excel加密、水印
weixin_44235190的博客
04-26 2718
Easyexcel、poi 依赖关系1.依赖关系 Easyexcel 3.0.5Easyexcel版本依赖包含对应poi依赖功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 1.依赖关系 Easyexcel 3.0.5 <d
快速通关Java 对 Excel导入导出-POI和EasyExcel
06-20
? ? ? 当前B/S模式已成为应用开发的主流，而在企业办公系统中，常常如下需求：把我们的报表直接用Excel... 通过本课程学习让大家快速通关Java对Excel操作，掌握POI和EasyExcel相关应用，彻底搞定Excel导入导出问题。
easyexcel 设置超链接或附件地址
CatchCat的博客
05-03 6222
easyexcel 设置超链接或附件地址自定义拦截器测试方法结果 自定义拦截器 package com.alibaba.easyexcel.test.demo.write; import java.util.List; import org.apache.poi.common.usermodel.HyperlinkType; import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.CreationHelper
使用阿里的EasyExcel读写Excel文档
最新发布
2401_84150168的博客
05-07 335
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
easyExcel 与 POI 基础知识
weixin_51351637的博客
05-13 2470
*创建工作簿对象：**其中org.apache.poi.ss.usermodel.Workbook是一个接口，有三个实现类，分别是HSSFWorkbook（Excel 03 版本）、SXSSFWorkbook（可以加快速度的处理07版本Excel）、XSSFWorkbook(Excel 07 版本，处理速度会慢一点)下面的实现，Workbook接口的实现类是XSSFWorkbook，IO流输出的文件的名称结尾是".xlsx"，除此之外其他的基本相同。（07 版Excel，没有限制多少行）
Apache POI和EasyExcel 第六集：Apache POI的Excel读取单元格中的计算公式
XRT_knives的博客
12-17 1245
Apache POI和EasyExcel 第六集：Apache POI的Excel读取单元格中的计算公式 一、资源 代码实现中的带有计算公式的Excel（xls） 链接：https://pan.baidu.com/s/1-iOXn4ZnzM9eFcNbo40Gzg 提取码：0916 二、代码实现 @Test public void testFormula() throws Exception { InputStream is = new FileInput
POI和EasyExcel
superchen98的博客
06-01 505
POI和EasyExcel 引入pom‘依赖 <!--xls 03版本--> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>3.17</version> </de
POI实现Excel导入导出并附带加载进度条
08-30
它利用了Apache POI的强大功能，结合maven的依赖管理，以及可能的GUI组件，提供了高效且直观的数据操作体验。开发者可以根据提供的测试数据和说明，轻松地将这个功能集成到自己的项目中，从而提升Excel处理部分的...
java 利用POI 导入导出Excel
06-03
前几天项目上需要加上导入导出，在网上找了一下，么有...于是自己写，源码里所需要的jar都有，从jsp界面进行Excel的导入导出，并可用于上传和下载。如有所用，喜不自禁,分享，开源的意义。 写的不是特别好，不喜勿喷！
Springboot+Poi实现Excel的导入导出
01-28
本项目结合了Spring Boot、MyBatis、Apache POI和MySQL，实现了Excel数据的导入导出功能，这对于数据处理和分析尤其有用。下面我们将深入探讨这些技术及其在项目中的应用。 首先，Spring Boot以其“约定优于配置”...
SSM框架利用poi导入导出Excel文件 demo
10-31
在本示例"SSM框架利用poi导入导出Excel文件 demo"中，我们将探讨如何在SSM项目中使用Apache POI库来实现Excel文件的导入与导出功能。 Apache POI是一个流行的开源库，它允许开发者在Java应用程序中创建、修改和显示...
POI和esayExcel
fjd7474的博客
07-18 2372
目前比较流行的就是ApachePoI和阿里巴巴的easyExcel！
easyexcel导出功能修改模板中的公式和下拉框获取
weixin_44236424的博客
08-12 1858
easyexcel的公式和下拉框实现
POI与easyExcel
lemon
02-04 570
POI Apache POI 官网 easyExcel easyExcel 官网地址 EasyExcel 是阿里巴巴开源的一个excel处理框架，以使用简单、节省内存著称。 EasyExcel 能大大减少占用内存的主要原因是在解析 Excel 时没有将文件数据一次性全部加载到内存中， 而是从磁盘上一行行读取数据，逐个解析。 下图是 EasyExcel 和 POI 在解析Excel时的对比图。 官方文档 POI快速开始 写 创建项目 导入依赖 由于excel分为03和07版的所以下面两个版本都导入了
EasyExcel之填充公式导出Excel
热门推荐
瘦子没有夏天
01-18 1万+
一、业务背景 1.1 技术演进 在业务系统的开发中，我们会经常遇见各类各样的Excel导出，按照传统的做法，我们会引入第三方工具jar: POI来实现我们的导出功能。但是这也有缺点,我们的业务代码中充斥着重复且没有很多意义的代码。 于是EasyExcel诞生了，它的出现了大大降低了我们开发的工作量，给我们提供了不少便利。 EasyExcel 官方源码： 链接 官方文档： 链接 在这里，对EasyExcel我们就不做过多介绍，有不了解的同学可以根据上述的官方地址进行自行学习。 本篇文章所探求的主旨均是建立
EasyExcel与POI
weixin_59048239的博客
09-27 4179
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bfQ2tCcU-1664283941992)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20220927162011271.png)]
POI处理Excel中公式不能自动计算出来的问题
时光的博客
05-16 6476
昨天运维给我发信息说通过Excel导入信息集报错，我一脸迷茫~因为我在本地测试毫无问题 于是喊她把她需要导入的Excel发给我看看，一看果然是跟我操作不一样的。 她们在计算合计时是通过excel公式计算的，而我本地是直接输入的。这就导致了一个问题的出现。 获取到的值为null,我不能通过常规方法获取公式计算出来的值。 在经过网上一番查找答案之后，终于找到了一个简单高效的方法。 新增了一个方法 //...
Easyexcel：org.apache.poi.POIXMLException: java.lang.reflect.InvocationTargetException
qq_54224923的博客
06-05 593
easyexcel: org.apache.poi.POIXMLException: java.lang.reflect.InvocationTargetException com.alibaba.excel.exception.ExcelGenerateException: Create workbook failure
解决POi冲突总结（当项目存在多个POI依赖时）
DiKui1997的博客
07-04 5967
项目同时引入了easy excel和自动化测试框架concordion-excel-extension，这两个依赖都制定了内置了POI版本，我的冲突是POI3.14和4.1.2，导致了在easy excel使用时依赖混论，找不到方法。如果可以去掉一个提升版本依赖是最好的，如果不能的情况下那只能找到中间版本，但这样又会增加一个版本依赖。可以将easy excel源代码克隆，官网提供了各个版本的代码，克隆下来之后。其实就是两个POI提供的方法不一样，当依赖混乱时就会找不到对应版本的对应方法。
Java使用POI操作Excel：导入导出详解
- 为了提高开发效率，减少代码重复，可以编写工具类，封装常见的Excel操作方法，如导入导出方法，使用反射和自定义注解优化功能。 7. **依赖管理**： - 需要在项目中引入Apache POI的三个依赖： - poi：核心库，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值