使用注解来实现Excel的导入导出是一种常见的做法，它能够简化开发流程并提高代码的可维护性。对于简单报表的导出导入，这个最佳。现在很多自研的项目，和常用的导出Jar包，都封装了自己的@Excel的注解，比如若依的@Excel，EasyExcel的@ExcelProperty，等等，这篇文章，主要是带领大家熟悉注解导出Excel，因为使用注解导出Excel的底层原理大差不差，咱们直接开始。
1.基础用法
1.1 添加EasyExcel 依赖
<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>
1.2 写个自定义注解
package com.etoak.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 自定义导出Excel数据注解
**/
@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;
}
1.3 写个Excel 工具类
package com.etoak.vo;
import com.etoak.annotation.Excel;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddressList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.*;
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;
}*/
}
这个工具类一共有三个方法
exportExcel(List<?> list, String sheetName, HttpServletResponse response) 这个方法是导出excel的方法， 三个参数
1、需要导入到excel表的数据集合
2、导出excel文件的名字，例如test.xls，由于我们使用的是HSSFWorkbook:是操作Excel2003以前 （包括2003）的版本，扩展名是.xls；xls文件对于行数有要求，xls文件最长65536行。更改文档扩 展名时必须用另存为不能直接修改后缀：.xls另存为.xlsx而不是手动修改后缀；
3、HttpServletResponse是Java Servlet API中的一个接口，用于表示HTTP响应。当Web应用程序接 收到一个HTTP请求时，它会创建一个HttpServletRequest对象来封装请求信息，并创建一个 HttpServletResponse对象来封装响应信息。
HttpServletResponse允许Servlet容器通过Servlet向客户端发送响应。这个接口提供了多种方法 来设置HTTP响应的状态码、头部信息、内容类型、字符编码等，并且提供了输出流和输出缓冲区 来发送响应的内容。
List<T> importExcel(InputStream input) throws Exception 这个方法是导入excel文件，将数据转为相应的集合。参数传入一个InputStream 流就可以了
List<T> importExcel(String sheetName, InputStream input) 这个方法对excel表单指定excel sheet 内容转换成list ，两个参数，1、对于excel表的sheetName ，2、一个InputStream流
1.4 写个controller 测试一下
你要导出哪个实体类，就给哪个实体类添加我们自定义的注解@Excel
1.4.1 实体类
package com.etoak.entity;
import com.baomidou.mybatisplus.annotation.*;
import com.etoak.annotation.Excel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
* (TestTable)实体类
*
* @author makejava
* @since 2024-08-15 10:08:59
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TestTable implements Serializable{
private static final long serialVersionUID= 240344468689896500L;
@TableId(value = "id" , type = IdType.AUTO)
@Excel(name = "id")
private Integer id;
@TableField(value = "name")
@Excel(name = "姓名")
private String name;
@TableField(value = "age")
@Excel(name = "年龄")
private Integer age;
@TableField(value = "email")
@Excel(name = "邮箱",height = 20,width = 30)
private String email;
}
然后写个接口测试一下我们写的导出的Excel工具类
1.4.2 controller
@GetMapping("testExcel")
public void testExcel(HttpServletResponse response){
//先new一个工具类，把我们想导出的数据类型，以构造对象的方式传给ExcelUtil
ExcelUtil<TestTable> excelUtil = new ExcelUtil<>(TestTable.class);
//查询出要导出的数据
List<TestTable> excelList = testTableService.selectList();
//利用我们工具类方法，导出excel exportExcel(List<?> list, String sheetName, HttpServletResponse response)
excelUtil.exportExcel(excelList , "userInformation.xlsx", response);
}
1.5 测试结果
数据没有问题，基本的导出写完了。
但是实际工作中，我们导出功能都绑定在我们项目中，如果我们只在后端处理远远不够的，我们前端调用完这个接口后，还要对这个接口返回的数据进行处理。
2.导入Excel
导入excel文件，获取excel文件里面的数据，我们ExcelUtil 有两个方法，
1、List<T> importExcel(String sheetName, InputStream input)
2、List<T> importExcel(InputStream input)
2.1 importExcel(InputStream input)
这个方法很简单，只需要传入一个输入流就可以了，先看一下我们的excel文件的内容和结构
第一列，一定要和我们@Excel(name = "导出excel的title") 的name属性一致
2.1.1 写个controller 测试一下
@PostMapping("import")
public ResultVO importExcel(MultipartFile file) throws Exception {
//先new 个导入数据的ExcelUtil工具类
ExcelUtil<TestTable> excelUtil = new ExcelUtil<>(TestTable.class);
//用file.getInputStream 来获取文件的输入流
List<TestTable> testTables = excelUtil.importExcel(file.getInputStream());
return ResultVO.success(testTables);
}
测试结果
注意点：这个方法只导出sheet 索引为0 excel表的数据
2.2 List<T> importExcel(String sheetName, InputStream input)
这里两个参数 第一个是 excel文件里面sheet的名字，第二个是excel文件的输入流
先看excel结构，两个sheet，每个sheet都有不同的数据 这是第一个sheet的
这是第二个sheet的
两个sheet ，我们现在要导出test 表的数据
2.2.2 直接上代码
@PostMapping("importSheet")
public ResultVO importSheet(MultipartFile file,@RequestParam String sheetName) throws Exception {
ExcelUtil<TestTable> excelUtil = new ExcelUtil<>(TestTable.class);
List<TestTable> testTables = excelUtil.importExcel(sheetName,file.getInputStream());
return ResultVO.success(testTables);
}
看结果
可以看到名字为test的sheet表的数据被我们导出了
3.@Excel注解的使用
咱们自定义@Excel 有很多个属性，对@Excel属性咱们进行一个解析
package com.etoak.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 自定义导出Excel数据注解
**/
@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;
}
3.1 name 属性
导出到Excel的名字，也就是Excel的title
效果图
@TableId(value = "id" , type = IdType.AUTO)
@Excel(name = "id")
private Integer id;
@TableField(value = "name")
@Excel(name = "姓名")
private String name;
3.2 dateFormat
将导出到Excel的时间以指定的格式展示
3.3 readConverterExp
将导出到Excel的数据转换对应的内容，例如，数据库中有个字段 type代表工作类型，数据类型是 int ，1代表就业，2 代表外包，如果我们在实体类上添加@Excel（name="工作类型"），不写readConverterExp的话，只会在Excel文件上导出 1，2。
@TableField(value = "age")
@Excel(name = "年龄",readConverterExp = "29=29岁")
private Integer age;
效果展示
3.4 height 和 weight
这个就是改变单元格的宽度和高度的，在我们这个工具类里面，只要给一个@Excel注解添加weight 和 height，就会改变所有的单元格的宽度和高度。
3.5 suffix
这个属性给导出的数据加上后缀
示例
@TableField(value = "age")
@Excel(name = "年龄",suffix = "岁")
private Integer age;
3.6 defaultValue
当值为空时,字段的默认值
@TableField(value = "age")
@Excel(name = "年龄",defaultValue = "0")
private Integer age;
3.7 prompt
提示信息，给单元格加个提示信息,示例
@TableField(value = "age")
@Excel(name = "年龄",prompt = "请输入数字")
private Integer age;
3.8 combo
设置只能选择不能输入的列内容,就是在Excel单元格设置一个下拉框
@TableField(value = "age")
@Excel(name = "年龄",combo = {"1","2"})
private Integer age;
3.9 isExport
是否导出数据,示例
@TableField(value = "age")
@Excel(name = "年龄",isExport = false)
private Integer age;
本文就是简单介绍一下，如何使用注解导出Excel，不同公司定义的注解不一样，注解的属性也不一样，这个只是作为一个示例，供大家学习，具体到公司的业务的时候，具体情况具体分析，加油兄弟们。
扫一扫
683
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
