easyExcel使⽤⾃定义注解
package act.Entity;
import l.annotation.ExcelProperty;
import act.annotation.IdcardValidate;
import lombok.Data;
import straints.NotBlank;
/**
* 基础数据类
*
**/
@Data
public class IndexOrNameData {
/**
* 强制读取第三个这⾥不建议 index 和 name 同时⽤，要么⼀个对象只⽤index，要么⼀个对象只⽤name去匹配
*/
@ExcelProperty(index = 2)
private Double doubleData;
/**
* ⽤名字去匹配，这⾥需要注意，如果名字重复，会导致只有⼀个字段读取到数据
*/
@ExcelProperty("字符串标题")
private String string;
@NotBlank(message = "⽇期标题不能为空")
@ExcelProperty("⽇期标题")
private String date;
@IdcardValidate
@ExcelProperty("⾝份证号")
private String idcard;
}
基础类
package act.listener;
import l.context.AnalysisContext;
import l.event.AnalysisEventListener;
import l.metadata.property.ExcelContentProperty;
import adata.holder.ReadHolder;
import adata.holder.ReadRowHolder;
import adata.property.ExcelReadHeadProperty;
import com.alibaba.fastjson.JSON;
import act.Entity.ExcelCellBo;
import act.Entity.ExcelErrorDTO;
import act.Entity.IndexOrNameData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.validation.ConstraintViolation;
import javax.validation.Path;
import javax.validation.Validation;
import ups.Default;
import java.util.*;
/**
* 模板的读取类
*
* @author Jiaju Zhuang
*/
public class IndexOrNameDataListener extends AnalysisEventListener<IndexOrNameData> {
private static final Logger LOGGER = Logger(IndexOrNameDataListener.class);
/**
* 每隔5条存储数据库，实际使⽤中可以3000条，然后清理list ，⽅便内存回收
*/
private static final int BATCH_COUNT = 5;
List<IndexOrNameData> dataList = new ArrayList<IndexOrNameData>();
List<ExcelErrorDTO> errorList = new ArrayList<ExcelErrorDTO>();
boolean validateResult = true;
public boolean getValidateResult(){
return validateResult;
}
public List<ExcelErrorDTO> getErrorList(){
return errorList;
}
@Override
public void invoke(IndexOrNameData data, AnalysisContext context) {
LOGGER.info("解析到⼀条数据:{}", JSONString(data));
Map<String, ExcelCellBo> propertyNameMap = getPropertyNameMap(true,context);
if (validate(data,propertyNameMap)) {
dataList.add(data);
}
if (dataList.size() >= BATCH_COUNT) {
saveData();
dataList.clear();
}
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
saveData();
LOGGER.info("所有数据解析完成！");
}
/**
* 加上存储数据库
*/
private void saveData() {
LOGGER.info("{}条数据，开始存储数据库！", dataList.size());
LOGGER.info("存储数据库成功！");
}
boolean validate(IndexOrNameData e, Map<String, ExcelCellBo> propertyNameMap) {
Set<ConstraintViolation<IndexOrNameData>> validateSet = Validation.buildDefaultValidatorFactory().getValidator().validate(e, Default.class);
if (validateSet != null && !validateSet.isEmpty()) {
validateResult = false;
ExcelErrorDTO errorDTO;
for (ConstraintViolation<IndexOrNameData> constraint : validateSet) {
Path propertyPath = PropertyPath();
String propertyName = String();
ExcelCellBo bo = (propertyName);
errorDTO = new ExcelErrorDTO();
errorDTO.HeadName());
Object invalidValue = InvalidValue();
if (invalidValue != null) {
errorDTO.String());
}else {
errorDTO.setValue(null);
}
errorDTO.ColumnIndex()+1);
errorDTO.RowIndex()+1);
errorDTO.setErrMsg("第"+RowIndex()+"⾏，第"+ColumnIndex()+"列,"+Message());
errorList.add(errorDTO);
}
}
return validateResult;
}
Map<String, ExcelCellBo> getPropertyNameMap(boolean isSingleHeader, AnalysisContext analysisContext) {
Map<String, ExcelCellBo> propertyNameMap = new HashMap<>(16);
ReadRowHolder readRowHolder = adRowHolder();
Integer rowIndex = RowIndex();
ReadHolder readHolder = analysisContext.currentReadHolder();
ExcelReadHeadProperty excelReadHeadProperty = lReadHeadProperty();
Collection<ExcelContentProperty> values;
if (isSingleHeader) {
Map<Integer, ExcelContentProperty> contentPropertyMap = ContentPropertyMap();
values = contentPropertyMap.values();
} else {
//也适⽤于单⾏表头
Map<String, ExcelContentProperty> fieldNameContentPropertyMap = FieldNameContentPropertyMap(); values = fieldNameContentPropertyMap.values();
}
ExcelCellBo bo;
for (ExcelContentProperty contentProperty : values) {
bo = new ExcelCellBo();
bo.setRowIndex(rowIndex);
bo.Head().getColumnIndex());
bo.Head().getFieldName());
//多⾏表头
bo.setHeadName(String.join(",", Head().getHeadNameList()));
bo.Field());
propertyNameMap.Head().getFieldName(), bo);
}
return propertyNameMap;
}
}
模板的读取类
package act.Entity;
import lombok.Data;
import flect.Field;
@Data
public class ExcelCellBo {
private Field field;
private String fieldName;
private String headName;
private Integer columnIndex;
private Integer rowIndex;
}
单元格信息
package act.Entity;
import lombok.Data;
@Data
public class ExcelErrorDTO {
String headName;
String value;
Integer columnIndex;
Integer rowIndex;
String errMsg;
}
错误信息
package act.annotation;
import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
@Target(FIELD)
@Retention(RUNTIME)
@Constraint(validatedBy = IdcardValidator.class)
public @interface IdcardValidate {
String message() default "⾝份证号不正确";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
⾃定义校验注解
package act.annotation;
import act.utils.IdCardVerification;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
ParseException;
public class IdcardValidator implements ConstraintValidator<IdcardValidate, String> {
private static final Logger logger = Logger(IdcardValidator.class);
@Override
public void initialize(IdcardValidate idcardValidate) {
}
@Override
public boolean isValid(String idcard, ConstraintValidatorContext context) {
String info = "";
try {
info = IdCardVerification.IDCardValidate(idcard);
} catch (ParseException e) {
<("⾝份证号校验异常");
}
if(!"0".equals(info)){
context.disableDefaultConstraintViolation();
context.buildConstraintViolationWithTemplate(info).addConstraintViolation();
return false;
}
return true;
}
}
校验逻辑的类
package act.utils;
ParseException;
SimpleDateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Hashtable;
validation verificationimport Matcher;
import Pattern;
/
**
* ⾝份证号码的格式：610821-20061222-612-X 由18位数字组成：前6位为地址码，第7⾄14位为出⽣⽇期码，第15⾄17位为顺序码，
* 第18位为校验码。检验码分别是0-10共11个数字，当检验码为“10”时，为了保证公民⾝份证号码18位，所以⽤“X”表⽰。虽然校验码为“X”不能更换，但若需全⽤数字表⽰，只需将18位公民⾝份号码转换成15位居民⾝份证号码，去掉第7⾄8位和最后1 * 当今的⾝份证号码有15位和18位之分。1985年我国实⾏居民⾝份证制度，当时签发的⾝份证号码是15位的，1999年签发的⾝份证由于年份的扩展（由两位变为四位）和末尾加了效验码，就成了18位。
* （1）前1、2位数字表⽰：所在省份的代码；
* （2）第3、4位数字表⽰：所在城市的代码；
* （3）第5、6位数字表⽰：所在区县的代码；
* （4）第7~14位数字表⽰：出⽣年、⽉、⽇；
* （5）第15、16位数字表⽰：所在地的派出所的代码；
* （6）第17位数字表⽰性别：奇数表⽰男性，偶数表⽰⼥性
* （7）第18位数字是校检码：根据⼀定算法⽣成
*/
public class IdCardVerification {
/**⾝份证有效*/
public static final String VALIDITY = "0";
/**位数不⾜*/
public static final String LACKDIGITS = "⾝份证号码长度应该为15位或18位。";
/**最后⼀位应为数字*/
public static final String LASTOFNUMBER = "⾝份证15位号码都应为数字 ; 18位号码除最后⼀位外，都应为数字。";
/**出⽣⽇期⽆效*/
public static final String INVALIDBIRTH = "⾝份证出⽣⽇期⽆效。";
/**⽣⽇不在有效范围*/
public static final String INVALIDSCOPE = "⾝份证⽣⽇不在有效范围。";
/**⽉份⽆效*/
public static final String INVALIDMONTH = "⾝份证⽉份⽆效";
/**⽇期⽆效*/
public static final String INVALIDDAY = "⾝份证⽇期⽆效";
/**⾝份证地区编码错误*/
public static final String CODINGERROR = "⾝份证地区编码错误。";
/**⾝份证校验码⽆效*/
public static final String INVALIDCALIBRATION = "⾝份证校验码⽆效，不是合法的⾝份证号码";
/
**
* 检验⾝份证号码是否符合规范
* @param IDStr ⾝份证号码
* @return错误信息或成功信息
*/
public static String IDCardValidate(String IDStr) throws ParseException {
String tipInfo = VALIDITY;// 记录错误信息
String Ai = "";
// 判断号码的长度 15位或18位
if (IDStr.length() != 15 && IDStr.length() != 18) {
tipInfo = LACKDIGITS;
return tipInfo;
}
// 18位⾝份证前17位位数字，如果是15位的⾝份证则所有号码都为数字
if (IDStr.length() == 18) {
Ai = IDStr.substring(0, 17);
} else if (IDStr.length() == 15) {
Ai = IDStr.substring(0, 6) + "19" + IDStr.substring(6, 15);
}
if (isNumeric(Ai) == false) {
tipInfo = LASTOFNUMBER;
return tipInfo;
}
// 判断出⽣年⽉是否有效
String strYear = Ai.substring(6, 10);// 年份
String strMonth = Ai.substring(10, 12);// ⽉份
String strDay = Ai.substring(12, 14);// ⽇期
if (isDate(strYear + "-" + strMonth + "-" + strDay) == false) {
tipInfo = INVALIDBIRTH;
return tipInfo;
}
GregorianCalendar gc = new GregorianCalendar();
SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd");
try {
if ((gc.get(Calendar.YEAR) - Integer.parseInt(strYear)) > 150
|| (gc.getTime().getTime() - s.parse(strYear + "-" + strMonth + "-" + strDay).getTime()) < 0) {
tipInfo = INVALIDSCOPE;
return tipInfo;
}
} catch (NumberFormatException e) {
e.printStackTrace();
} catch (ParseException e) {
e.printStackTrace();
}
if (Integer.parseInt(strMonth) > 12 || Integer.parseInt(strMonth) == 0) {
tipInfo = INVALIDMONTH;
return tipInfo;
}
if (Integer.parseInt(strDay) > 31 || Integer.parseInt(strDay) == 0) {
tipInfo = INVALIDDAY;
return tipInfo;
}
// 判断地区码是否有效
Hashtable<String, String> areacode = GetAreaCode();
// 如果⾝份证前两位的地区码不在Hashtable，则地区码有误
if ((Ai.substring(0, 2)) == null) {
tipInfo = CODINGERROR;
return tipInfo;
}
if (isVarifyCode(Ai, IDStr) == false) {
tipInfo = INVALIDCALIBRATION;
return tipInfo;
}
return tipInfo;
}
/*
* 判断第18位校验码是否正确第18位校验码的计算⽅式：
* 1. 对前17位数字本体码加权求和公式为：S = Sum(Ai * Wi), i =
* 0, ... , 16 其中Ai表⽰第i个位置上的⾝份证号码数字值，Wi表⽰第i位置上的加权因⼦，其各位对应的值依次为： 7 9 10 5 8 4
* 2 1 6 3 7 9 10 5 8 4 2
* 2. ⽤11对计算结果取模 Y = mod(S, 11)
* 3. 根据模的值得到对应的校验码
* 对应关系为： Y值： 0 1 2 3 4 5 6 7 8 9 10 校验码： 1 0 X 9 8 7 6 5 4 3 2
*/
private static boolean isVarifyCode(String Ai, String IDStr) {
String[] VarifyCode = { "1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2" };
String[] Wi = { "7", "9", "10", "5", "8", "4", "2", "1", "6", "3", "7", "9", "10", "5", "8", "4", "2" };
int sum = 0;
for (int i = 0; i < 17; i++) {
sum = sum + Integer.parseInt(String.valueOf(Ai.charAt(i))) * Integer.parseInt(Wi[i]);
}
int modValue = sum % 11;
String strVerifyCode = VarifyCode[modValue];
Ai = Ai + strVerifyCode;
if (IDStr.length() == 18) {
if (Ai.equals(IDStr) == false) {
return false;
}
}
return true;
}
/**
* 将所有地址编码保存在⼀个Hashtable中
* @return Hashtable 对象
*/
private static Hashtable<String, String> GetAreaCode() {
Hashtable<String, String> hashtable = new Hashtable<String, String>();
hashtable.put("11", "北京");
hashtable.put("12", "天津");
hashtable.put("13", "河北");
hashtable.put("14", "⼭西");
hashtable.put("15", "内蒙古");
hashtable.put("21", "辽宁");
hashtable.put("22", "吉林");
hashtable.put("23", "⿊龙江");
hashtable.put("31", "上海");
hashtable.put("32", "江苏");
hashtable.put("33", "浙江");
hashtable.put("34", "安徽");
hashtable.put("35", "福建");
hashtable.put("36", "江西");
hashtable.put("37", "⼭东");
hashtable.put("41", "河南");
hashtable.put("42", "湖北");
hashtable.put("43", "湖南");
hashtable.put("44", "⼴东");
hashtable.put("45", "⼴西");
hashtable.put("46", "海南");
hashtable.put("50", "重庆");
hashtable.put("51", "四川");
hashtable.put("52", "贵州");
hashtable.put("53", "云南");
hashtable.put("54", "西藏");
hashtable.put("61", "陕西");
hashtable.put("62", "⽢肃");
hashtable.put("63", "青海");
hashtable.put("64", "宁夏");
hashtable.put("65", "新疆");
hashtable.put("71", "台湾");
hashtable.put("81", "⾹港");
hashtable.put("82", "澳门");
hashtable.put("91", "国外");
return hashtable;
}
/**
* 判断字符串是否为数字,0-9重复0次或者多次
* @param strnum
* @return true, 符合; false, 不符合。
*/
private static boolean isNumeric(String strnum) {
Pattern pattern = Patternpile("[0-9]*");
Matcher isNum = pattern.matcher(strnum);
if (isNum.matches()) {
return true;
} else {
return false;
}
}
/**
* 功能：判断字符串出⽣⽇期是否符合正则表达式：包括年⽉⽇，闰年、平年和每⽉31天、30天和闰⽉的28天或者29天
* @return true, 符合; false, 不符合。
*/
public static boolean isDate(String strDate) {
Pattern pattern = Patternpile(
"^((\\d{2}(([02468][048])|([13579][26]))[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][1235679])|([13579][013457 Matcher m = pattern.matcher(strDate);
if (m.matches()) {
return true;
} else {
return false;
}
}
}
⾝份证号校验
IndexOrNameDataListener indexOrNameDataListener = new IndexOrNameDataListener();
if(!ValidateResult()){
for (ExcelErrorDTO excelErrorDTO : ErrorList()){
System.out.ErrMsg());
}
}
easyExcel 读取
参考:
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论