一、POI方法导出Excel文件
meven包：
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>3.17</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml-schemas</artifactId>
<version>3.17</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>3.17</version>
</dependency>二、 POI HSSF API组件详解
HSSF（用于操作Excel的组件）提供给用户使用的对象在rg.apache.poi.hssf.usermodel包中,主要部分包括Excel对象，样式和格式，还有辅助操作。有以下几种对象：
常用组件：
HSSFWorkbook excel的文档对象
HSSFSheet excel的表单
HSSFRow excel的行
HSSFCell excel的格子单元
HSSFFont excel字体
HSSFDataFormat 日期格式
HSSFHeader sheet头
HSSFFooter sheet尾（只有打印的时候才能看到效果）
样式：
HSSFCellStyle cell样式
辅助操作包括：
HSSFDateUtil 日期
HSSFPrintSetup 打印
HSSFErrorConstants 错误信息表
三、输出到本地
@Test
public void excelPoi1(HttpServletResponse response) throws IOException {
//创建HSSFWorkbook对象(excel的文档对象)
HSSFWorkbook wb = new HSSFWorkbook();
//建立新的sheet对象（excel的表单）
HSSFSheet sheet = wb.createSheet("成绩表");
//在sheet里创建第一行，参数为行索引(excel的行)，可以是0～65535之间的任何一个
HSSFRow row1 = sheet.createRow(0);
//创建单元格（excel的单元格，参数为列索引，可以是0～255之间的任何一个
HSSFCell cell = row1.createCell(0);
//设置单元格内容
cell.setCellValue("学员考试成绩一览表");
//合并单元格CellRangeAddress构造参数依次表示 起始行，截至行，起始列， 截至列
sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 3));
//设置单元格格式
HSSFCellStyle cellStyle = wb.createCellStyle();
HSSFFont fontStyle=wb.createFont();
//设置字体样式
fontStyle.setFontName("黑体");
//设置字体高度
fontStyle.setFontHeightInPoints((short)20);
//设置一个字体的颜色
//2表示红色
//3表示绿色
//4表示蓝色
//5表示黄色
//6表示紫色
//7表示亮蓝色
//8表示黑色
//9表示白色
fontStyle.setColor((short) 6);
//设置斜体
fontStyle.setItalic(false);
//设置下划线
fontStyle.setUnderline(HSSFFont.U_SINGLE);
//设置粗体
fontStyle.setBold(true);
//设置日期型数据的显示样式
cellStyle.setDataFormat(HSSFDataFormat.getBuiltinFormat("m/d/yy h:mm"));
//设置背景颜色
cellStyle.setFillForegroundColor((short) 13);
cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
// 将字体对象赋值给单元格样式对象
cellStyle.setFont(fontStyle);
// 将单元格样式应用于单元格
cell.setCellStyle(cellStyle);
//在sheet里创建第二行
HSSFRow row2 = sheet.createRow(1);
//创建单元格并设置单元格内容
row2.createCell(0).setCellValue("姓名");
row2.createCell(1).setCellValue("班级");
row2.createCell(2).setCellValue("笔试成绩");
row2.createCell(3).setCellValue("机试成绩");
//在sheet里创建第三行
HSSFRow row3 = sheet.createRow(2);
row3.createCell(0).setCellValue("李明");
row3.createCell(1).setCellValue("As178");
row3.createCell(2).setCellValue(87);
row3.createCell(3).setCellValue(78);
//将文件输出本地
FileOutputStream output=new FileOutputStream("e:\\workbook2.xls");
wb.write(output);
output.flush();
System.out.println("ok");
//----------------------------------下面是上线后自定义位置--------------
//输出Excel文件
OutputStream output=response.getOutputStream();
response.reset();
String s = formName + ".xls"; //设置表名字
//设置响应头，
response.setHeader("Content-Disposition", "attachment;filename="+new String(s.getBytes("utf-8"),"iso8859-1"));
response.setContentType("application/ynd.ms-excel;charset=UTF-8");
wb.write(output);
output.close();
}
读取excel
实现将已存在的Excel文件中的数据导入到系统中的基本步骤同导出十分的类似，关键在于要了解要导入Excel文件的结构，比如数据有哪些列、读取数据起始位置（有效数据从第几行几列开始）等。
//解析Excel
public static void main(String[] args)throws IOException {
//解析Excel
List temp = new ArrayList();
FileInputStream fileIn = new FileInputStream("D:\\sql\\工单注销.xls");
//根据指定的文件输入流导入Excel从而产生Workbook对象
XSSFWorkbook xssfWorkbook = new XSSFWorkbook(fileIn);
//获取Excel文档中的第一个表单
Sheet sht0 = xssfWorkbook.getSheetAt(0);
//对Sheet中的每一行进行迭代
for (Row r : sht0) {
System.out.println("第" + r.getRowNum() + "行-----------");
//如果当前行的行号（从0开始）未达到2（第三行）则从新循环
if (r.getRowNum() < 1) {
continue;
}
System.out.println("r.getRowNum() = " + r.getRowNum());
//---------------------------------------------------------
for (int i = 0; i < 7; i++) {
Cell cell = sht0.getRow(r.getRowNum()).getCell(i);
if (cell == null) {
continue;
}
cell.setCellType(CellType.STRING);//定义字段类型为string
//取出当前行第i个单元格数据
String stringCellValue = r.getCell(i).getStringCellValue();
System.out.println(i + ":" + stringCellValue);
}
}
}POI导出word文档：
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.math.BigInteger;
import java.util.List;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.xwpf.usermodel.ParagraphAlignment;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFRun;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STJc;
public class DCcontroller {
/**
* 导出word
* @author ygc
*/
public static void main(String[] args) throws IOException, InvalidFormatException {
XWPFDocument document = new XWPFDocument();
//这行代码是创建标题
XWPFParagraph title = document.createParagraph();
//设置段落居中
title.setAlignment(ParagraphAlignment.valueOf(STJc.INT_CENTER));
// //设置段落左对齐
// title.setAlignment(ParagraphAlignment.valueOf(STJc.INT_LEFT));
// //设置段落右对齐
// title.setAlignment(ParagraphAlignment.valueOf(STJc.INT_RIGHT));
XWPFRun titleRun = title.createRun();
// titleRun.setColor("00000");
titleRun.setFontSize(20);
titleRun.setFontFamily("宋体");
titleRun.setBold(true);
titleRun.setText("浙江省体育局关于拟授予灵运等42人宝藏男孩称号进行公示的通知");
titleRun.addBreak(); //换行
//添加第一个段落
XWPFParagraph paragraph1 = document.createParagraph();
//设置之段落左对齐
paragraph1.setAlignment(ParagraphAlignment.valueOf(STJc.INT_LEFT));
// ---------以上是设置整段的，以下为设置内容
XWPFRun firstRun = paragraph1.createRun();
firstRun.setFontSize(13);
firstRun.setFontFamily("黑体");
firstRun.addTab();
firstRun.setText("各市体育局、各有关训练单位:" +
"根据《运动员技术等级管理办法》的规定，现对拟授予灵运等42人宝藏男孩称号(具体名单见附件)进行公示。公示期为2021年12月28日-2022年1月6日(七个工作日)。");
firstRun.addBreak(); //换行
firstRun.addTab();
firstRun.setText("公示期内，如对上述名单有异议，任何单位和个人均可以电话、书面或其他形式向省体育局机关纪委和体育竞赛处反映问题的，需加盖单位公章；以个人名义反映问题的，需署名或当面反映。");
firstRun.addBreak(); //换行
//添加第二个段落
XWPFParagraph paragraph2 = document.createParagraph();
paragraph2.setAlignment(ParagraphAlignment.valueOf(STJc.INT_CENTER));
// ---------以上是设置整段的，以下为设置内容
XWPFRun firstRun1 = paragraph2.createRun();
firstRun1.setFontSize(17);
firstRun1.setFontFamily("黑体");
firstRun1.addTab();
firstRun1.setText("拟授予宝藏男孩称号人员名单");
OutputStream os = new FileOutputStream("D:\\wordTest.doc");
document.write(os);
if(os!=null){
try{
os.close();
System.out.println("文件已输出！");
}
catch(IOException e){
e.printStackTrace();
}
}
}
}
结果：
(一)基于注解的Excel导出
依赖：
<dependency>
<groupId>cn.afterturn</groupId>
<artifactId>easypoi-base</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>cn.afterturn</groupId>
<artifactId>easypoi-web</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>cn.afterturn</groupId>
<artifactId>easypoi-annotation</artifactId>
<version>4.1.2</version>
</dependency>
<!--Swagger-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.7.0</version>
</dependency>
<!--Swagger ui-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.7.0</version>
</dependency>
配置Excel注解
package com.ex.config;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 自定义导出Excel数据注解
*
* @author sunziwen
* @version 1.0
* @date 2018-12-29 15:00
**/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Excel {
/**
* 导出到Excel中的名字.
*/
public String name();
/**
* 日期格式, 如: yyyy-MM-dd
*/
public String dateFormat() default "";
/**
* 读取内容转表达式 (如: 0=男,1=女,2=未知)
*/
public String readConverterExp() default "";
/**
* 导出时在excel中每个列的高度 单位为字符
*/
public double height() default 14;
/**
* 导出时在excel中每个列的宽 单位为字符
*/
public double width() default 20;
/**
* 文字后缀,如% 90 变成90%
*/
public String suffix() default "";
/**
* 当值为空时,字段的默认值
*/
public String defaultValue() default "";
/**
* 提示信息
*/
public String prompt() default "";
/**
* 设置只能选择不能输入的列内容.
*/
public String[] combo() default {};
/**
* 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写.
*/
public boolean isExport() default true;
}配置ExcelUtil操作类
package com.ex.utis;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.servlet.http.HttpServletResponse;
import com.ex.config.Excel;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.DVConstraint;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFDataValidation;
import org.apache.poi.hssf.usermodel.HSSFFont;
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.CellType;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.VerticalAlignment;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.apache.poi.ss.util.CellRangeAddressList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Excel相关操作
*
* @author sunziwen
* @version 1.0
* @date 2022-03-25 15:20
**/
public class ExcelUtil<T> {
private static final Logger log = LoggerFactory.getLogger(ExcelUtil.class);
private Class<T> clazz;
public ExcelUtil(Class<T> clazz) {
this.clazz = clazz;
}
/**
* 对excel表单默认第一个索引名转换成list
*
* @param input 输入流
* @return 转换后集合
*/
public List<T> importExcel(InputStream input) throws Exception {
return importExcel(StringUtils.EMPTY, input);
}
/**
* 对excel表单指定表格索引名转换成list
*
* @param sheetName 表格索引名
* @param input 输入流
* @return 转换后集合
*/
public List<T> importExcel(String sheetName, InputStream input) throws Exception {
List<T> list = new ArrayList<T>();
Workbook workbook = WorkbookFactory.create(input);
Sheet sheet = null;
if (StringUtils.isNotEmpty(sheetName)) {
// 如果指定sheet名,则取指定sheet中的内容.
sheet = workbook.getSheet(sheetName);
} else {
// 如果传入的sheet名不存在则默认指向第1个sheet.
sheet = workbook.getSheetAt(0);
}
if (sheet == null) {
throw new IOException("文件sheet不存在");
}
int rows = sheet.getPhysicalNumberOfRows();
if (rows > 0) {
// 默认序号
// int serialNum = 0;
// 有数据时才处理 得到类的所有field.
Field[] allFields = clazz.getDeclaredFields();
/**
* 这里是要将实体类的属性与excel表的列序号对应上，有两种方式：
* 1.按照先后顺序进行一一对应。
* 2.按照注解的name值与表头对应起来
*/
// 定义一个map用于存放列的序号和field.
Map<Integer, Field> fieldsMap = new HashMap<Integer, Field>();
//定义一个name到Excel表的index的映射Map
HashMap<String, Integer> name2index = new HashMap<>();
//默认第一行是表头
Row r = sheet.getRow(0);
for (int i = 0; i < allFields.length; i++) {
Cell cell = r.getCell(i);
if (cell == null) {
continue;
} else {
// 先设置Cell的类型，然后就可以把纯数字作为String类型读进来了
r.getCell(i).setCellType(CellType.STRING);
cell = r.getCell(i);
String c = cell.getStringCellValue();
if (StringUtils.isEmpty(c)) {
continue;
}
name2index.put(c, i);
}
}
for (int col = 0; col < allFields.length; col++) {
Field field = allFields[col];
// 将有注解的field存放到map中.
if (field.isAnnotationPresent(Excel.class)) {
Excel excel = field.getAnnotation(Excel.class);
String name = excel.name();
Integer index = name2index.get(name);
if (index != null) {
field.setAccessible(true);
fieldsMap.put(index, field);
}
}
}
//下面这个是按序号一一对应的。不太友好，还是按照表头名称来对应
// for (int col = 0; col < allFields.length; col++) {
// Field field = allFields[col];
// // 将有注解的field存放到map中.
// if (field.isAnnotationPresent(Excel.class)) {
// // 设置类的私有字段属性可访问.
// field.setAccessible(true);
// fieldsMap.put(++serialNum, field);
// }
// }
for (int i = 1; i < rows; i++) {
// 从第2行开始取数据,默认第一行是表头.
Row row = sheet.getRow(i);
int cellNum = allFields.length;
T entity = null;
for (int j = 0; j < cellNum; j++) {
Cell cell = row.getCell(j);
if (cell == null) {
continue;
} else {
// 先设置Cell的类型，然后就可以把纯数字作为String类型读进来了
row.getCell(j).setCellType(CellType.STRING);
cell = row.getCell(j);
}
String c = cell.getStringCellValue();
if (StringUtils.isEmpty(c)) {
continue;
}
// 如果不存在实例则新建.
entity = (entity == null ? clazz.newInstance() : entity);
// 从map中得到对应列的field.
Field field = fieldsMap.get(j);
// 取得类型,并根据对象类型设置值.
Class<?> fieldType = field.getType();
if (String.class == fieldType) {
field.set(entity, String.valueOf(c));
} else if ((Integer.TYPE == fieldType) || (Integer.class == fieldType)) {
field.set(entity, Integer.parseInt(c));
} else if ((Long.TYPE == fieldType) || (Long.class == fieldType)) {
field.set(entity, Long.valueOf(c));
} else if ((Float.TYPE == fieldType) || (Float.class == fieldType)) {
field.set(entity, Float.valueOf(c));
} else if ((Short.TYPE == fieldType) || (Short.class == fieldType)) {
field.set(entity, Short.valueOf(c));
} else if ((Double.TYPE == fieldType) || (Double.class == fieldType)) {
field.set(entity, Double.valueOf(c));
} else if (Character.TYPE == fieldType) {
if ((c != null) && (c.length() > 0)) {
field.set(entity, Character.valueOf(c.charAt(0)));
}
} else if (Date.class == fieldType) {
//对字符串解析成日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = cell.getStringCellValue()
.replaceAll("/", "-")
.replaceAll("上午", "")
.replaceAll("下午", "")
.replaceAll(" ", " ");
System.out.println("----------------------------:" + s);
Date parse = sdf.parse(s);
field.set(entity, parse);
// if (cell.getCellTypeEnum() == CellType.NUMERIC) {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// cell.setCellValue(sdf.format(cell.getNumericCellValue()));
// c = sdf.format(cell.getNumericCellValue());
// } else {
// c = cell.getStringCellValue();
// }
} else if (java.math.BigDecimal.class == fieldType) {
c = cell.getStringCellValue();
}
}
if (entity != null) {
list.add(entity);
}
}
}
return list;
}
/**
* 对list数据源将其里面的数据导入到excel表单
* 针对List<Map>类型的数据
*
* @param list 导出数据集合
* @param sheetName 工作表的名称
* @return 结果
*/
public static void exportMapExcel(List<Map> list, String[] title, String sheetName, HttpServletResponse response) {
if (null == list || list.size() == 0) {
return;
}
HSSFWorkbook workbook = null;
try {
// 产生工作薄对象
workbook = new HSSFWorkbook();
// excel2003中每个sheet中最多有65536行
int sheetSize = 65536;
// 取出一共有多少个sheet.
double sheetNo = Math.ceil(list.size() / sheetSize);
for (int index = 0; index <= sheetNo; index++) {
// 产生工作表对象
HSSFSheet sheet = workbook.createSheet();
if (sheetNo == 0) {
workbook.setSheetName(index, sheetName);
} else {
// 设置工作表的名称.
workbook.setSheetName(index, sheetName + index);
}
HSSFRow row;
HSSFCell cell; // 产生单元格
// 产生第一行，写入标题
row = sheet.createRow(0);
if (null == title || title.length == 0) {
throw new RuntimeException("导出错误");
}
for (int i = 0; i < title.length; i++) {
cell = row.createCell(i);
cell.setCellType(CellType.STRING);
cell.setCellValue(title[i]);
}
int cell_idx = 0;
int startNo = index * sheetSize;
int endNo = Math.min(startNo + sheetSize, list.size());
// 写入各条记录,每条记录对应excel表中的一行
for (int i = startNo; i < endNo; i++) {
row = sheet.createRow(i + 1 - startNo);
// 得到导出对象.
Map map = list.get(i);
Set keySet = map.keySet();
Iterator values = keySet.iterator();
cell_idx = 0;
while (values.hasNext()) {
Object value = map.get(values.next());
cell = row.createCell(cell_idx);
cell.setCellValue(value.toString());
cell_idx++;
}
}
}
//String filename = encodingFilename(sheetName);
response.setHeader("content-Type", "application/vnd.ms-excel");
response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(sheetName, "UTF-8"));
// response.setContentType("application/octet-stream");
// response.setHeader("Content-disposition", "attachment;filename=" + URLEncoder.encode(filename, "UTF-8"));
response.flushBuffer();
workbook.write(response.getOutputStream());
//return filename;
} catch (Exception e) {
log.error("导出Excel异常{}", e.getMessage());
throw new RuntimeException("导出Excel失败，请联系网站管理员！");
} finally {
if (workbook != null) {
try {
workbook.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
/**
* 对list数据源将其里面的数据导入到excel表单
*
* @param list 导出数据集合
* @param sheetName 工作表的名称
* @return 结果
*/
public void exportExcel(List<?> list, String sheetName, HttpServletResponse response) {
HSSFWorkbook workbook = null;
try {
// 得到所有定义字段
Field[] allFields = clazz.getDeclaredFields();
List<Field> fields = new ArrayList<Field>();
// 得到所有field并存放到一个list中.
for (Field field : allFields) {
if (field.isAnnotationPresent(Excel.class)) {
fields.add(field);
}
}
// 产生工作薄对象
workbook = new HSSFWorkbook();
// excel2003中每个sheet中最多有65536行
int sheetSize = 65536;
// 取出一共有多少个sheet.
double sheetNo = Math.ceil(list.size() / sheetSize);
for (int index = 0; index <= sheetNo; index++) {
// 产生工作表对象
HSSFSheet sheet = workbook.createSheet();
if (sheetNo == 0) {
workbook.setSheetName(index, sheetName);
} else {
// 设置工作表的名称.
workbook.setSheetName(index, sheetName + index);
}
HSSFRow row;
HSSFCell cell; // 产生单元格
// 产生一行
row = sheet.createRow(0);
// 写入各个字段的列头名称
for (int i = 0; i < fields.size(); i++) {
Field field = fields.get(i);
Excel attr = field.getAnnotation(Excel.class);
// 创建列
cell = row.createCell(i);
// 设置列中写入内容为String类型
cell.setCellType(CellType.STRING);
HSSFCellStyle cellStyle = workbook.createCellStyle();
cellStyle.setAlignment(HorizontalAlignment.CENTER);
cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
if (attr.name().indexOf("注：") >= 0) {
HSSFFont font = workbook.createFont();
font.setColor(HSSFFont.COLOR_RED);
// cellStyle.setFont(font);
//设置颜色
// cellStyle.setFillForegroundColor(HSSFColor.HSSFColorPredefined.YELLOW.getIndex());
sheet.setColumnWidth(i, 6000);
} else {
HSSFFont font = workbook.createFont();
// 粗体显示
font.setBold(true);
// 选择需要用到的字体格式
// cellStyle.setFont(font);
//设置颜色
// cellStyle.setFillForegroundColor(HSSFColor.HSSFColorPredefined.LIGHT_YELLOW.getIndex());
// 设置列宽
sheet.setColumnWidth(i, (int) ((attr.width() + 0.72) * 256));
row.setHeight((short) (attr.height() * 20));
}
// cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
// cellStyle.setWrapText(true);
cell.setCellStyle(cellStyle);
// 写入列名
cell.setCellValue(attr.name());
// 如果设置了提示信息则鼠标放上去提示.
if (StringUtils.isNotEmpty(attr.prompt())) {
// 这里默认设了2-101列提示.
setHSSFPrompt(sheet, "", attr.prompt(), 1, 100, i, i);
}
// 如果设置了combo属性则本列只能选择不能输入
if (attr.combo().length > 0) {
// 这里默认设了2-101列只能选择不能输入.
setHSSFValidation(sheet, attr.combo(), 1, 100, i, i);
}
}
int startNo = index * sheetSize;
int endNo = Math.min(startNo + sheetSize, list.size());
// 写入各条记录,每条记录对应excel表中的一行
HSSFCellStyle cs = workbook.createCellStyle();
cs.setAlignment(HorizontalAlignment.CENTER);
cs.setVerticalAlignment(VerticalAlignment.CENTER);
for (int i = startNo; i < endNo; i++) {
row = sheet.createRow(i + 1 - startNo);
// 得到导出对象.
T vo = (T) list.get(i);
for (int j = 0; j < fields.size(); j++) {
// 获得field.
Field field = fields.get(j);
// 设置实体类私有属性可访问
field.setAccessible(true);
Excel attr = field.getAnnotation(Excel.class);
try {
// 设置行高
row.setHeight((short) (attr.height() * 20));
// 根据Excel中设置情况决定是否导出,有些情况需要保持为空,希望用户填写这一列.
if (attr.isExport()) {
// 创建cell
cell = row.createCell(j);
cell.setCellStyle(cs);
if (vo == null) {
// 如果数据存在就填入,不存在填入空格.
cell.setCellValue("");
continue;
}
String dateFormat = attr.dateFormat();
String readConverterExp = attr.readConverterExp();
if (StringUtils.isNotEmpty(dateFormat)) {
cell.setCellValue(new SimpleDateFormat(dateFormat).format((Date) field.get(vo)));
} else if (StringUtils.isNotEmpty(readConverterExp)) {
cell.setCellValue(convertByExp(String.valueOf(field.get(vo)), readConverterExp));
} else {
cell.setCellType(CellType.STRING);
// 如果数据存在就填入,不存在填入空格.
cell.setCellValue(field.get(vo) == null ? attr.defaultValue() : field.get(vo) + attr.suffix());
}
}
} catch (Exception e) {
log.error("导出Excel失败{}", e.getMessage());
}
}
}
}
//String filename = encodingFilename(sheetName);
response.setContentType("application/octet-stream");
response.setHeader("Content-disposition", "attachment;filename=" + URLEncoder.encode(sheetName, "UTF-8"));
response.flushBuffer();
workbook.write(response.getOutputStream());
} catch (Exception e) {
log.error("导出Excel异常{}", e.getMessage());
throw new RuntimeException("导出Excel失败，请联系网站管理员！");
} finally {
if (workbook != null) {
try {
workbook.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
/**
* 设置单元格上提示
*
* @param sheet 要设置的sheet.
* @param promptTitle 标题
* @param promptContent 内容
* @param firstRow 开始行
* @param endRow 结束行
* @param firstCol 开始列
* @param endCol 结束列
* @return 设置好的sheet.
*/
private static HSSFSheet setHSSFPrompt(HSSFSheet sheet, String promptTitle, String promptContent, int firstRow,
int endRow, int firstCol, int endCol) {
// 构造constraint对象
DVConstraint constraint = DVConstraint.createCustomFormulaConstraint("DD1");
// 四个参数分别是：起始行、终止行、起始列、终止列
CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
// 数据有效性对象
HSSFDataValidation dataValidationView = new HSSFDataValidation(regions, constraint);
dataValidationView.createPromptBox(promptTitle, promptContent);
sheet.addValidationData(dataValidationView);
return sheet;
}
/**
* 设置某些列的值只能输入预制的数据,显示下拉框.
*
* @param sheet 要设置的sheet.
* @param textlist 下拉框显示的内容
* @param firstRow 开始行
* @param endRow 结束行
* @param firstCol 开始列
* @param endCol 结束列
* @return 设置好的sheet.
*/
private static HSSFSheet setHSSFValidation(HSSFSheet sheet, String[] textlist, int firstRow, int endRow,
int firstCol, int endCol) {
// 加载下拉列表内容
DVConstraint constraint = DVConstraint.createExplicitListConstraint(textlist);
// 设置数据有效性加载在哪个单元格上,四个参数分别是：起始行、终止行、起始列、终止列
CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
// 数据有效性对象
HSSFDataValidation dataValidationList = new HSSFDataValidation(regions, constraint);
sheet.addValidationData(dataValidationList);
return sheet;
}
/**
* 解析导出值 0=男,1=女,2=未知
*
* @param propertyValue 参数值
* @param converterExp 翻译注解
* @return 解析后值
* @throws Exception
*/
private static String convertByExp(String propertyValue, String converterExp) throws Exception {
try {
String[] convertSource = converterExp.split(",");
for (String item : convertSource) {
String[] itemArray = item.split("=");
if (itemArray[0].equals(propertyValue)) {
return itemArray[1];
}
}
} catch (Exception e) {
throw e;
}
return propertyValue;
}
/**
* 编码文件名
*/
/*private static String encodingFilename(String filename) {
filename = UUID.randomUUID().toString() + "_" + filename + ".xls";
return filename;
}*/
}基于@Excel的注解进行配置文档的字段信息
package com.ex.pojo;
import com.ex.config.Excel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.time.LocalDateTime;
/**
* (User)表实体类
*
* @author suzniwen
* @since 2021-04-13 16:11:55
*/
@SuppressWarnings("serial")
@Accessors(chain = true)
@Data
public class User {
@Excel(name = "编号")
@ApiModelProperty(value = "主键")
private String id;
@Excel(name = "账号")
@ApiModelProperty(value = "账号")
private String loginName;
@Excel(name = "用户名")
@ApiModelProperty(value = "用户名")
private String userName;
@ApiModelProperty(value = "用户名拼音")
private String namePinyin;
@Excel(name = "性别", readConverterExp = "1=男,0=女")
@ApiModelProperty(value = "性别")
private String gender;
@Excel(name = "证件类型",readConverterExp="1=居民身份证,2=香港居民来往内地通行证,3=澳门居民来往内地通行证,4=台湾居民来往大陆通行证,6=护照")
@ApiModelProperty(value = "证件类型")
private String credType;
@Excel(name = "证件号码")
@ApiModelProperty(value = "证件号码")
private String credNum;
@ApiModelProperty(value = "机构id")
private String orgId;
@Excel(name = "机构名称")
@ApiModelProperty(value = "机构名称")
private String orgName;
@Excel(name = "电话")
@ApiModelProperty(value = "电话")
private String phone;
@Excel(name = "邮箱")
@ApiModelProperty(value = "邮箱")
private String email;
@Excel(name = "人员类型",readConverterExp = "student=学生,teacher=教师,parent=家长,system=系统人员,developers=开发者,manager=管理员")
@ApiModelProperty(value = "人员类型")
private String personType;
@Excel(name = "应用系统角色编码")
@ApiModelProperty(value = "应用系统角色编码")
private String appRoleCode;
@ApiModelProperty(value = "创建时间")
private LocalDateTime createTime;
@ApiModelProperty(value = "更新时间")
private LocalDateTime updateTime;
}Controller调用测试
package com.ex.controller;
import com.ex.pojo.User;
import com.ex.utis.ExcelUtil;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
@RestController
public class TestController {
@GetMapping("/export")
@ResponseBody //导出excle
public void export(HttpServletResponse response) {
ExcelUtil<User> excelUtil = new ExcelUtil<>(User.class);
User user = new User();
user.setId("123").setEmail("123456789").setCredType("好好哄");
//要导出的数据集
List<User> list =new ArrayList<>();
list.add(user);
excelUtil.exportExcel(list, "userInformation.xlsx",response);
}
@PostMapping("/DoExport")
@ResponseBody //读取excle
public void DoExport(@RequestParam(name = "file", required = false) MultipartFile file) throws Exception {
ExcelUtil<User> excelUtil = new ExcelUtil<>(User.class);
List<User> users = excelUtil.importExcel( file.getInputStream());
for (User user :users){
String id = user.getId();
System.out.println("id = " + id);
}
}
}
导出成功
读取成功：
读取execl表格中的日期，进行转换
转换年月
public static String DateToNormal(String number) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Date setupTime = HSSFDateUtil.getJavaDate(Double.valueOf(number));//重要
String f = df.format(setupTime);
System.out.println("转换过后的日期："+f);
return f;
}转换时间
public static String Time(Double times){
Date date = HSSFDateUtil.getJavaDate(times);
System.out.println(date);
//Unix时间戳
long time = date.getTime();
System.out.println(time);
//自定义格式化
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
String format = sdf.format(time);
System.out.println("转换后的时间 = " + format);
return format;
}进行替换word文档中的内容以及替换图片
采用的是poi中的XWPFDocument，既可以替换文字，也可以替换成图片，对于表格数据，或者段落数据都可以使用。比HWPFDocument方便，HWPFDocument替换文字更合适便捷，对于图片无法替换只能读取
以下是翻阅很多文章整理出来的，同时替换表格和段落的代码
public static void main(String[] args) throws Exception {
try {
// 导入文档模板
XWPFDocument doc = openDocx("D:\\var\\uploaded_files\\syqyqjbd.docx");
if (doc != null) {
// 文本类 key-value
Map<String, String> params = new HashMap<>();
params.put("name", "厉害的人物");
params.put("sex", "男");
params.put("title", "9999999999999999999999999");
// 图片类 key-url
List<Map<String, String>> picParamsList = new ArrayList<>();
Map<String, String> picParams = new HashMap<>();
picParams.put("${pic}", "D:\\var\\uploaded_files\\123.png");
picParamsList.add(picParams);
List<XWPFParagraph> paragraphs = doc.getParagraphs();
replaceText(paragraphs,params,picParamsList);
// 获取文档对象所有子元素
List<IBodyElement> ibs = doc.getBodyElements();
for (IBodyElement ib : ibs) {
// 读取的文档对象类型判断是否是表格
if (ib.getElementType() == BodyElementType.TABLE) {
// 替换表格
replaceTable(ib, params);
}
}
// 输出文档
writeDocx(doc, new FileOutputStream("D:\\var\\uploaded_files\\test.docx"));
} else {
System.out.println("文档对象为空");
}
}catch (IOException e){
e.printStackTrace();
}
}
//进行“段落”替换文本
private static void replaceText(List<XWPFParagraph> paragraphs,Map<String, String> params, List<Map<String, String>> picParamsList){
for (XWPFParagraph paragraph : paragraphs) {
List<XWPFRun> runs = paragraph.getRuns();
for (XWPFRun run : runs) {
String text = run.getText(0);
for (String picKey : params.keySet()) {
if (text != null && text.contains(picKey)) {
text = text.replace(picKey, params.get(picKey));
run.setText(text, 0);
}
}
//大于0说明要替换图片
if (picParamsList.size() > 0) {
if (text != null && text.contains("${pic}")) {
run.setText("", 0);
for (Map<String, String> map : picParamsList) {
// 替换图片
try {
replacePic(run, map.get("${pic}"));
} catch (Exception e) {
System.out.println("e = " + e);
}
}
}
}
}
}
}
/**
* @param ib 文档中的子元素
* @param params 文档模板中的参数
* @return void
* */
private static void replaceTable(IBodyElement ib, Map<String, String> params) throws Exception {
XWPFTable table;
List<XWPFTableRow> rows;
List<XWPFTableCell> cells;
table = (XWPFTable) ib;
// 获取表格的每一行
rows = table.getRows();
for (XWPFTableRow row : rows) {
// 获取表格的每一列
cells = row.getTableCells();
int cellsize = cells.size();
int cellcount = 0;
for (cellcount = 0; cellcount < cellsize; cellcount++) {
XWPFTableCell cell = cells.get(cellcount);
String runtext = "";
// 获取单元格的段落内容
List<XWPFParagraph> ps = cell.getParagraphs();
for (XWPFParagraph p : ps) {
// 获取每个段落的片段（字体样式相同的一段）
for (XWPFRun run : p.getRuns()) {
// 获取片段中的文本
runtext = run.text();
// 替换文本
if (params != null) {
for (String picKey : params.keySet()) {
if (runtext != null && runtext.contains(picKey)) {
run.setText(params.get(picKey) + "", 0);
}
}
}
}
}
}
}
}
/**
* 写入image
* @param run 需要替换图片的片段
* @param imgFile 图片路径
* @throws Exception
*/
public static void replacePic(XWPFRun run, String imgFile) throws Exception {
int format;
if (imgFile.endsWith(".emf")) {
format = Document.PICTURE_TYPE_EMF;
} else if (imgFile.endsWith(".wmf")) {
format = Document.PICTURE_TYPE_WMF;
} else if (imgFile.endsWith(".pict")) {
format = Document.PICTURE_TYPE_PICT;
} else if (imgFile.endsWith(".jpeg") || imgFile.endsWith(".jpg")) {
format = Document.PICTURE_TYPE_JPEG;
} else if (imgFile.endsWith(".png")) {
format = Document.PICTURE_TYPE_PNG;
} else if (imgFile.endsWith(".dib")) {
format = Document.PICTURE_TYPE_DIB;
} else if (imgFile.endsWith(".gif")) {
format = Document.PICTURE_TYPE_GIF;
} else if (imgFile.endsWith(".tiff")) {
format = Document.PICTURE_TYPE_TIFF;
} else if (imgFile.endsWith(".eps")) {
format = Document.PICTURE_TYPE_EPS;
} else if (imgFile.endsWith(".bmp")) {
format = Document.PICTURE_TYPE_BMP;
} else if (imgFile.endsWith(".wpg")) {
format = Document.PICTURE_TYPE_WPG;
} else {
System.err.println(
"Unsupported picture: " + imgFile + ". Expected emf|wmf|pict|jpeg|png|dib|gif|tiff|eps|bmp|wpg");
return;
}
if(imgFile.startsWith("http")||imgFile.startsWith("https")){
run.addPicture(new URL(imgFile).openConnection().getInputStream(), format, "rpic", Units.toEMU(350),Units.toEMU(350));
}else{
run.addPicture(new FileInputStream(imgFile), format, "rpic", Units.toEMU(350),Units.toEMU(350));
}
}
/**
* @param url 获取文档对象的路径
* @return XWPFDocument 返回文档对象
* */
public static XWPFDocument openDocx(String url) {
XWPFDocument doc = null;
try (InputStream input = new FileInputStream(url)) {
doc = new XWPFDocument(input);
return doc;
} catch (IOException e) {
e.printStackTrace();
}
return doc;
}
/**
* @param outDoc 输出的文档对象
* @param out 输出内容
* @return void
* */
public static void writeDocx(XWPFDocument outDoc, OutputStream out) {
try {
outDoc.write(out);
out.flush();
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
扫一扫
45万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
