一个基于POI 进行Excel导入和导出的工具类

最新推荐文章于 2021-07-21 17:05:58 发布
置顶 最新推荐文章于 2021-07-21 17:05:58 发布
阅读量286 收藏 1
点赞数 1
分类专栏： Java 文章标签： java excel
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhc82871987/article/details/112722288
版权

一个基于POI 进行Excel导入和导出的工具类

1.引入POI依赖

首先maven引入poi依赖包，我这里使用的是4.1.2版本。

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

2.相关API介绍

  • Workbook： 表示一个excel文件
  • Sheet： 表示excel文件中的一个工作薄，通过Workboot创建
  • Row： Excel的行，通过Sheet创建
  • Cell： 表示一个单元格，通过Row创建

3. ExcelUtils类

import com.oatrc.common.utils.file.FileUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.util.List;

/**
 * @author xhc
 * @Date 2020/11/3 13:31
 */
public class ExcelUtils {

    /**
     * 创建工作簿
     * @param fis 文件输入流
     * @param fileName 文件名
     * @return 返回指定版本的workbook
     */
    public static Workbook getWorkbook(InputStream fis, String fileName) throws IOException {
        if (FileUtils.isExcel(fileName)){
            Workbook workbook = null;
            String extension = FileUtils.getFileExtension(fileName);
            if (extension.equalsIgnoreCase("xls")){
                workbook = new HSSFWorkbook(fis);
            }else if (extension.equalsIgnoreCase("xlsx")){
                workbook = new XSSFWorkbook(fis);
            }
            return workbook;
        }
        return null;
    }

    /**
     * 读取excel文件中的内容
     * @param fis 输入流
     * @param fileName 文件名称
     * @param clazz 生成的对象类型
     * @param <T> 生成的对象类型
     * @return 返回excel文件中的对象列表
     * @throws IOException 抛出IO异常
     */
    public static <T> List<T> readList(InputStream fis, String fileName, Class<T> clazz) throws IOException {
        Workbook workbook = getWorkbook(fis, fileName);
        if (workbook != null){
            return readList(workbook, clazz, 0);
        }
        return null;
    }

    /**
     * 从Excel文件中创建java对象
     * @param workbook
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> List<T> readList(Workbook workbook, Class<T> clazz, int sheetIndex) throws IOException {
        if (workbook != null && clazz != null){
            ExcelVo<T> excelVo = ExcelVo.getInstance(clazz);
            if (excelVo != null){
                return excelVo.readExcel(workbook, sheetIndex);
            }
        }
        return null;
    }

    /**
     * 创建excel工作簿
     * @param rows
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> Workbook createExcel(List<T> rows, Class<T> clazz){
        if (rows != null && clazz != null){
            ExcelVo<T> excelVo = ExcelVo.getInstance(clazz);
            if (excelVo != null){
                return excelVo.createExcel(rows);
            }
        }
        return null;
    }

    /**
     * 将excel文件写到客户端
     * @param workbook excel工作簿
     * @param fileName 客户端下载文件时的文件名
     * @param response 文件输出目的地
     * @throws IOException 异常信息
     */
    public static void write(Workbook workbook, String fileName, HttpServletResponse response) throws IOException {
        if (workbook != null && FileUtils.isExcel(fileName)){
            response.setContentType("application/vnd.ms-excel");
            response.setHeader("content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "utf-8"));
            response.setHeader("Access-Control-Expose-Headers", "content-Disposition");
            workbook.write(response.getOutputStream());
        }
    }

    /**
     * 将excel文件写到客户端
     * @param workbook excel工作簿
     * @param fileName 客户端下载文件时的文件名
     * @param outputStream 文件输出流
     * @throws IOException 异常信息
     */
    public static void write(Workbook workbook, String fileName, OutputStream outputStream) throws IOException {
        if (workbook != null && FileUtils.isExcel(fileName)){
            workbook.write(outputStream);
            outputStream.flush();
        }
    }

}

4. Excel注解类

import java.lang.annotation.*;


/**
 * 标注在java对象上表示该对象可以进行Excel的读取和创建。
 * 没有标注该注解的对象无法使用ExcelUtils进行Excel创建和读取操作。
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Excel {

    /**
     * 最大支持的行数，当导入的文件行数大于该数值时会抛出ExcelException异常
     */
    public int maxRow() default 10000;

