备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

【Java用法】使用poi写Java代码导出Excel文档的解决方案

2023-10-14 58
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【Java用法】使用poi写Java代码导出Excel文档的解决方案

【Java用法】使用EasyPoi导入与导出Excel文档的解决方案，这是另外一种方法导入导出文档

第一步：添加Maven依赖

<!--poi的依赖-->
<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi</artifactId>
  <version>3.10.1</version>
</dependency>
<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi-ooxml</artifactId>
  <version>3.10.1</version>
</dependency>

第二步：添加注解

下面是需要导出的实体类，需要添加@ExcelField注解；如果没有，请查看第二步中的一个注解类。

@ApiModel(value = "未提交日报实体")
@Data
public class DailyNoSubmitReport implements Serializable {
    @ApiModelProperty(value = "未提交日报id", example = "1")
    @ExcelField("编号")
    private Integer id;
    @ApiModelProperty(value = "手机号")
    @ExcelField("手机号")
    private String userName;
    @ApiModelProperty(value = "姓名")
    @ExcelField("姓名")
    private String trueName;
    @ApiModelProperty(value = "部门id")
    @ExcelField("部门id")
    private String deptId;
    @ApiModelProperty(value = "部门名称")
    @ExcelField("部门名称")
    private String deptName;
    @ExcelField(value = "未提交日期", dateFormat = "yyyy-MM-dd HH:mm:ss")
    @ApiModelProperty(value = "未提交日期")
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
    private Date noSubmitDate;
    @ExcelField("每周周几")
    @ApiModelProperty(value = "每周周几")
    private String dayOfWeek;
    @ExcelField(value = "创建日期", dateFormat = "yyyy-MM-dd HH:mm:ss")
    @ApiModelProperty(value = "创建日期")
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date createTime;
}

以下是注解类：

package com.iot.daily.annotation;
import java.lang.annotation.*;
/**
 * Description:ExcelField
 *
 * @author Jin
 * @create 2017-4-10
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ExcelField {
    String value() default "";
    String dateFormat() default "";
    boolean isOnlyImport() default false;
    String isNullDefaultValue() default "N/A";
}

第三步：编写导出类

@Override
    public JsonResult exportExcel(User user, QueryParamDTO queryParamDTO) {
        if (user == null) {
            log.error("E|DailyStatisticsServiceImpl|exportExcel()|分页导出Excel日报未提交人员列表时，获取当前登录人失败！");
            return JsonResult.fail("获取当前登录人失败！");
        }
        int pageNum = queryParamDTO.getPageNum();
        int pageSize = queryParamDTO.getPageSize();
        try {
            PageInfo<Object> pageInfo = PageHelper.startPage(pageNum, pageSize).doSelectPageInfo(() ->
                    dailyNoSubmitReportMapper.pageList(queryParamDTO));
            ExcelUtil.exports2007("日报未提交人员列表", pageInfo.getList());
            return JsonResult.ok("导出日报未提交人员列表成功！");
        } catch (Exception e) {
            log.error("E|DailyStatisticsServiceImpl|exportExcel()|分页导出Excel日报未提交人员列表失败！原因 = {}", e.getMessage());
        }
        return JsonResult.fail("分页导出Excel日报未提交人员列表时失败！");
    }

说明：上面导出类中的ExcelUtil工具类可以直接使用。即以下代码：

package com.iot.daily.common.util;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.google.common.collect.Lists;
import com.uiotsoft.daily.account.exception.ApplicationException;
import com.uiotsoft.daily.account.exception.ErrorCode;
import com.uiotsoft.daily.annotation.ExcelField;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
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 org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.beans.PropertyDescriptor;
import java.io.FileInputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.List;
/**
 * Description:
 *
 * @author Jin
 * @create 2017-07-27
 */
