Java——使用Excel实现多Sheet导入导出
本文主要介绍如何使用Excel实现导入导出功能。
现以硬件的设备健康度的规则集合数据为例，规则集合中有规则集（rule）、规则组（group）、规则项（item）三个有关联的数据，各存放在不同的表中。其中，规则集id关联规则组的点表id，规则组id关联规则项的组id。现在要导出一个硬件设备的规则集合数据，分别放在不同的Sheet工作表中且存放在同一个Excel文件。（可参考导出导入方法结合自己实际情况实现）
1. 添加依赖
在pom.xml文件中添加依赖，如缺失其他依赖可自行添加。
<!-- excel工具 -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>${poi.version}</version>
</dependency>
2. 编写Excel工具类
这一步，先在Excel工具类中添加导出方法，即将数据写入多Sheet工作表中。后续导出excel文件中需要用到。
public class ExcelUtil<T> {
public ExcelUtil(Class<T> clazz) {
this.clazz = clazz;
}
/**
* 将数据写入工作表
*
* @param sheet 工作表
* @param dataList 数据列表
* @param headers 表头
* @throws IllegalAccessException
*/
public static void writeDataToSheet(Sheet sheet, List<?> dataList, String[] headers) throws IllegalAccessException {
//初始化列数和行数
int columnNum = 0;
int rowNum = 0;
//创建并填充头部行
Row headerRow = sheet.createRow(rowNum++);
for (String header : headers) {
headerRow.createCell(columnNum++).setCellValue(header);
}
//遍历数据列表
for (Object data : dataList) {
//创建新行
Row dataRow = sheet.createRow(rowNum++);
columnNum = 0;
//如果数据不为空，获取其类并反射获取字段
if (data != null) {
Class<?> clazz = data.getClass();
Field[] fields = clazz.getDeclaredFields();
//遍历字段，查找注解为Excel的字段
for (Field field : fields) {
//允许访问私有字段
field.setAccessible(true);
Excel excelAnnotation = field.getAnnotation(Excel.class);
//如果字段有Excel注解，获取字段值并写入单元格
if (excelAnnotation != null) {
Object value = field.get(data);
dataRow.createCell(columnNum++).setCellValue(value != null ? value.toString() : "");
}
}
}
}
}
其中，Excel自定义注解如下：
/**
* 自定义导出Excel数据注解
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Excel {
/**
* 导出时在excel中排序
*/
int sort() default Integer.MAX_VALUE;
/**
* 导出到Excel中的名字.
*/
String name() default "";
/**
* 日期格式, 如: yyyy-MM-dd
*/
String dateFormat() default "";
/**
* 如果是字典类型，请设置字典的type值 (如: sys_user_sex)
*/
String dictType() default "";
/**
* 读取内容转表达式 (如: 0=男,1=女,2=未知)
*/
String readConverterExp() default "";
/**
* 分隔符，读取字符串组内容
*/
String separator() default ",";
/**
* BigDecimal 精度 默认:-1(默认不开启BigDecimal格式化)
*/
int scale() default -1;
/**
* BigDecimal 舍入规则 默认:BigDecimal.ROUND_HALF_EVEN
*/
int roundingMode() default BigDecimal.ROUND_HALF_EVEN;
/**
* 导出时在excel中每个列的高度 单位为字符
*/
double height() default 14;
/**
* 导出时在excel中每个列的宽 单位为字符
*/
double width() default 16;
/**
* 文字后缀,如% 90 变成90%
*/
String suffix() default "";
/**
* 当值为空时,字段的默认值
*/
String defaultValue() default "";
/**
* 提示信息
*/
String prompt() default "";
/**
* 设置只能选择不能输入的列内容.
*/
String[] combo() default {};
/**
* 是否需要纵向合并单元格,应对需求:含有list集合单元格)
*/
boolean needMerge() default false;
/**
* 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写.
*/
boolean isExport() default true;
/**
* 另一个类中的属性名称,支持多级获取,以小数点隔开
*/
String targetAttr() default "";
/**
* 是否自动统计数据,在最后追加一行统计数据总和
*/
boolean isStatistics() default false;
/**
* 导出类型（0数字 1字符串 2图片）
*/
ColumnType cellType() default ColumnType.STRING;
/**
* 导出列头背景色
*/
IndexedColors headerBackgroundColor() default IndexedColors.GREY_50_PERCENT;
/**
* 导出列头字体颜色
*/
IndexedColors headerColor() default IndexedColors.WHITE;
/**
* 导出单元格背景色
*/
IndexedColors backgroundColor() default IndexedColors.WHITE;
/**
* 导出单元格字体颜色
*/
IndexedColors color() default IndexedColors.BLACK;
/**
* 导出字段对齐方式
*/
HorizontalAlignment align() default HorizontalAlignment.CENTER;
/**
* 自定义数据处理器
*/
Class<?> handler() default ExcelHandlerAdapter.class;
/**
* 自定义数据处理器参数
*/
String[] args() default {};
/**
* 字段类型（0：导出导入；1：仅导出；2：仅导入）
*/
Type type() default Type.ALL;
enum Type {
ALL(0), EXPORT(1), IMPORT(2);
private final int value;
Type(int value) {
this.value = value;
}
public int value() {
return this.value;
}
}
enum ColumnType {
NUMERIC(0), STRING(1), IMAGE(2);
private final int value;
ColumnType(int value) {
this.value = value;
}
public int value() {
return this.value;
}
}
}
3. 导出代码实现
controller层
/**
* 导出规则数据
*/
@PostMapping("/export/{deviceId}")
public void export(HttpServletResponse response, @PathVariable("deviceId") String deviceId) throws Exception {
sysRuleAllService.exportRuleAllData(response, deviceId);
}
service层
/**
* 导出规则数据
*/
public void exportRuleAllData(HttpServletResponse response, String deviceId) throws Exception;
实现service：其中sysRuleMapper、sysRuleGroupMapper、sysRuleItemMapper各对应规则集合下面的三个数据集合。Header数组对应的在常量类中。根据业务自行实现。
/**
* 规则数据常量类
*/
public class SysRuleConstants {
//导出数据标题（对应三个Sheet工作表的表头，也就是三组数据表中的属性）
public static final String[][] HEADERS = {{"序号", "规则描述"},
{"id", "关联点表id", "组序号", "健康度"},
{"关联规则组id", "项序号", "连接符", "规则项", "规则描述", "判断符", "条件"}};
//标题占用行数（标题占用Sheet表的第1行，从0开始）
public static final int TITLE_NUM = 0;
//导入成功（失败）默认条数
public static final int INIT_NUM = 0;
//（这里是导入后返回的信息）
//成功条数
private final int successCount;
//失败条数
private final int failureCount;
public SysRuleConstants(int successCount, int failureCount) {
this.successCount = successCount;
this.failureCount = failureCount;
}
public int getSuccessCount() {
return successCount;
}
public int getFailureCount() {
return failureCount;
}
}
/**
* 导出规则数据
*
* @param response 响应对象
* @param deviceId 设备Id
* @throws Exception
*/
@Override
public void exportRuleAllData(HttpServletResponse response, String deviceId) throws Exception {
//这里根据实际情况导出想要的list数据，可导出多个list集合
List<SysRule> ruleList = sysRuleMapper.selectSysRuleListByDeviceId(deviceId);
List<SysRuleGroup> groupList = sysRuleGroupMapper.selectSysRuleGroupListByModeIdAndDeviceId(deviceId);
List<SysRuleItem> itemList = sysRuleItemMapper.selectSysRuleItemListByGroupIdAndModeIdAndDeviceId(deviceId);
//创建一个新的Excel文件
Workbook workbook = new XSSFWorkbook();
//在工作簿中创建三个工作表
Sheet ruleSheet = workbook.createSheet("规则集数据");
Sheet groupSheet = workbook.createSheet("规则组数据");
Sheet itemSheet = workbook.createSheet("规则项数据");
//调用方法写入数据（Header要对应导出的数据表头）
ExcelUtil.writeDataToSheet(ruleSheet, ruleList, SysRuleConstants.HEADERS[0]);
ExcelUtil.writeDataToSheet(groupSheet, groupList, SysRuleConstants.HEADERS[1]);
ExcelUtil.writeDataToSheet(itemSheet, itemList, SysRuleConstants.HEADERS[2]);
//设置响应头
response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
response.setCharacterEncoding("utf-8");
//写入输出流并关闭工作簿
workbook.write(response.getOutputStream());
workbook.close();
}
至此，导出三组不同的数据到三个Sheet工作表中，并存放在同一个Excel文件下就完成了。
4. 导出Excel文件展示
导出文件存放在本地。现在以这个Excel文件为例进行导入操作。
5. 添加Excel导入方法
在Excel工具类中添加：多Sheet表转换list数据
/**
* 对excel表单指定表格索引名转换成list
*
* @param sheetName 表格索引名
* @param titleNum 标题占用行数
* @param is 输入流
* @return 转换后集合
*/
public List<T> importExcel(String sheetName, InputStream is, int titleNum) throws Exception {
this.type = Type.IMPORT;
this.wb = WorkbookFactory.create(is);
List<T> list = new ArrayList<T>();
// 如果指定sheet名,则取指定sheet中的内容 否则默认指向第1个sheet
Sheet sheet = StringUtils.isNotEmpty(sheetName) ? wb.getSheet(sheetName) : wb.getSheetAt(0);
if (sheet == null) {
throw new IOException("文件sheet不存在");
}
boolean isXSSFWorkbook = !(wb instanceof HSSFWorkbook);
Map<String, PictureData> pictures;
if (isXSSFWorkbook) {
pictures = getSheetPictures07((XSSFSheet) sheet, (XSSFWorkbook) wb);
} else {
pictures = getSheetPictures03((HSSFSheet) sheet, (HSSFWorkbook) wb);
}
// 获取最后一个非空行的行下标，比如总行数为n，则返回的为n-1
int rows = sheet.getLastRowNum();
if (rows > 0) {
// 定义一个map用于存放excel列的序号和field.
Map<String, Integer> cellMap = new HashMap<String, Integer>();
// 获取表头
Row heard = sheet.getRow(titleNum);
for (int i = 0; i < heard.getPhysicalNumberOfCells(); i++) {
Cell cell = heard.getCell(i);
if (StringUtils.isNotNull(cell)) {
String value = this.getCellValue(heard, i).toString();
cellMap.put(value, i);
} else {
cellMap.put(null, i);
}
}
// 有数据时才处理 得到类的所有field.
List<Object[]> fields = this.getFields();
Map<Integer, Object[]> fieldsMap = new HashMap<Integer, Object[]>();
for (Object[] objects : fields) {
Excel attr = (Excel) objects[1];
Integer column = cellMap.get(attr.name());
if (column != null) {
fieldsMap.put(column, objects);
}
}
for (int i = titleNum + 1; i <= rows; i++) {
// 从第2行开始取数据,默认第一行是表头.
Row row = sheet.getRow(i);
// 判断当前行是否是空行
if (isRowEmpty(row)) {
continue;
}
T entity = null;
for (Map.Entry<Integer, Object[]> entry : fieldsMap.entrySet()) {
Object val = this.getCellValue(row, entry.getKey());
// 如果不存在实例则新建.
entity = (entity == null ? clazz.newInstance() : entity);
// 从map中得到对应列的field.
Field field = (Field) entry.getValue()[0];
Excel attr = (Excel) entry.getValue()[1];
// 取得类型,并根据对象类型设置值.
Class<?> fieldType = field.getType();
if (String.class == fieldType) {
String s = Convert.toStr(val);
if (StringUtils.endsWith(s, ".0")) {
val = StringUtils.substringBefore(s, ".0");
} else {
String dateFormat = field.getAnnotation(Excel.class).dateFormat();
if (StringUtils.isNotEmpty(dateFormat)) {
val = parseDateToStr(dateFormat, val);
} else {
val = Convert.toStr(val);
}
}
} else if ((Integer.TYPE == fieldType || Integer.class == fieldType) && StringUtils.isNumeric(Convert.toStr(val))) {
val = Convert.toInt(val);
} else if ((Long.TYPE == fieldType || Long.class == fieldType) && StringUtils.isNumeric(Convert.toStr(val))) {
val = Convert.toLong(val);
} else if (Double.TYPE == fieldType || Double.class == fieldType) {
val = Convert.toDouble(val);
} else if (Float.TYPE == fieldType || Float.class == fieldType) {
val = Convert.toFloat(val);
} else if (BigDecimal.class == fieldType) {
val = Convert.toBigDecimal(val);
} else if (Date.class == fieldType) {
if (val instanceof String) {
val = DateUtils.parseDate(val);
} else if (val instanceof Double) {
val = DateUtil.getJavaDate((Double) val);
}
} else if (Boolean.TYPE == fieldType || Boolean.class == fieldType) {
val = Convert.toBool(val, false);
}
if (StringUtils.isNotNull(fieldType)) {
String propertyName = field.getName();
if (StringUtils.isNotEmpty(attr.targetAttr())) {
propertyName = field.getName() + "." + attr.targetAttr();
} else if (StringUtils.isNotEmpty(attr.readConverterExp())) {
val = reverseByExp(Convert.toStr(val), attr.readConverterExp(), attr.separator());
} else if (StringUtils.isNotEmpty(attr.dictType())) {
val = reverseDictByExp(Convert.toStr(val), attr.dictType(), attr.separator());
} else if (!attr.handler().equals(ExcelHandlerAdapter.class)) {
val = dataFormatHandlerAdapter(val, attr);
} else if (ColumnType.IMAGE == attr.cellType() && StringUtils.isNotEmpty(pictures)) {
PictureData image = pictures.get(row.getRowNum() + "_" + entry.getKey());
if (image == null) {
val = "";
} else {
byte[] data = image.getData();
val = FileUtils.writeImportBytes(data);
}
}
ReflectUtils.invokeSetter(entity, propertyName, val);
}
}
list.add(entity);
}
}
return list;
}
6. 导入代码实现
controller层
/**
* 导入规则数据
*/
@PostMapping("/import/{deviceId}")
public AjaxResult importRuleAllData(@RequestPart("file") MultipartFile file, @PathVariable String deviceId) throws Exception {
ExcelUtil<SysRule> ruleExcelUtil = new ExcelUtil<>(SysRule.class);
List<SysRule> ruleList = ruleExcelUtil.importExcel("规则集数据", file.getInputStream(), SysRuleConstants.TITLE_NUM);
ExcelUtil<SysRuleGroup> groupExcelUtil = new ExcelUtil<>(SysRuleGroup.class);
List<SysRuleGroup> groupList = groupExcelUtil.importExcel("规则组数据", file.getInputStream(), SysRuleConstants.TITLE_NUM);
ExcelUtil<SysRuleItem> itemExcelUtil = new ExcelUtil<>(SysRuleItem.class);
List<SysRuleItem> itemList = itemExcelUtil.importExcel("规则项数据", file.getInputStream(), SysRuleConstants.TITLE_NUM);
String message = sysRuleAllService.importRuleAllData(ruleList, groupList, itemList, deviceId);
file.getInputStream().close();
return AjaxResult.success(message);
}
service层
/**
* 导入规则数据
*/
public String importRuleAllData(List<SysRule> ruleList, List<SysRuleGroup> groupList, List<SysRuleItem> itemList, String deviceId);
实现service
/**
* 导入规则数据
*
* @param ruleList 规则集列表
* @param groupList 规则组列表
* @param itemList 规则项列表
* @param deviceId 设备Id
* @return
*/
@Override
public String importRuleAllData(List<SysRule> ruleList, List<SysRuleGroup> groupList, List<SysRuleItem> itemList, String deviceId) {
//规则集不能为空
if (StringUtils.isNull(ruleList) || ruleList.size() == 0) {
throw new ServiceException("导入的规则集不能为空！");
}
StringBuilder successMsg = new StringBuilder();
StringBuilder failureMsg = new StringBuilder();
//注意：这里根据实际业务处理，此处封装了导入成功或失败后的返回信息
//规则集
SysRuleConstants ruleResult = importRule(ruleList, deviceId, SysRuleConstants.INIT_NUM, SysRuleConstants.INIT_NUM, successMsg, failureMsg);
//规则组
SysRuleConstants groupResult = importGroup(groupList, deviceId, SysRuleConstants.INIT_NUM, SysRuleConstants.INIT_NUM, successMsg, failureMsg);
//规则项
SysRuleConstants itemResult = importItem(itemList, deviceId, SysRuleConstants.INIT_NUM, SysRuleConstants.INIT_NUM, successMsg, failureMsg);
int successNum = ruleResult.getSuccessCount() + groupResult.getSuccessCount() + itemResult.getSuccessCount();
int failureNum = ruleResult.getFailureCount() + groupResult.getFailureCount() + itemResult.getFailureCount();
if (successNum > 0 && failureNum == 0) {
successMsg.insert(0, "恭喜您，数据导入成功！共 " + successNum + " 条。");
return successMsg.toString();
}
if (failureNum > 0 && successNum == 0) {
throw new ServiceException("很抱歉，数据导入失败！共 " + failureNum + " 条。" + failureMsg.toString());
}
if (successNum > 0 && failureNum > 0) {
failureMsg.insert(0, "部分数据已存在！共 " + failureNum + " 条。");
successMsg.insert(0, "部分数据导入成功！共 " + successNum + " 条。");
return failureMsg.toString() + "<br/>" + successMsg.toString();
}
return "没有数据被导入或处理";
}
//以下三个方法即：三组数据导入的逻辑处理，由于三组数据分开存放且三表有联系，此处分别处理数据。只参考导出导入方法可跳过。
/**
* 导入规则集
*
* @param ruleList 规则集数据
* @param deviceId 设备Id
* @param ruleSuccessNum 规则集成功条数
* @param ruleFailNum 规则集失败条数
* @param successMsg 成功信息
* @param failureMsg 失败信息
* @return
*/
public SysRuleConstants importRule(List<SysRule> ruleList, String deviceId, int ruleSuccessNum, int ruleFailNum, StringBuilder successMsg, StringBuilder failureMsg) {
for (SysRule sysRule : ruleList) {
try {
SysRule newSysRule = new SysRule();
newSysRule.setDeviceId(deviceId);
newSysRule.setOrderNum(sysRule.getOrderNum());
newSysRule.setRuleDesc(sysRule.getRuleDesc());
List<SysRule> sysRules = sysRuleMapper.selectSysRuleList(newSysRule);
if (StringUtils.isNull(sysRules) || sysRules.size() == 0) {
sysRule.setDeviceId(deviceId);
sysRuleMapper.insertSysRule(sysRule);
ruleSuccessNum++;
successMsg.append("<br/>" + ruleSuccessNum + "条规则集 " + " 导入成功");
} else {
ruleFailNum++;
failureMsg.append("<br/>" + ruleFailNum + "条规则集 " + " 已存在！");
}
} catch (Exception e) {
ruleFailNum++;
String msg = ("<br/>" + ruleFailNum + "条规则集 " + sysRule.getDeviceId() + " 导入失败：" + e.getMessage());
failureMsg.append(msg + e.getMessage());
LogUtils.getBlock(e);
}
}
return new SysRuleConstants(ruleSuccessNum, ruleFailNum);
}
/**
* 导入规则组
*
* @param groupList 规则组数据
* @param deviceId 设备Id
* @param groupSuccessNum 规则组成功条数
* @param groupFailNum 规则组失败条数
* @param successMsg 成功信息
* @param failureMsg 失败信息
* @return
*/
public SysRuleConstants importGroup(List<SysRuleGroup> groupList, String deviceId, int groupSuccessNum, int groupFailNum, StringBuilder successMsg, StringBuilder failureMsg) {
for (SysRuleGroup sysRuleGroup : groupList) {
try {
//重复导入判断：根据要导入的设备id取出group数据，比较这个数据和groupList是否相同
List<SysRuleGroup> existGroupList = sysRuleGroupMapper.selectSysRuleGroupListByModeIdAndDeviceId(deviceId);
//比较existGroupList和groupList是否相同，不比较id
if (existGroupList.size() != 0 && existGroupList.size() == groupList.size()) {
for (SysRuleGroup existGroup : existGroupList) {
if (existGroup.equals(sysRuleGroup)) {
throw new ServiceException("规则组已存在！");
}
}
groupFailNum++;
failureMsg.append("<br/>" + groupFailNum + "条规则组 " + " 已存在！");
} else {
//已经导入进去的规则集sysRule
List<SysRule> newSysRules = sysRuleMapper.selectSysRuleListByDeviceId(deviceId);
if (StringUtils.isNull(newSysRules) || newSysRules.size() == 0) {
throw new ServiceException("导入规则组失败，规则组对应的规则集不存在！");
} else {
/*
根据sysRuleGroup的modeId查询到旧的rule，再根据旧的rule的设备id，orderNum和ruleDesc查询到新的rule
然后取出新的rule的id作为新的group的modeId，其他数据不变，插入sys_rule_group表
*/
SysRule oldSysRule = sysRuleMapper.selectSysRuleById(sysRuleGroup.getModeId());
if (StringUtils.isNull(oldSysRule)) {
throw new ServiceException("规则集不存在！");
}
SysRule newSysRule = sysRuleMapper.selectSysRuleByDeviceIdAndOrderNumAndDesc(deviceId, oldSysRule.getOrderNum(), oldSysRule.getRuleDesc());
if (StringUtils.isNotNull(newSysRule)) {
SysRuleGroup newGroup = new SysRuleGroup();
newGroup.setModeId(newSysRule.getId());
newGroup.setOrderNum(sysRuleGroup.getOrderNum());
newGroup.setHealth(sysRuleGroup.getHealth());
sysRuleGroupMapper.insertSysRuleGroup(newGroup);
groupSuccessNum++;
successMsg.append("<br/>" + groupSuccessNum + "条规则组 " + " 导入成功");
}
}
}
} catch (Exception e) {
groupFailNum++;
String msg = ("<br/>" + groupFailNum + "条规则组，导入失败：" + e.getMessage());
failureMsg.append(msg + e.getMessage());
LogUtils.getBlock(e);
}
}
return new SysRuleConstants(groupSuccessNum, groupFailNum);
}
/**
* 导入规则项
*
* @param itemList 规则项数据
* @param deviceId 设备Id
* @param itemSuccessNum 规则项成功条数
* @param itemFailNum 规则项失败条数
* @param successMsg 成功信息
* @param failureMsg 失败信息
* @return
*/
public SysRuleConstants importItem(List<SysRuleItem> itemList, String deviceId, int itemSuccessNum, int itemFailNum, StringBuilder successMsg, StringBuilder failureMsg) {
for (SysRuleItem sysRuleItem : itemList) {
try {
//已经导入进去的规则组sysRuleGroup
List<SysRuleGroup> newSysRuleGroups = sysRuleGroupMapper.selectSysRuleGroupListByModeIdAndDeviceId(deviceId);
if (StringUtils.isNull(newSysRuleGroups) || newSysRuleGroups.size() == 0) {
throw new ServiceException("导入规则项失败，规则组对应的规则组不存在！");
} else {
/*
根据sysRuleItem的groupId查询对应的旧的group，再根据旧的group的modeId查询对应的旧的rule
然后根据设备id和旧的rule的orderNum和ruleDesc找到新的rule，取出新的rule的id（即新插入的group的modeId）
根据rule的新id（新的group的modeId）对应的新的group（这个新的group可能是多个）
根据旧的group的modeId查询所有的旧的group列表，根据新的rule的id查询出新的group列表
遍历两个group列表，如果旧的group的id和item的groupId一样，sysRuleItem的groupId设置为对应的新的group的id
其他数据不变，然后查询新sysRuleItem数据列表，没有的话插入
*/
SysRuleGroup oldSysRuleGroup = sysRuleGroupMapper.selectSysRuleGroupById(sysRuleItem.getGroupId());
if (StringUtils.isNull(oldSysRuleGroup)) {
throw new ServiceException("规则组不存在！");
}
SysRule oldSysRule = sysRuleMapper.selectSysRuleById(oldSysRuleGroup.getModeId());
if (StringUtils.isNull(oldSysRule)) {
throw new ServiceException("规则不存在！");
}
SysRule newSysRule = sysRuleMapper.selectSysRuleByDeviceIdAndOrderNumAndDesc(deviceId, oldSysRule.getOrderNum(), oldSysRule.getRuleDesc());
if (StringUtils.isNull(newSysRule)) {
throw new ServiceException("导入后的规则不存在！");
}
List<SysRuleGroup> oldGroups = sysRuleGroupMapper.selectSysRuleGroupByModeId(oldSysRuleGroup.getModeId());
List<SysRuleGroup> newGroups = sysRuleGroupMapper.selectSysRuleGroupByModeId(newSysRule.getId());
Iterator<SysRuleGroup> oldGroupIterator = oldGroups.iterator();
Iterator<SysRuleGroup> newGroupIterator = newGroups.iterator();
while (oldGroupIterator.hasNext() && newGroupIterator.hasNext()) {
SysRuleGroup oldGroup = oldGroupIterator.next();
SysRuleGroup newGroup = newGroupIterator.next();
if (Objects.equals(oldGroup.getId(), sysRuleItem.getGroupId())) {
SysRuleItem newRuleItem = new SysRuleItem();
newRuleItem.setGroupId(newGroup.getId());
newRuleItem.setOrderNum(sysRuleItem.getOrderNum());
newRuleItem.setConcat(sysRuleItem.getConcat());
newRuleItem.setItem(sysRuleItem.getItem());
newRuleItem.setDesc(sysRuleItem.getDesc());
newRuleItem.setComparison(sysRuleItem.getComparison());
newRuleItem.setConditionType(sysRuleItem.getConditionType());
List<SysRuleItem> existItemList = sysRuleItemMapper.selectSysRuleItemList(newRuleItem);
if (StringUtils.isNull(existItemList) || existItemList.size() == 0) {
sysRuleItemMapper.insertSysRuleItem(newRuleItem);
itemSuccessNum++;
successMsg.append("<br/>" + itemSuccessNum + "条规则项 " + " 导入成功");
} else {
itemFailNum++;
failureMsg.append("<br/>" + itemFailNum + "条规则项 " + " 已存在！");
}
}
}
}
} catch (Exception e) {
itemFailNum++;
String msg = ("<br/>" + itemFailNum + "条规则项，导入失败：" + e.getMessage());
failureMsg.append(msg + e.getMessage());
LogUtils.getBlock(e);
}
}
return new SysRuleConstants(itemSuccessNum, itemFailNum);
}
至此，导入功能完成。导入的数据可一一对应，即成功导入。
其中，主要以Excel工具类的数据写入不同工作表、多表转换数据为主。
完~
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