    /**
     * 最大支持的列数，当导入的文件列数大于该数值时会抛出ExcelException异常
     */
    public int maxCol() default 100;

    /**
     * 导出时在excel中行的高度，单位（px）
     */
    public short height() default 14;

}

5. ExcelCoumn注解类

import org.apache.poi.ss.usermodel.CellType;
import java.lang.annotation.*;

/**
 * excel导入导出时列字段的注解， 标注在java对象的属性上，
 * 规范excel单元格内容与java属性之间的转换关系。
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ExcelColumn {

    /**
     * 表格标题
     */
    public String value() default "";

    /**
     * 表格中字段的编号
     */
    public int index() default 0;

    /**
     * 导出时在excel中每个列的宽 单位为字符
     */
    public short width() default 16;

    /**
     * 导出类型
     */
    public CellType cellType() default CellType.STRING;

    /**
     * 当值为空时,创建excel时的默认值
     */
    public String defaultValue() default "";

    /**
     * 日期格式, 如: yyyy/MM/dd hh:mm:ss
     */
    public String dateFormat() default "yyyy/MM/dd hh:mm:ss";

    /**
     * 文字后缀,如% 90 变成90%
     */
    public String suffix() default "";

    /**
     * 读取内容转表达式 (格式: 0=男,1=女,2=未知)，将等号前后的数据进行映射。
     * 等号左边的数据时java对象的值，右边为excel单元格内容。
     */
    public String converter() default "";

}

6.CellConverter类

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 进行数据的映射，对ExcelColumn注解中的converter字段进行解释
 * 如 （0=男,1=女）
 */
public class CellConverter {

    private Map<String, String> map = new HashMap<>();

    /**
     * 创建Converter对象
     * @param pattern 格式必须是 k1=v1,k2=v2的字符串，中间为英文逗号
     */
    public CellConverter(String pattern){
        String[] values = pattern.split(",");
        for (String value : values){
            String[] data = value.split("=");
            map.put(data[0], data[1]);
        }
    }

    /**
     * 导入数据时，将excel的数据转成java数据
     * @param val 映射前的数据
     * @return 返回映射后的数据
     */
    String getObjVal(String val){
        Set<String> keySet = map.keySet();
        for (String key : keySet){
            if (map.get(key).equals(val)){
                return key;
            }
        }
        return null;
    }

    /**
     * 导出数据时将java数据转成excel明文信息
     * @param key 映射前的数据
     * @return 返回映射后的数据
     */
    String getExcelVal(String key){
        return map.get(key);
    }

}

7. 核心对象 ExcelVo

import com.oatrc.common.exception.ExcelException;
import com.oatrc.common.utils.string.StringUtils;
import lombok.Data;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 实际进行Excel导入和创建操作的对象
 * @author xhc
 * @Date 2020/11/3 13:31
 */
@Data
public class ExcelVo<T> {

    private static final Logger logger = LoggerFactory.getLogger(ExcelVo.class);

    private int maxRow;     //最大行数

    private int maxCol;     //最大列数

    private short rowHeight; //行高

    private List<Column> columns;   //表格的列信息

    private List<T> objList;   //Java对象

    private Workbook workbook;  //excel工作簿

    private Class<T> rowType;   //生成Excel行数据的java对象类型

    private final Map<String, CellConverter> cellConverterMap = new HashMap<>();    //存放字段的翻译对象

    /**
     * 禁止使用new关键字来创建实例
     */
    private ExcelVo(Class<T> rowType){
        this.rowType = rowType;
    }

