Anteriormente, presentamos el uso de Autopoi de JeecgBoot para exportar Excel en SpringBoot . De hecho, la capa inferior de Autopoi también es EasyPoi, que es muy conveniente para la importación / exportación de Excel. Entonces EasyPoi también se basa en POI. Si desea estudiar este aspecto en profundidad, puede echar un vistazo al método nativo de importación / exportación de POI primero, volverá a elegir EasyPoi
1. Introducción
La función de EasyPoi es la misma que la del nombre easy, y la función principal es fácil, de modo que una persona que nunca ha visto poi puede escribir fácilmente exportar Excel, exportar plantilla Excel, importar Excel, exportar plantilla Word, a través de anotaciones simples y lenguaje de plantilla (familiar Sintaxis de expresión), complete la complicada escritura anterior
Si desea obtener más información sobre Autopoi de JeecgBoot, puede consultar otro blog mío, utilizando Autopoi de JeecgBoot para exportar Excel en SpringBoot
https://blog.csdn.net/qq_40065776/article/details/107824221
2. Presenta EasyPoi
EasyPoi también está bien empaquetado en SpringBoot, lo que nos permite usar EasyPoi rápidamente para el desarrollo en SpringBoot
<!-- easypoi -->
<dependency>
<groupId>cn.afterturn</groupId>
<artifactId>easypoi-spring-boot-starter</artifactId>
<version>4.2.0</version>
</dependency>
Solo necesitamos introducir esta dependencia, que es un buen soporte para SpringBoot
Tres, interpretación del código fuente
1. Interpretación del código fuente de @Excel
Consultando el código fuente, no es difícil encontrarlo en la anotación cn.afterturn.easypoi.excel.annotation.Excel
/**
* Copyright 2013-2015 JueYue ([email protected])
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package cn.afterturn.easypoi.excel.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Excel 导出基本注释
* @author JueYue
* 2014年6月20日 下午10:25:12
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Excel {
/**
* 导出时，对应数据库的字段 主要是用户区分每个字段， 不能有annocation重名的 导出时的列名
* 导出排序跟定义了annotation的字段的顺序有关 可以使用a_id,b_id来确实是否使用
*/
public String name();
/**
* 展示到第几个可以使用a_id,b_id来确定不同排序
*/
public String orderNum() default "0";
/**
* 值得替换 导出是{a_id,b_id} 导入反过来,所以只用写一个
*/
public String[] replace() default {
};
/**
* 字典名称
*/
public String dict() default "";
}
Lo anterior es el fragmento de código de la anotación @Excel, podemos ver que la anotación admite dos métodos de reemplazo de diccionario
- 1. Reemplazar. Este método admite la escritura directa en los parámetros de anotación, como:
@Excel(name = "性别", width = 15, replace = "男_1,女_2")
@TableField("sex")
private Integer sex;
Usamos 1 para hombres y 2 para mujeres, de modo que cuando exportamos, podemos reemplazar automáticamente el valor mágico en los datos, pero de esta manera a menudo tenemos que escribir demasiado código en los parámetros de anotación, y nuestro diccionario suele ser Cambiando dinámicamente, tales limitaciones son demasiado grandes
- 2. dict, modo diccionario, pasado en los parámetros del diccionario, tales como:
@Excel(name = "性别", width = 15, dict = "sex")
@TableField("sex")
private Integer sex;
Aquí solo pasamos la clave del diccionario, de modo que cuando consultamos los datos y escribimos en el archivo de Excel, podemos reemplazar dinámicamente el valor mágico en los datos y aumentar la legibilidad de los datos.
2. Interpretación del código fuente de IExcelDictHandler
En el paso anterior, ya sabemos que EasyPoi admite la exportación de consultas de diccionario personalizado, entonces, ¿cómo lo implementamos? Al leer el código en la interfaz cn.afterturn.easypoi.handler.inter.IExcelDictHandler, el código es el siguiente:
package cn.afterturn.easypoi.handler.inter;
import java.util.List;
import java.util.Map;
/**
* @author jueyue on 18-2-2.
* @version 3.0.4
*/
public interface IExcelDictHandler {
/**
* 返回字典所有值
* key: dictKey
* value: dictValue
* @param dict 字典Key
* @return
*/
default public List<Map> getList(String dict) {
return null;
}
/**
* 从值翻译到名称
*
* @param dict 字典Key
* @param obj 对象
* @param name 属性名称
* @param value 属性值
* @return
*/
public String toName(String dict, Object obj, String name, Object value);
/**
* 从名称翻译到值
*
* @param dict 字典Key
* @param obj 对象
* @param name 属性名称
* @param value 属性值
* @return
*/
public String toValue(String dict, Object obj, String name, Object value);
}
Se proporcionan tres métodos en la interfaz:
- 1. GetList, consulta todos los datos del diccionario debajo de la clave a través de la clave del diccionario, por ejemplo: {"1": "男", "2": "女"} debajo del sexo
- 2. toName, la función de traducción del diccionario, de valor a nombre, por ejemplo: sexo: 1 -> "男", generalmente utilizado al exportar
- 3. toValue, a diferencia de toName, se traduce de nombre a valor, por ejemplo: sexo: "男" -> 1, generalmente utilizado al importar
Ahora que sabemos que la interfaz de traducción de diccionarios se proporciona en EasyPoi, solo necesitamos proporcionar una clase de implementación y reescribir los métodos en la interfaz. IExcelDictHandlerImpl.java implementa la interfaz IExcelDictHandler. El código es el siguiente:
package com.zyxx.common.excel;
import cn.afterturn.easypoi.handler.inter.IExcelDictHandler;
import com.zyxx.sys.service.SysDictDetailService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
/**
* 支持字典参数设置
* 举例： @Excel(name = "性别", width = 15, dicCode = "sex")
* 1、导出的时候会根据字典配置，把值1,2翻译成：男、女;
* 2、导入的时候，会把男、女翻译成1,2存进数据库;
*
* @Author lizhou
*/
@Slf4j
@Component
public class IExcelDictHandlerImpl implements IExcelDictHandler {
@Autowired
private SysDictDetailMapper testSysDictDetailMapper;
private static SysDictDetailMapper sysDictDetailMapper;
@PostConstruct
public void init() {
sysDictDetailMapper = this.testSysDictDetailMapper;
}
/**
* 从值翻译到名称
*
* @param dict 字典Key
* @param obj 对象
* @param name 属性名称
* @param value 属性值
* @return
*/
@Override
public String toName(String dict, Object obj, String name, Object value) {
return sysDictDetailMapper.getTextByDictAndValue(dict, String.valueOf(value));
}
/**
* 从名称翻译到值
*
* @param dict 字典Key
* @param obj 对象
* @param name 属性名称
* @param value 属性值
* @return
*/
@Override
public String toValue(String dict, Object obj, String name, Object value) {
return null;
}
}
- 1. Aquí exportamos, solo usamos el método toName (traducción de valor a nombre), por lo que solo se escribe un método
- 2. Necesitamos usar la anotación @Component para cargarlo en el contenedor Spring
- 3. @PostConstruct Esta anotación se usa para decorar un método void () no estático. El método decorado por @PostConstruct se ejecutará cuando el servidor cargue el Servlet, y el servidor solo lo ejecutará una vez. PostConstruct se ejecuta después del constructor y antes del método init ()
Cuarto, empieza a exportar
1. Defina la clase de entidad
package com.zyxx.sys.entity;
import cn.afterturn.easypoi.excel.annotation.Excel;
import com.baomidou.mybatisplus.annotation.*;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import com.zyxx.common.annotation.Dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 用户信息表
* </p>
*
* @author lizhou
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("sys_user_info")
@ApiModel(value = "SysUserInfo对象", description = "用户信息表")
public class SysUserInfo extends Model<SysUserInfo> {
@ApiModelProperty(value = "ID")
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@Excel(name = "姓名", width = 15)
@ApiModelProperty(value = "姓名")
@TableField("name")
private String name;
@Excel(name = "电话", width = 15)
@ApiModelProperty(value = "电话")
@TableField("phone")
private String phone;
@Excel(name = "性别", width = 15, dict = "sex")
@TableField("sex")
@Dict(dictCode = "user_sex")
private Integer sex;
@Excel(name = "状态", width = 15, dict = "status")
@TableField("status")
private Integer status;
}
La anotación @Excel se explica de la siguiente manera:
- nombre, nombre del encabezado
- ancho, ancho de columna
- dict, clave de diccionario
2. Exportar interfaz API
La capa del controlador proporciona API de exportación
@ApiOperation(value = "导出用户信息", notes = "导出用户信息")
@GetMapping(value = "/export")
public void exportXls(HttpServletResponse response) {
// 查询数据
List<SysUserInfo> list = sysUserInfoService.list(1, Integer.MAX_VALUE);
// 导出数据，数据，数据类型，文件名称，表名，响应对象
ExportExcelUtil.exportExcel(list, SysUserInfo.class, "用户信息表", "用户信息统计", response);
}
3. Exportar herramientas
/**
* 导出excel
*
* @param list 数据集合
* @param pojoClass 数据类型
* @param fileName 文件名称
* @param title 表明
* @param response 响应对象
*/
public static void exportExcel(List<?> list, Class<?> pojoClass, String fileName, String title, HttpServletResponse response) {
ExportParams exportParams = new ExportParams(title, null);
// 自定义字典查询规则
exportParams.setDictHandler(new IExcelDictHandlerImpl());
Workbook workbook = ExcelExportUtil.exportExcel(exportParams, pojoClass, list);
if (workbook != null) {
try {
response.setCharacterEncoding("UTF-8");
response.setHeader("content-Type", "application/vnd.ms-excel");
response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8") + ".xls");
workbook.write(response.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
}
exportParams.setDictHandler (new IExcelDictHandlerImpl ());, pasamos una regla de consulta de diccionario personalizada
Cinco, prueba de exportación
Llamamos a la interfaz API para exportar datos para exportar el archivo. El efecto de exportación es el siguiente:
Seis, resumen
Se puede ver que el método de consulta y exportación del diccionario personalizado es en realidad el mismo que el método Autopoi de JeecgBoot. Más tarde, se descubrió que el Autopoi de JeecgBoot y el archivo de lectura hutool ExcelReader estaban en conflicto, y el Autopoi de JeecgBoot fue abandonado. EasyPoi es de hecho un poderoso Producto de operación Excel! ! !
Si encuentra deficiencias en la lectura, ¡deje un mensaje! ! !