java 使用自定义注解实例

在使用若依框架中,看到自定义了一个注解。记录下自己的想法

自定义  Excel 注解类

 1 import java.lang.annotation.ElementType;
 2 import java.lang.annotation.Retention;
 3 import java.lang.annotation.RetentionPolicy;
 4 import java.lang.annotation.Target;
 5 
 6 /**
 7  * 自定义导出Excel数据注解
 8  * 
 9  * @author samgou
10  */
11 @Retention(RetentionPolicy.RUNTIME)
12 @Target(ElementType.FIELD)
13 public @interface Excel
14 {
15     /**
16      * 导出到Excel中的名字.
17      */
18     public String name();
19 
20     /**
21      * 日期格式, 如: yyyy-MM-dd
22      */
23     public String dateFormat() default "";
24 
25     /**
26      * 读取内容转表达式 (如: 0=男,1=女,2=未知)
27      */
28     public String readConverterExp() default "";
29 
30     /**
31      * 导出时在excel中每个列的高度 单位为字符
32      */
33     public double height() default 14;
34 
35     /**
36      * 导出时在excel中每个列的宽 单位为字符
37      */
38     public double width() default 20;
39 
40     /**
41      * 文字后缀,如% 90 变成90%
42      */
43     public String suffix() default "";
44 
45     /**
46      * 当值为空时,字段的默认值
47      */
48     public String defaultValue() default "";
49 
50     /**
51      * 提示信息
52      */
53     public String prompt() default "";
54 
55     /**
56      * 设置只能选择不能输入的列内容.
57      */
58     public String[] combo() default {};
59 
60     /**
61      * 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写.
62      */
63     public boolean isExport() default true;
64 }
View Code