    /**
     * 获取一个实例对象，检查传入的对象是否有Excel注解，若没有则返回null
     * @param clazz excel映射的java类型
     * @return 返回一个ExcelVo对象
     */
    public static <T> ExcelVo<T> getInstance(Class<T> clazz){
        //通过clazz对象填充maxRow，maxCol，columns数据
        Excel excel = clazz.getDeclaredAnnotation(Excel.class);
        if (excel == null){
            throw new ExcelException(clazz.getName() + "不支持Excel操作");
        }
        ExcelVo<T> excelVo = new ExcelVo<>(clazz);
        //获取java类上注解修饰的信息
        excelVo.setMaxRow(excel.maxRow());
        excelVo.setMaxCol(excel.maxCol());
        excelVo.setRowHeight((short) (excel.height() * 20));
        //获取每列的元信息
        Field[] fields = clazz.getDeclaredFields();
        List<Column> columns = createColumns(fields, excelVo.getCellConverterMap());
        if (columns.size() > excelVo.maxCol){
            throw new ExcelException("Excel数据超出限制，最大支持" + excelVo.maxCol + "列数据");
        }
        excelVo.setColumns(columns);
        return excelVo;
    }

    /**
     * 填充列的元数据信息
     * @param fields
     * @return
     */
    private static List<Column> createColumns(Field[] fields, Map<String, CellConverter> cellConverterMap){
        List<Column> columns = new ArrayList<>();
        for (Field field : fields){
            ExcelColumn annotation = field.getDeclaredAnnotation(ExcelColumn.class);
            if (annotation != null){
                Column column = new Column();
                column.setFieldName(field.getName());
                column.setName(annotation.value());
                column.setIndex(annotation.index());
                column.setWidth(annotation.width());
                column.setDefaultValue(annotation.defaultValue());
                column.setDateFormat(annotation.dateFormat());
                column.setSuffix(annotation.suffix());
                column.setFieldType(field.getType().getSimpleName().toLowerCase());
                column.setConvert(annotation.converter());
                if (StringUtils.isNotEmpty(annotation.converter())){
                    cellConverterMap.put(column.getFieldName(), new CellConverter(annotation.converter()));
                }
                columns.add(column);
            }
        }
        return columns;
    }

    /*----------------------------------------- READ ---------------------------------------*/

    /**
     * 读取excel文件中的数据
     * @param workbook excel文件
     * @return 读取结果
     */
    public List<T> readExcel(Workbook workbook, int sheetIndex){
        this.objList = new ArrayList<>();
        if (workbook != null){
            this.workbook = workbook;
            Sheet sheet = workbook.getSheetAt(sheetIndex);
            //获取工作表的行数
            int rowCount = sheet.getPhysicalNumberOfRows();
            if (rowCount > maxRow + 1){
                throw new ExcelException("Excel数据超出限制，最大支持" + maxRow + "行数据");
            }
            if (rowCount > 1){
                //从第二行开始读取数据，第一行是标题，忽略
                for (int i = 1; i < rowCount; i++){
                    Row row = sheet.getRow(i);
                    T rowValue = setRowValue(row);
                    if (rowValue != null){
                        this.objList.add(rowValue);
                    }
                }
            }
        }
        return this.objList;
    }