public class ExcelUtil {
    public static void exports(String sheetName, List<?> list) {
        if (CollUtil.isEmpty(list)) {
            throw new ApplicationException(ErrorCode.E_100106);
        }
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletResponse response = attributes.getResponse();
        try {
            ServletOutputStream out = response.getOutputStream();
            HSSFWorkbook wb = new HSSFWorkbook();
            HSSFSheet sheet = wb.createSheet(sheetName);
            for (int i = 0; i < list.size(); i++) {
                Object obj = list.get(i);
                Class clazz = obj.getClass();
                if (i == 0) {
                    HSSFRow row = sheet.createRow(i);
                    Field[] fields = clazz.getDeclaredFields();
                    int tmp = 0;
                    for (Field field : fields) {
                        HSSFCell cell = row.createCell(tmp);
                        ExcelField excelFiled = field.getAnnotation(ExcelField.class);
                        // 判断是否只支持导入
                        if (excelFiled == null || excelFiled.isOnlyImport()) {
                            continue;
                        }
                        cell.setCellValue(excelFiled.value());
                        tmp++;
                    }
                }
                HSSFRow row = sheet.createRow(i + 1);
                Field[] fields = clazz.getDeclaredFields();
                int tmp = 0;
                for (Field field : fields) {
                    ExcelField excelFiled = field.getAnnotation(ExcelField.class);
                    if (excelFiled == null || excelFiled.isOnlyImport()) {
                        continue;
                    }
                    HSSFCell cell = row.createCell(tmp);
                    PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
                    Method getMethod = pd.getReadMethod();
                    Object o = getMethod.invoke(obj);
                    if (!StrUtil.isBlank(excelFiled.dateFormat()) && o instanceof Date) {
                        cell.setCellValue(DateUtil.format((Date) o, excelFiled.dateFormat()));
                    } else {
                        cell.setCellValue(ObjectUtil.isNull(o) ? excelFiled.isNullDefaultValue() : String.valueOf(o));
                    }
                    tmp++;
                }
            }
            response.reset();
            response.setHeader("Content-disposition", "attachment;filename=" + new String(sheetName.getBytes("utf-8"), "ISO8859-1") + ".xls");
            response.setContentType("application/msexcel");
            wb.write(out);
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            throw new ApplicationException(ErrorCode.E_100106 + "导出excel失败，【" + e.getMessage() + "】");
        }
    }
    public static void exports2007(String sheetName, List<?> list) {
        if (CollUtil.isEmpty(list)) {
            throw new ApplicationException(ErrorCode.E_100106);
        }
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletResponse response = attributes.getResponse();
        try {
            ServletOutputStream out = response.getOutputStream();
            XSSFWorkbook wb = new XSSFWorkbook();
            XSSFSheet sheet = wb.createSheet(sheetName);
            for (int i = 0; i < list.size(); i++) {
                Object obj = list.get(i);
                Class clazz = obj.getClass();
                if (i == 0) {
                    XSSFRow row = sheet.createRow(i);
                    Field[] fields = clazz.getDeclaredFields();
                    int tmp = 0;
                    for (Field field : fields) {
                        XSSFCell cell = row.createCell(tmp);
                        ExcelField excelFiled = field.getAnnotation(ExcelField.class);
                        if (excelFiled == null || excelFiled.isOnlyImport()) {
                            continue;
                        }
                        cell.setCellValue(excelFiled.value());
                        tmp++;
                    }
                }
                XSSFRow row = sheet.createRow(i + 1);
                Field[] fields = clazz.getDeclaredFields();
                int tmp = 0;
                for (Field field : fields) {
                    ExcelField excelFiled = field.getAnnotation(ExcelField.class);
                    if (excelFiled == null || excelFiled.isOnlyImport()) {
                        continue;
                    }
                    XSSFCell cell = row.createCell(tmp);
                    PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
                    Method getMethod = pd.getReadMethod();
                    Object o = getMethod.invoke(obj);
                    if (!StrUtil.isBlank(excelFiled.dateFormat()) && o instanceof Date) {
                        cell.setCellValue(DateUtil.format((Date) o, excelFiled.dateFormat()));
                    } else {
                        cell.setCellValue(ObjectUtil.isNull(o) ? excelFiled.isNullDefaultValue() : String.valueOf(o));
                    }
                    tmp++;
                }
            }
            response.reset();
            response.setHeader("Content-disposition", "attachment;filename=" + new String(sheetName.getBytes("utf-8"), "ISO8859-1") + ".xlsx");
            response.setContentType("application/msexcel");
            wb.write(out);
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("导出excel失败，[" + e.getMessage() + "]");
        }
    }
    public static <T> List<T> imports(FileInputStream is, Class<T> clazz) {
        List<T> result = Lists.newArrayList();
        try {
            HSSFWorkbook workbook = new HSSFWorkbook(is);
            Sheet sheet = workbook.getSheetAt(0);
            // 获取第0行标题
            Row row0 = sheet.getRow(0);
            // 遍历每一列
            for (int r = 1; r < sheet.getPhysicalNumberOfRows(); r++) {
                T obj = clazz.newInstance();
                Field[] fields = obj.getClass().getDeclaredFields();
                Row row = sheet.getRow(r);
                for (int c = 0; c < row.getPhysicalNumberOfCells(); c++) {
                    for (Field field : fields) {
                        ExcelField excelFiled = field.getAnnotation(ExcelField.class);
                        String title = getCellValue(row0.getCell(c).getCellType(), row0.getCell(c));
                        if (excelFiled == null && !title.equals(excelFiled.value())) {
                            continue;
                        }
                        String cellValue = getCellValue(row.getCell(c).getCellType(), row.getCell(c));
                        PropertyDescriptor pd = new PropertyDescriptor(field.getName(), obj.getClass());
                        if ("错误".equals(cellValue) || field.getType() == String.class) {
                            pd.getWriteMethod().invoke(obj, cellValue);
                            continue;
                        }
                        if (field.getType() == Integer.class) {
                            pd.getWriteMethod().invoke(obj, Integer.parseInt(cellValue));
                            continue;
                        }
                        if (field.getType() == Long.class) {
                            pd.getWriteMethod().invoke(obj, Long.parseLong(cellValue));
                            continue;
                        }
                        if (field.getType() == Float.class) {
                            pd.getWriteMethod().invoke(obj, Float.parseFloat(cellValue));
                            continue;
                        }
                        if (field.getType() == Double.class) {
                            pd.getWriteMethod().invoke(obj, Double.parseDouble(cellValue));
                            continue;
                        }
                        if (field.getType() == Date.class) {
                            pd.getWriteMethod().invoke(obj, DateUtil.parseDate(cellValue));
                        }
                    }
                }
                result.add(obj);
            }
        } catch (Exception e) {
            throw new RuntimeException("导如excel失败,[" + e.getMessage() + "]");
        }
        return result;
    }
    public static <T> List<T> imports2007(FileInputStream is, Class<T> clazz) {
        List<T> result = Lists.newArrayList();
        try {
            XSSFWorkbook workbook = new XSSFWorkbook(is);
            Sheet sheet = workbook.getSheetAt(0);
            // 获取第0行标题
            Row row0 = sheet.getRow(0);
            // 遍历每一列
            for (int r = 1; r < sheet.getPhysicalNumberOfRows(); r++) {
                T obj = clazz.newInstance();
                Field[] fields = obj.getClass().getDeclaredFields();
                Row row = sheet.getRow(r);
                for (int c = 0; c < row.getPhysicalNumberOfCells(); c++) {
                    for (Field field : fields) {
                        ExcelField excelFiled = field.getAnnotation(ExcelField.class);
                        String title = getCellValue(row0.getCell(c).getCellType(), row0.getCell(c));
                        if (excelFiled == null || !title.equals(excelFiled.value())) {
                            continue;
                        }
                        String cellValue = getCellValue(row.getCell(c).getCellType(), row.getCell(c));
                        PropertyDescriptor pd = new PropertyDescriptor(field.getName(), obj.getClass());
                        if ("错误".equals(cellValue) || field.getType() == String.class) {
                            pd.getWriteMethod().invoke(obj, cellValue);
                            continue;
                        }
                        if (field.getType() == Integer.class) {
                            pd.getWriteMethod().invoke(obj, Integer.parseInt(cellValue));
                            continue;
                        }
                        if (field.getType() == Long.class) {
                            pd.getWriteMethod().invoke(obj, Long.parseLong(cellValue));
                            continue;
                        }
                        if (field.getType() == Float.class) {
                            pd.getWriteMethod().invoke(obj, Float.parseFloat(cellValue));
                            continue;
                        }
                        if (field.getType() == Double.class) {
                            pd.getWriteMethod().invoke(obj, Double.parseDouble(cellValue));
                            continue;
                        }
                        if (field.getType() == Date.class) {
                            pd.getWriteMethod().invoke(obj, DateUtil.parseDate(cellValue));
                        }
                    }
                }
                result.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("导如excel失败,[" + e.getMessage() + "]");
        }
        return result;
    }
    public static String getCellValue(int cellType, Cell cell) {
        switch (cellType) {
            // 文本
            case Cell.CELL_TYPE_STRING:
                return cell.getStringCellValue();
            // 数字、日期
            case Cell.CELL_TYPE_NUMERIC:
                if (org.apache.poi.ss.usermodel.DateUtil.isCellDateFormatted(cell)) {
                    // 日期型
                    return DateUtil.formatDate(cell.getDateCellValue());
                } else {
                    // 数字
                    return String.valueOf(cell.getNumericCellValue());
                }
                // 布尔型
            case Cell.CELL_TYPE_BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            // 空白
            case Cell.CELL_TYPE_BLANK:
                return cell.getStringCellValue();
            // 错误
            case Cell.CELL_TYPE_ERROR:
                return "错误";
            // 公式
            case Cell.CELL_TYPE_FORMULA:
                return "错误";
            default:
                return "错误";
        }
    }
    /*public static void main(String[] args) {
        File file = new File("E:\\123.xlsx");
        try {
            FileInputStream inputStream = new FileInputStream(file);
            List<TCmsContent> list = imports2007(inputStream, TCmsContent.class);
            System.out.println(list.get(0).getTitle());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }*/
}

完结！


文章标签：
Java
Maven
关键词：
excel导出
Java文档
Java用法
Java代码
Java解决方案
No8g攻城狮
目录
相关文章
技术君
|
15天前
|
Java 测试技术 应用服务中间件
常见 Java 代码缺陷及规避方式（下）
常见 Java 代码缺陷及规避方式（下）
技术君
43 0
舒一笑
|
17天前
|
Java
Java中ReentrantLock释放锁代码解析
Java中ReentrantLock释放锁代码解析
舒一笑
25 8
java开发-郭老师
|
18天前
|
Java
Java 字符串分割split空字符串丢失解决方案
Java 字符串分割split空字符串丢失解决方案
java开发-郭老师
15 0
念广隶
|
19天前
|
Java
Java中的抽象类：深入了解抽象类的概念和用法
Java中的抽象类是一种不能实例化的特殊类，常作为其他类的父类模板，定义子类行为和属性。抽象类包含抽象方法（无实现）和非抽象方法。定义抽象类用`abstract`关键字，子类继承并实现抽象方法。抽象类适用于定义通用模板、复用代码和强制子类实现特定方法。优点是提供抽象模板和代码复用，缺点是限制继承灵活性和增加类复杂性。与接口相比，抽象类可包含成员变量和单继承。使用时注意设计合理的抽象类结构，谨慎使用抽象方法，并遵循命名规范。抽象类是提高代码质量的重要工具。
念广隶
33 1
Y2000104
|
20天前
|
前端开发 小程序 Java
uniapp上传图片 前端以及java后端代码实现
uniapp上传图片 前端以及java后端代码实现
Y2000104
33 0
喜欢猪猪
|
21天前
|
设计模式 存储 Java
23种设计模式，享元模式的概念优缺点以及JAVA代码举例
【4月更文挑战第6天】享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享技术有效地支持大量细粒度对象的重用。这个模式在处理大量对象时非常有用，特别是当这些对象中的许多实例实际上可以共享相同的状态时，从而可以减少内存占用，提高程序效率
喜欢猪猪
35 4
喜欢猪猪
|
22天前
|
设计模式 Java 中间件
23种设计模式，适配器模式的概念优缺点以及JAVA代码举例
【4月更文挑战第6天】适配器模式（Adapter Pattern）是一种结构型设计模式，它的主要目标是让原本由于接口不匹配而不能一起工作的类可以一起工作。适配器模式主要有两种形式：类适配器和对象适配器。类适配器模式通过继承来实现适配，而对象适配器模式则通过组合来实现
喜欢猪猪
31 4
桃李春风一杯酒
|
22天前
|
存储 缓存 算法
优化 Java 后台代码的关键要点
【4月更文挑战第5天】本文探讨了优化 Java 后台代码的关键点，包括选用合适的数据结构与算法、减少不必要的对象创建、利用 Java 8 新特性、并发与多线程处理、数据库和缓存优化、代码分析与性能调优、避免阻塞调用、JVM 调优以及精简第三方库。通过这些方法，开发者可以提高系统性能、降低资源消耗，提升用户体验并减少运营成本。
桃李春风一杯酒
31 14
tangrg
|
8天前
|
easyexcel 数据库
公司大佬对excel导入、导出的封装，那叫一个秒啊
封装公司统一使用的组件的主要目标是为了简化开发人员的调用流程，避免各个项目组重复集成和编写不规范的代码。文中提到对阿里EasyExcel进行了二次封装，提供了导入和导出功能，并支持模板的导入和导出。此外，还处理了读取数据与实际保存数据不一致的情况，通过提供自定义转换器来解决。
tangrg
27 0
xiaohua616
|
8天前
|
JSON Java 数据格式
Java QueryWrapper基本用法
Java QueryWrapper基本用法
xiaohua616
13 2

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
  • 3
    使用Java代码打印log日志
  • 4
    Java数据结构与算法-java数据结构与算法（二）
  • 5
    【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍（一）
  • 6
    深入理解Java并发编程：线程安全与性能优化
  • 7
    Java入门高频考查基础知识4（字节跳动面试题18题2.5万字参考答案）
  • 8
    开发语言详解（python、java、Go(Golong)。。。。）
  • 9
    《理解 WebSocket：Java Web 开发的实时通信技术》
  • 10
    java线程池讲解面试
  • 1
    使用AOP+反射实现Excel数据的读取
    20
  • 2
    使用Python批量合并Excel文件的所有Sheet数据
    33
  • 3
    盘点CSV文件在Excel中打开后乱码问题的两种处理方法
    163
  • 4
    使用openpyxl库从Excel文件中提取指定的数据并生成新的文件
    29
  • 5
    用Python实现Excel中的Vlookup功能
    32
  • 6
    4种方法用Python批量实现多Excel多Sheet合并
    39
  • 7
    Python中导入Excel数据：全面解析与实践
    42
  • 8
    使用SQL和Python处理Excel文件数据
    54
  • 9
    Python操作Excel常用方法汇总
    35
  • 10
    Python导入Excel数据到MySQL数据库
    93

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）