业务代码:

  1 import java.io.File;
  2 import java.io.FileOutputStream;
  3 import java.io.IOException;
  4 import java.io.InputStream;
  5 import java.io.OutputStream;
  6 import java.lang.reflect.Field;
  7 import java.text.SimpleDateFormat;
  8 import java.util.ArrayList;
  9 import java.util.Date;
 10 import java.util.HashMap;
 11 import java.util.List;
 12 import java.util.Map;
 13 import java.util.UUID;
 14 import org.apache.poi.hssf.usermodel.DVConstraint;
 15 import org.apache.poi.hssf.usermodel.HSSFCell;
 16 import org.apache.poi.hssf.usermodel.HSSFCellStyle;
 17 import org.apache.poi.hssf.usermodel.HSSFDataValidation;
 18 import org.apache.poi.hssf.usermodel.HSSFFont;
 19 import org.apache.poi.hssf.usermodel.HSSFRow;
 20 import org.apache.poi.hssf.usermodel.HSSFSheet;
 21 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 22 import org.apache.poi.hssf.util.HSSFColor.HSSFColorPredefined;
 23 import org.apache.poi.ss.usermodel.Cell;
 24 import org.apache.poi.ss.usermodel.CellType;
 25 import org.apache.poi.ss.usermodel.FillPatternType;
 26 import org.apache.poi.ss.usermodel.HorizontalAlignment;
 27 import org.apache.poi.ss.usermodel.Row;
 28 import org.apache.poi.ss.usermodel.Sheet;
 29 import org.apache.poi.ss.usermodel.VerticalAlignment;
 30 import org.apache.poi.ss.usermodel.Workbook;
 31 import org.apache.poi.ss.usermodel.WorkbookFactory;
 32 import org.apache.poi.ss.util.CellRangeAddressList;
 33 import org.slf4j.Logger;
 34 import org.slf4j.LoggerFactory;
 35 import com.samgou.common.annotation.Excel;
 36 import com.samgou.common.base.AjaxResult;
 37 import com.samgou.common.config.Global;
 38 
 39 /**
 40  * Excel相关处理
 41  * 
 42  * @author samgou
 43  */
 44 public class ExcelUtil<T>
 45 {
 46     private static final Logger log = LoggerFactory.getLogger(ExcelUtil.class);
 47 
 48     public Class<T> clazz;
 49 
 50     public ExcelUtil(Class<T> clazz)
 51     {
 52         this.clazz = clazz;
 53     }
 54 
 55     /**
 56      * 对excel表单默认第一个索引名转换成list
 57      * 
 58      * @param input 输入流
 59      * @return 转换后集合
 60      */
 61     public List<T> importExcel(InputStream input) throws Exception
 62     {
 63         return importExcel(StringUtils.EMPTY, input);
 64     }
 65 
 66     /**
 67      * 对excel表单指定表格索引名转换成list
 68      * 
 69      * @param sheetName 表格索引名
 70      * @param input 输入流
 71      * @return 转换后集合
 72      */
 73     public List<T> importExcel(String sheetName, InputStream input) throws Exception
 74     {
 75         List<T> list = new ArrayList<T>();
 76 
 77         Workbook workbook = WorkbookFactory.create(input);
 78         Sheet sheet = null;
 79         if (StringUtils.isNotEmpty(sheetName))
 80         {
 81             // 如果指定sheet名,则取指定sheet中的内容.
 82             sheet = workbook.getSheet(sheetName);
 83         }
 84         else
 85         {
 86             // 如果传入的sheet名不存在则默认指向第1个sheet.
 87             sheet = workbook.getSheetAt(0);
 88         }
 89 
 90         if (sheet == null)
 91         {
 92             throw new IOException("文件sheet不存在");
 93         }
 94 
 95         int rows = sheet.getPhysicalNumberOfRows();
 96 
 97         if (rows > 0)
 98         {
 99             // 默认序号
100             int serialNum = 0;
101             // 有数据时才处理 得到类的所有field.
102             Field[] allFields = clazz.getDeclaredFields();
103             // 定义一个map用于存放列的序号和field.
104             Map<Integer, Field> fieldsMap = new HashMap<Integer, Field>();
105             for (int col = 0; col < allFields.length; col++)
106             {
107                 Field field = allFields[col];
108                 // 将有注解的field存放到map中.
109                 if (field.isAnnotationPresent(Excel.class))
110                 {
111                     // 设置类的私有字段属性可访问.
112                     field.setAccessible(true);
113                     fieldsMap.put(++serialNum, field);
114                 }
115             }
116             for (int i = 1; i < rows; i++)
117             {
118                 // 从第2行开始取数据,默认第一行是表头.
119                 Row row = sheet.getRow(i);
120                 int cellNum = serialNum;
121                 T entity = null;
122                 for (int j = 0; j < cellNum; j++)
123                 {
124                     Cell cell = row.getCell(j);
125                     if (cell == null)
126                     {
127                         continue;
128                     }
129                     else
130                     {
131                         // 先设置Cell的类型,然后就可以把纯数字作为String类型读进来了
132                         row.getCell(j).setCellType(CellType.STRING);
133                         cell = row.getCell(j);
134                     }
135 
136                     String c = cell.getStringCellValue();
137                     if (StringUtils.isEmpty(c))
138                     {
139                         continue;
140                     }
141 
142                     // 如果不存在实例则新建.
143                     entity = (entity == null ? clazz.newInstance() : entity);
144                     // 从map中得到对应列的field.
145                     Field field = fieldsMap.get(j + 1);
146                     // 取得类型,并根据对象类型设置值.
147                     Class<?> fieldType = field.getType();
148                     if (String.class == fieldType)
149                     {
150                         field.set(entity, String.valueOf(c));
151                     }
152                     else if ((Integer.TYPE == fieldType) || (Integer.class == fieldType))
153                     {
154                         field.set(entity, Integer.parseInt(c));
155                     }
156                     else if ((Long.TYPE == fieldType) || (Long.class == fieldType))
157                     {
158                         field.set(entity, Long.valueOf(c));
159                     }
160                     else if ((Float.TYPE == fieldType) || (Float.class == fieldType))
161                     {
162                         field.set(entity, Float.valueOf(c));
163                     }
164                     else if ((Short.TYPE == fieldType) || (Short.class == fieldType))
165                     {
166                         field.set(entity, Short.valueOf(c));
167                     }
168                     else if ((Double.TYPE == fieldType) || (Double.class == fieldType))
169                     {
170                         field.set(entity, Double.valueOf(c));
171                     }
172                     else if (Character.TYPE == fieldType)
173                     {
174                         if ((c != null) && (c.length() > 0))
175                         {
176                             field.set(entity, Character.valueOf(c.charAt(0)));
177                         }
178                     }
179                     else if (java.util.Date.class == fieldType)
180                     {
181                         if (cell.getCellTypeEnum() == CellType.NUMERIC)
182                         {
183                             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
184                             cell.setCellValue(sdf.format(cell.getNumericCellValue()));
185                             c = sdf.format(cell.getNumericCellValue());
186                         }
187                         else
188                         {
189                             c = cell.getStringCellValue();
190                         }
191                     }
192                     else if (java.math.BigDecimal.class == fieldType)
193                     {
194                         c = cell.getStringCellValue();
195                     }
196                 }
197                 if (entity != null)
198                 {
199                     list.add(entity);
200                 }
201             }
202         }
203 
204         return list;
205     }
206 
207     /**
208      * 对list数据源将其里面的数据导入到excel表单
209      * 
210      * @param list 导出数据集合
211      * @param sheetName 工作表的名称
212      * @return 结果
213      */
214     public AjaxResult exportExcel(List<T> list, String sheetName)
215     {
216         OutputStream out = null;
217         HSSFWorkbook workbook = null;
218         try
219         {
220             // 得到所有定义字段
221             Field[] allFields = clazz.getDeclaredFields();
222             List<Field> fields = new ArrayList<Field>();
223             // 得到所有field并存放到一个list中.
224             for (Field field : allFields)
225             {
226                 //如果有添加excel标签,就放到list上面
227                 if (field.isAnnotationPresent(Excel.class))
228                 {
229                     fields.add(field);
230                 }
231             }
232 
233             // 产生工作薄对象
234             workbook = new HSSFWorkbook();
235             // excel2003中每个sheet中最多有65536行
236             int sheetSize = 65536;
237             // 取出一共有多少个sheet.
238             double sheetNo = Math.ceil(list.size() / sheetSize);
239             for (int index = 0; index <= sheetNo; index++)
240             {
241                 // 产生工作表对象
242                 HSSFSheet sheet = workbook.createSheet();
243                 if (sheetNo == 0)
244                 {
245                     workbook.setSheetName(index, sheetName);
246                 }
247                 else
248                 {
249                     // 设置工作表的名称.
250                     workbook.setSheetName(index, sheetName + index);
251                 }
252                 HSSFRow row;
253                 HSSFCell cell; // 产生单元格
254 
255                 // 产生一行
256                 row = sheet.createRow(0);
257                 // 写入各个字段的列头名称
258                 for (int i = 0; i < fields.size(); i++)
259                 {
260                     Field field = fields.get(i);
261                     Excel attr = field.getAnnotation(Excel.class);
262                     // 创建列
263                     cell = row.createCell(i);
264                     // 设置列中写入内容为String类型
265                     cell.setCellType(CellType.STRING);
266                     HSSFCellStyle cellStyle = workbook.createCellStyle();
267                     cellStyle.setAlignment(HorizontalAlignment.CENTER);
268                     cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
269                     if (attr.name().indexOf("注:") >= 0)
270                     {
271                         HSSFFont font = workbook.createFont();
272                         font.setColor(HSSFFont.COLOR_RED);
273                         cellStyle.setFont(font);
274                         cellStyle.setFillForegroundColor(HSSFColorPredefined.YELLOW.getIndex());
275                         sheet.setColumnWidth(i, 6000);
276                     }
277                     else
278                     {
279                         HSSFFont font = workbook.createFont();
280                         // 粗体显示
281                         font.setBold(true);
282                         // 选择需要用到的字体格式
283                         cellStyle.setFont(font);
284                         cellStyle.setFillForegroundColor(HSSFColorPredefined.LIGHT_YELLOW.getIndex());
285                         // 设置列宽
286                         sheet.setColumnWidth(i, (int) ((attr.width() + 0.72) * 256));
287                         row.setHeight((short) (attr.height() * 20));
288                     }
289                     cellStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
290                     cellStyle.setWrapText(true);
291                     cell.setCellStyle(cellStyle);
292 
293                     // 写入列名
294                     cell.setCellValue(attr.name());
295 
296                     // 如果设置了提示信息则鼠标放上去提示.
297                     if (StringUtils.isNotEmpty(attr.prompt()))
298                     {
299                         // 这里默认设了2-101列提示.
300                         setHSSFPrompt(sheet, "", attr.prompt(), 1, 100, i, i);
301                     }
302                     // 如果设置了combo属性则本列只能选择不能输入
303                     if (attr.combo().length > 0)
304                     {
305                         // 这里默认设了2-101列只能选择不能输入.
306                         setHSSFValidation(sheet, attr.combo(), 1, 100, i, i);
307                     }
308                 }
309 
310                 int startNo = index * sheetSize;
311                 int endNo = Math.min(startNo + sheetSize, list.size());
312                 // 写入各条记录,每条记录对应excel表中的一行
313                 HSSFCellStyle cs = workbook.createCellStyle();
314                 cs.setAlignment(HorizontalAlignment.CENTER);
315                 cs.setVerticalAlignment(VerticalAlignment.CENTER);
316                 for (int i = startNo; i < endNo; i++)
317                 {
318                     row = sheet.createRow(i + 1 - startNo);
319                     // 得到导出对象.
320                     T vo = (T) list.get(i);
321                     for (int j = 0; j < fields.size(); j++)
322                     {
323                         // 获得field.
324                         Field field = fields.get(j);
325                         // 设置实体类私有属性可访问
326                         field.setAccessible(true);
327                         Excel attr = field.getAnnotation(Excel.class);
328                         try
329                         {
330                             // 设置行高
331                             row.setHeight((short) (attr.height() * 20));
332                             // 根据Excel中设置情况决定是否导出,有些情况需要保持为空,希望用户填写这一列.
333                             if (attr.isExport())
334                             {
335                                 // 创建cell
336                                 cell = row.createCell(j);
337                                 cell.setCellStyle(cs);
338                                 if (vo == null)
339                                 {
340                                     // 如果数据存在就填入,不存在填入空格.
341                                     cell.setCellValue("");
342                                     continue;
343                                 }
344 
345                                 String dateFormat = attr.dateFormat();
346                                 String readConverterExp = attr.readConverterExp();
347                                 if (StringUtils.isNotEmpty(dateFormat))
348                                 {
349                                     cell.setCellValue(DateUtils.parseDateToStr(dateFormat, (Date) field.get(vo)));
350                                 }
351                                 else if (StringUtils.isNotEmpty(readConverterExp))
352                                 {
353                                     cell.setCellValue(convertByExp(String.valueOf(field.get(vo)), readConverterExp));
354                                 }
355                                 else
356                                 {
357                                     cell.setCellType(CellType.STRING);
358                                     // 如果数据存在就填入,不存在填入空格.
359                                     cell.setCellValue(StringUtils.isNull(field.get(vo)) ? attr.defaultValue() : field.get(vo) + attr.suffix());
360                                 }
361                             }
362                         }
363                         catch (Exception e)
364                         {
365                             log.error("导出Excel失败{}", e.getMessage());
366                         }
367                     }
368                 }
369             }
370             String filename = encodingFilename(sheetName);
371             out = new FileOutputStream(getAbsoluteFile(filename));
372             //写出到硬盘
373             workbook.write(out);
374             return AjaxResult.success(filename);
375         }
376         catch (Exception e)
377         {
378             log.error("导出Excel异常{}", e.getMessage());
379             return AjaxResult.error("导出Excel失败,请联系网站管理员!");
380         }
381         finally
382         {
383             if (workbook != null)
384             {
385                 try
386                 {
387                     workbook.close();
388                 }
389                 catch (IOException e1)
390                 {
391                     e1.printStackTrace();
392                 }
393             }
394             if (out != null)
395             {
396                 try
397                 {
398                     out.close();
399                 }
400                 catch (IOException e1)
401                 {
402                     e1.printStackTrace();
403                 }
404             }
405         }
406     }
407 
408     /**
409      * 设置单元格上提示
410      * 
411      * @param sheet 要设置的sheet.
412      * @param promptTitle 标题
413      * @param promptContent 内容
414      * @param firstRow 开始行
415      * @param endRow 结束行
416      * @param firstCol 开始列
417      * @param endCol 结束列
418      * @return 设置好的sheet.
419      */
420     public static HSSFSheet setHSSFPrompt(HSSFSheet sheet, String promptTitle, String promptContent, int firstRow,
421             int endRow, int firstCol, int endCol)
422     {
423         // 构造constraint对象
424         DVConstraint constraint = DVConstraint.createCustomFormulaConstraint("DD1");
425         // 四个参数分别是:起始行、终止行、起始列、终止列
426         CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
427         // 数据有效性对象
428         HSSFDataValidation dataValidationView = new HSSFDataValidation(regions, constraint);
429         dataValidationView.createPromptBox(promptTitle, promptContent);
430         sheet.addValidationData(dataValidationView);
431         return sheet;
432     }
433 
434     /**
435      * 设置某些列的值只能输入预制的数据,显示下拉框.
436      * 
437      * @param sheet 要设置的sheet.
438      * @param textlist 下拉框显示的内容
439      * @param firstRow 开始行
440      * @param endRow 结束行
441      * @param firstCol 开始列
442      * @param endCol 结束列
443      * @return 设置好的sheet.
444      */
445     public static HSSFSheet setHSSFValidation(HSSFSheet sheet, String[] textlist, int firstRow, int endRow,
446             int firstCol, int endCol)
447     {
448         // 加载下拉列表内容
449         DVConstraint constraint = DVConstraint.createExplicitListConstraint(textlist);
450         // 设置数据有效性加载在哪个单元格上,四个参数分别是:起始行、终止行、起始列、终止列
451         CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
452         // 数据有效性对象
453         HSSFDataValidation dataValidationList = new HSSFDataValidation(regions, constraint);
454         sheet.addValidationData(dataValidationList);
455         return sheet;
456     }
457     
458     /**
459      * 解析导出值 0=男,1=女,2=未知
460      * 
461      * @param propertyValue 参数值
462      * @param converterExp 翻译注解
463      * @return 解析后值
464      * @throws Exception
465      */
466     public static String convertByExp(String propertyValue, String converterExp) throws Exception
467     {
468         try
469         {
470             String[] convertSource = converterExp.split(",");
471             for (String item : convertSource)
472             {
473                 String[] itemArray = item.split("=");
474                 if (itemArray[0].equals(propertyValue))
475                 {
476                     return itemArray[1];
477                 }
478             }
479         }
480         catch (Exception e)
481         {
482             throw e;
483         }
484         return propertyValue;
485     }
486 
487     /**
488      * 编码文件名
489      */
490     public String encodingFilename(String filename)
491     {
492         filename = UUID.randomUUID().toString() + "_" + filename + ".xls";
493         return filename;
494     }
495 
496     /**
497      * 获取下载路径
498      * 
499      * @param filename 文件名称
500      */
501     public String getAbsoluteFile(String filename)
502     {
503         String downloadPath = Global.getDownloadPath() + filename;
504         File desc = new File(downloadPath);
505         if (!desc.getParentFile().exists())
506         {
507             desc.getParentFile().mkdirs();
508         }
509         return downloadPath;
510     }
511 }
View Code