    /**
     * 获取一个行记录
     * @return
     */
    private T setRowValue(Row row){
        T rowObj = null;
        try {
            rowObj = this.rowType.newInstance();
            for (Column column: this.columns){
                //获取cell中的数据
                Cell cell = row.getCell(column.getIndex());
                //excel中的原始数据
                String cellVal = getCellValue(cell);
                if (StringUtils.isNotEmpty(cellVal)){
                    //如果定义了数据转换对象，则对数据进行转换
                    CellConverter converter = this.getCellConverter(column.getFieldName());
                    if (converter != null){
                        cellVal = converter.getObjVal(cellVal);
                    }
                    try {
                        if (StringUtils.isNotEmpty(cellVal)){
                            Field field = this.rowType.getDeclaredField(column.getFieldName());
                            field.setAccessible(true);  //使属性可以被操作
                            setCellValue(field, rowObj, cellVal, column.getFieldType());
                        }
                    } catch (NoSuchFieldException e) {
                        e.printStackTrace();
                    }

                }
            }
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        System.out.println(rowObj);
        return rowObj;
    }

    /**
     * 获取Excel单元格的数据
     * @param cell 单元格
     * @return 返回单元格中的数据
     */
    private String getCellValue(Cell cell){
        if (cell != null){
            cell.getCellStyle();
            CellType cellType = cell.getCellType();
            switch (cellType) {
                case STRING: return cell.getStringCellValue();
                case BOOLEAN: return getBooleanValue(cell).toString();
                case NUMERIC: return getNumericValue(cell).toString();
                case FORMULA: return getFormulaValue(cell).toString();
                default: return null;
            }
        }
        return null;
    }

    private Boolean getBooleanValue(Cell cell){
        return cell.getBooleanCellValue();
    }

    /**
     * 获取单元格中用公式生成的数据
     */
    private Double getFormulaValue(Cell cell){
        FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
        evaluator.evaluateFormulaCell(cell);
        CellValue cellValue = evaluator.evaluate(cell);
        return cellValue.getNumberValue();
    }

    /**
     * 获取单元格中的数字类型的数据
     */
    private Object getNumericValue(Cell cell){
        Object columnValue = null;
        String cellStyleStr = cell.getCellStyle().getDataFormatString();
        if ("@".equalsIgnoreCase(cellStyleStr) || "General".equalsIgnoreCase(cellStyleStr)) {
            columnValue = cell.getNumericCellValue();
        } else {
            columnValue = DateUtil.getJavaDate(cell.getNumericCellValue()).getTime();
        }
        return columnValue;
    }

    /**
     * 填充字段数据
     */
    private void setCellValue(Field field, Object obj, String val, String fieldType) throws IllegalAccessException {
        if (fieldType.equalsIgnoreCase("string")){
            field.set(obj, val);
        } else if (fieldType.equalsIgnoreCase("BigDecimal")){
            field.set(obj, new BigDecimal(val));
        } else if (fieldType.equalsIgnoreCase("BigInteger")){
            field.set(obj, new BigInteger(val));
        } else if (fieldType.equalsIgnoreCase("int") || fieldType.equalsIgnoreCase("integer")){
            field.set(obj, Integer.valueOf(val));
        } else if (fieldType.equalsIgnoreCase("long")){
            field.set(obj, Long.valueOf(val));
        } else if (fieldType.equalsIgnoreCase("short")){
            field.set(obj, Short.valueOf(val));
        } else if (fieldType.equalsIgnoreCase("byte")){
            field.set(obj, Byte.valueOf(val));
        } else if (fieldType.equalsIgnoreCase("double")){
            field.set(obj, Double.valueOf(val));
        } else if (fieldType.equalsIgnoreCase("float")){
            field.set(obj, Float.valueOf(val));
        } else if (fieldType.equalsIgnoreCase("boolean")){
            field.set(obj, Boolean.valueOf(val));
        }else if (fieldType.equalsIgnoreCase("date")){
            field.set(obj, new Date(Long.parseLong(val)));
        }
    }

    /*----------------------------------------- WRITE ---------------------------------------*/

    /**
     * 创建excel工作簿
     * @param objList java集合
     * @return excel工作簿
     */
    public Workbook createExcel(List<T> objList){
        this.objList = objList;
        //创建workbook
        Workbook workbook = new SXSSFWorkbook(1000);
        //创建工作薄
        Sheet sheet = workbook.createSheet();
        //创建标题
        Row title = sheet.createRow(0);
        title.setHeight(this.rowHeight);
        fillTitle(title);
        //填充内容
        for (int i = 0; i < objList.size(); i++) {
            Row row = sheet.createRow(i + 1);
            row.setHeight(this.rowHeight);
            fillRow(row, objList.get(i));
        }
        this.workbook = workbook;
        return workbook;
    }

    /**
     * 填充标题信息
     * @param title
     */
    private void fillTitle(Row title) {
        for (Column column : columns){
            //创建单元格并设置列名称以及列的样式
            Cell cell = title.createCell(column.getIndex());
            cell.setCellValue(column.getName());
        }
    }

    /**
     * 填充excel文件内容
     * @param row
     * @param obj
     */
    private void fillRow(Row row, T obj) {
        for (Column column : columns){
            //创建单元格并设置列名称以及列的样式
            Cell cell = row.createCell(column.getIndex());
            setCellValue(cell, column, obj);
        }
    }

    private void setCellValue(Cell cell, Column column, T obj) {
        try {
            Field field = obj.getClass().getDeclaredField(column.getFieldName());
            field.setAccessible(true);
            Object val = field.get(obj);
            if (val != null){
                //判断是否有Convert数据映射对象
                CellConverter converter = this.getCellConverter(column.getFieldName());
                if (converter != null){
                    val = converter.getExcelVal(val.toString());
                }
                //判断数据是否为时间类型
                if (val instanceof Date){
                    SimpleDateFormat dateFormat = new SimpleDateFormat(column.getDateFormat());
                    val = dateFormat.format((Date) val);
                }
                cell.setCellValue(val.toString());
            }else{
                cell.setCellValue(column.getDefaultValue());
            }
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }


    /*------------------------------------- COMMON -------------------------------------------*/

    /**
     * 获取指定字段的字段翻译对象
     * @param fieldName 字段名称
     * @return 处理该字段java对象和excel字段的映射的CellConverter对象
     */
    private CellConverter getCellConverter(String fieldName){
        return this.cellConverterMap.get(fieldName);
    }

    /**
     * 隐藏对cellConverterMap的外部访问权限
     */
    private Map<String, CellConverter> getCellConverterMap(){
        return this.cellConverterMap;
    }

}

注：代码中使用到了FileUtils工具类以及StringUtils等工具类，这些工具类只是为了简化代码开发的，代码很简单，不在此处贴出了，根据方法名称便可以知道该方法是干嘛用的，若有兴趣，可以私信笔者或者加QQ：82871987索要代码。

另外ExcelException只是简单的继承了RuntimeException类。

会编程的大熊猫
关注
专栏目录
基于poi的excel导入导出工具类
04-03
基于poi的excel导入导出封装，poi版本 org.apache.poi poi 4.1.0 org.apache.poi poi-ooxml 4.1.0
基于POI实现Excel表的导入导出功能
热门推荐
HackDaily
06-12 4万+
对于批量数据的操作，在项目中引进Excel的导入和导出功能是个不错的选择。对于Excel表的结构，简单理解可以把它分成三部分（Sheet，Cell，Row），这三部分可以理解为excel表中的页，列，行。因此，我们想要获取到某一个单元的内容，可以通过获取该单元所在的页数、对应所在的行和对应的列数从而定位到该单位，继而便可执行操作从而获取其中的内容。本文在SSM环境下基于Java的POI实现对exc...
使用POI书写EXCEL常用导入导出工具类
bigLiu66的博客
12-27 472
目录 一：先到http://poi.apache.org/官网下载poi相关jar包  二：先来做一个简单的demo  三：书写通用工具类 四：测试程序   一：先到http://poi.apache.org/官网下载poi相关jar包 我这里使用的版本是4.0.1  解压后选取需要的jar包   接下来就是熟悉的构建工程了，将jar包文件放到lib目录下  二：先来做一...
poi-Excel导入/导出工具类
tangyb828的博客
04-16 1130
一、POI导出报表要用到的包 <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>3.13</version> </dependency> <depende...
【小家java】一个基于POI的Excel导入、导出工具处理类（支持xls，xlsx格式），另有SpringMVC的导入、导出案例讲解
架构师：通透，才能写出好代码！
11-14 1292
前言 表格的导入、导出可谓开发过程中经常会碰到的功能。然后这种模版化的东西并不需要每次都去编码一次，因此我就整理了一个Excel的万能处理类。能够实现兼容2003、2007的各种Excel格式的导入导出功能，使用起来也非常的方面，适用于所有业务场景，下面会有案例讲解 Excel导入、导出工具类源码： /** * 操作Excel的处理器类(含导入和导出功能) * * @author fangs...
基于POI的Excel多Sheet页导出导入工具类
02-13
"基于POI的Excel多Sheet页导出导入工具类"是一个实用的Java类库，专为处理Excel文件中的多个工作表（Sheet）而设计，提供了一种高效且灵活的方式来操作Excel数据。 该工具类的核心功能包括： 1. **多Sheet页操作**...
excel poi工具类 导入 导出 合并单元格 计算公式
01-07
这个“excel poi工具类”是利用Apache POI库来实现对Excel文件进行导入、导出、合并单元格以及处理计算公式的功能。下面我们将深入探讨这些知识点。 **1. Apache POI库介绍** Apache POI是一个开源项目，它为Java...
SpringBoot整合poi实现Excel文件的导入和导出.pdf
10-08
下面我们将详细介绍如何在SpringBoot中整合POI来实现Excel的导入和导出，以及如何利用ExcelFormatUtil工具类进行单元格数据格式的判断。 首先，我们需要在项目的pom.xml文件中引入Apache POI的相关依赖，具体如下：...
Java poi导入导出EXCEL工具类（兼容各版本）
08-21
概述：Java poi导入导出EXCEL工具类（兼容各版本） 一、功能说明 允许同时导入或导出多个sheet，同一sheet可同时存在多个数据块，按数据块划分处理数据。 二、配置文件示例及详细说明 1、导入xml配置示例如下（见...
poi导入Excel工具类
jattxgt的博客
08-22 207
package exportexcel; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.InputStream; import java.math.BigDecimal; import org.apache.poi.hssf.usermodel.HSSFCell;...
poi导入导出Excel通用工具类 兼容xls，xlsx
07-11
利用poi导入导出Excel xls，xlsx
java poi excel 模板导入通用工具类，支持2003/2007
06-23
java poi excel 模板导入通用工具类，支持 2003/2007 版excel 详细看里面的README.md
poi多sheet页导出工具类和实例 包含多个excel导出
03-22
改资源包含 数据量超过20万以上导出解决方案，还有动态获取数据公共类 1） 把数据分成多个sheet导出。 2） 把数据分成多个excel 导出。 全部都有，还有实例。
基于POI的excel导入
baidu_35051056的博客
07-21 4038
一般基于POI导入时仅需要一个POI包即可，但是前提是所需要导入的模板或文件仅需要支持一个excel版本时，这时你仅需要导入一个POI包即可。 ooxml、ooxml-schemas是基于xlsx后缀也就是office版本在2003以后的版本时所需要的包。 目前所写的excel导入的版本为 office 2003 版本后缀名为 .xls 的导入方式，如果需要更高版本的将里面的 new HSSFWorkbook 这块进行变更为对应版本的即可。 HSSFworkbook 支持后缀.xls（2003） X.
基于POI的导入导出Excel
weixin_34216196的博客
03-08 38
package main.java;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import...
Java工具集-POI导入工具
逍遥云恋
12-30 692
添加依赖 <!--poi--> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>4.0.1<...
POI导入工具类
admin_mvip的博客
01-21 1228
ExcelUtil.java 是主要工具类 WDWUtil.java 是验证Excel是2003（HSSFWorkbook）还是2007（XSSFWorkbook）；以及文件是否是Excel文件 使用方法，此处是SpringMVC接收上传的文件， 使用(org.springframework.web.multipart.MultipartFile)MultipartFile file来接收文...
Java基于POI4.1.2实现Excel的导入导出功能
qq_36069670的博客
07-09 2254
Java基于POI4.1.2实现Excel的导入导出功能 ** ## 1、导入依赖 ** <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi-ooxml-schemas</artifactId> <version>4.1.2</version> </dependency> <dependency> &lt
java导出excel 工具类_利用poi导出excel的工具类
weixin_39766910的博客
02-25 316
在实际的项目中，经常会有导出到Excel的功能，前阶段研究了下poi导出Excel，自己整理了一个导出的工具类，下面把代码贴出来，大家相互学习学习！工具类import java.io.OutputStream;import java.net.URLEncoder;import javax.servlet.http.HttpServletResponse;import org.apache.poi....
Java POI实现Excel导入通用工具类示例及应用
本文旨在提供一个详细的通用工具类示例，帮助开发者在Java中高效地导入Excel数据。 首先，文章明确了导入Excel的背景，指出通常Java开发中导出Excel功能较为常见，但在实现导入时需要特别注意两点：列数、顺序与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值