关键代码:

 1 // 得到所有定义字段
 2             Field[] allFields = clazz.getDeclaredFields();
 3             List<Field> fields = new ArrayList<Field>();
 4             // 得到所有field并存放到一个list中.
 5             for (Field field : allFields)
 6             {
 7                 //如果有添加excel标签,就放到list上面
 8                 if (field.isAnnotationPresent(Excel.class))
 9                 {
10                     fields.add(field);
11                 }
12             }

第2行 通过反射,获得类的所有属性https://blog.csdn.net/u014102846/article/details/81481126

第8行 判断 该类的某个属性,是否使用了 Excel 注解,如果有就导出。这样我们在定义类的时候,如果某属性需要导出,则使用该注解就可以了

例如:SysUser.java

  1 import org.apache.commons.lang3.builder.ToStringBuilder;
  2 import org.apache.commons.lang3.builder.ToStringStyle;
  3 import java.util.Date;
  4 import java.util.List;
  5 import com.samgou.common.annotation.Excel;
  6 import com.samgou.common.base.BaseEntity;
  7 import com.samgou.common.utils.StringUtils;
  8 
  9 /**
 10  * 用户对象 sys_user
 11  * 
 12  * @author samgou
 13  */
 14 public class SysUser extends BaseEntity
 15 {
 16     private static final long serialVersionUID = 1L;
 17 
 18     /** 用户ID */
 19     @Excel(name = "用户序号")
 20     private Long userId;
 21 
 22     /** 部门ID */
 23     private Long deptId;
 24 
 25     /** 部门父ID */
 26     private Long parentId;
 27 
 28     /** 登录名称 */
 29     @Excel(name = "登录名称")
 30     private String loginName;
 31 
 32     /** 用户名称 */
 33     @Excel(name = "用户名称")
 34     private String userName;
 35 
 36     /** 用户邮箱 */
 37     @Excel(name = "用户邮箱")
 38     private String email;
 39 
 40     /** 手机号码 */
 41     @Excel(name = "手机号码")
 42     private String phonenumber;
 43 
 44     /** 用户性别 */
 45     @Excel(name = "用户性别", readConverterExp = "0=男,1=女,2=未知")
 46     private String sex;
 47 
 48     /** 用户头像 */
 49     private String avatar;
 50 
 51     /** 密码 */
 52     private String password;
 53 
 54     /** 盐加密 */
 55     private String salt;
 56 
 57     /** 帐号状态(0正常 1停用) */
 58     @Excel(name = "帐号状态", readConverterExp = "0=正常,1=停用")
 59     private String status;
 60 
 61     /** 删除标志(0代表存在 2代表删除) */
 62     private String delFlag;
 63 
 64     /** 最后登陆IP */
 65     @Excel(name = "最后登陆IP")
 66     private String loginIp;
 67 
 68     /** 最后登陆时间 */
 69     @Excel(name = "最后登陆时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss")
 70     private Date loginDate;
 71 
 72     /** 部门对象 */
 73     private SysDept dept;
 74 
 75     private List<SysRole> roles;
 76 
 77     /** 角色组 */
 78     private Long[] roleIds;
 79 
 80     /** 岗位组 */
 81     private Long[] postIds;
 82 
 83     public Long getUserId()
 84     {
 85         return userId;
 86     }
 87 
 88     public void setUserId(Long userId)
 89     {
 90         this.userId = userId;
 91     }
 92 
 93     public boolean isAdmin()
 94     {
 95         return isAdmin(this.userId);
 96     }
 97 
 98     public static boolean isAdmin(Long userId)
 99     {
100         return userId != null && 1L == userId;
101     }
102 
103     public Long getDeptId()
104     {
105         return deptId;
106     }
107 
108     public void setDeptId(Long deptId)
109     {
110         this.deptId = deptId;
111     }
112 
113     public Long getParentId()
114     {
115         return parentId;
116     }
117 
118     public void setParentId(Long parentId)
119     {
120         this.parentId = parentId;
121     }
122 
123     public String getLoginName()
124     {
125         return loginName;
126     }
127 
128     public void setLoginName(String loginName)
129     {
130         this.loginName = loginName;
131     }
132 
133     public String getUserName()
134     {
135         return userName;
136     }
137 
138     public void setUserName(String userName)
139     {
140         this.userName = userName;
141     }
142 
143     public String getEmail()
144     {
145         return email;
146     }
147 
148     public void setEmail(String email)
149     {
150         this.email = email;
151     }
152 
153     public String getPhonenumber()
154     {
155         return phonenumber;
156     }
157 
158     public void setPhonenumber(String phonenumber)
159     {
160         this.phonenumber = phonenumber;
161     }
162 
163     public String getSex()
164     {
165         return sex;
166     }
167 
168     public void setSex(String sex)
169     {
170         this.sex = sex;
171     }
172 
173     public String getAvatar()
174     {
175         if (StringUtils.isEmpty(avatar))
176         {
177             return StringUtils.EMPTY;
178         }
179         else
180         {
181             return avatar;
182         }
183     }
184 
185     public void setAvatar(String avatar)
186     {
187         this.avatar = avatar;
188     }
189 
190     public String getPassword()
191     {
192         return password;
193     }
194 
195     public void setPassword(String password)
196     {
197         this.password = password;
198     }
199 
200     public String getSalt()
201     {
202         return salt;
203     }
204 
205     public void setSalt(String salt)
206     {
207         this.salt = salt;
208     }
209 
210     public String getStatus()
211     {
212         return status;
213     }
214 
215     public void setStatus(String status)
216     {
217         this.status = status;
218     }
219 
220     public String getDelFlag()
221     {
222         return delFlag;
223     }
224 
225     public void setDelFlag(String delFlag)
226     {
227         this.delFlag = delFlag;
228     }
229 
230     public String getLoginIp()
231     {
232         return loginIp;
233     }
234 
235     public void setLoginIp(String loginIp)
236     {
237         this.loginIp = loginIp;
238     }
239 
240     public Date getLoginDate()
241     {
242         return loginDate;
243     }
244 
245     public void setLoginDate(Date loginDate)
246     {
247         this.loginDate = loginDate;
248     }
249 
250     public SysDept getDept()
251     {
252         return dept;
253     }
254 
255     public void setDept(SysDept dept)
256     {
257         this.dept = dept;
258     }
259 
260     public List<SysRole> getRoles()
261     {
262         return roles;
263     }
264 
265     public void setRoles(List<SysRole> roles)
266     {
267         this.roles = roles;
268     }
269 
270     public Long[] getRoleIds()
271     {
272         return roleIds;
273     }
274 
275     public void setRoleIds(Long[] roleIds)
276     {
277         this.roleIds = roleIds;
278     }
279 
280     public Long[] getPostIds()
281     {
282         return postIds;
283     }
284 
285     public void setPostIds(Long[] postIds)
286     {
287         this.postIds = postIds;
288     }
289 
290     @Override
291     public String toString() {
292         return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
293             .append("userId", getUserId())
294             .append("deptId", getDeptId())
295             .append("loginName", getLoginName())
296             .append("userName", getUserName())
297             .append("email", getEmail())
298             .append("phonenumber", getPhonenumber())
299             .append("sex", getSex())
300             .append("avatar", getAvatar())
301             .append("password", getPassword())
302             .append("salt", getSalt())
303             .append("status", getStatus())
304             .append("delFlag", getDelFlag())
305             .append("loginIp", getLoginIp())
306             .append("loginDate", getLoginDate())
307             .append("createBy", getCreateBy())
308             .append("createTime", getCreateTime())
309             .append("updateBy", getUpdateBy())
310             .append("updateTime", getUpdateTime())
311             .append("remark", getRemark())
312             .toString();
313     }
314 }
View Code

 

如果不使用注解的话,业务代码就需要传入 Excel表格列的参数和对应的属性,这样一来就比较麻烦了

posted @ 2019-12-17 10:59  wullll  阅读(426)  评论(0编辑  收藏  举报