├── .idea
    ├── compiler.xml
    └── misc.xml
├── README.md
├── excelutils.iml
├── pom.xml
└── src
    └── main
        └── java
            └── com
                └── jenkin
                    └── excel
                        ├── ExcelUtils.java
                        ├── anno
                            ├── EnableExport.java
                            ├── EnableExportField.java
                            ├── EnableSelectList.java
                            └── ImportIndex.java
                        └── enums
                            └── ColorEnum.java


/.idea/compiler.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project version="4">
 3 |   <component name="CompilerConfiguration">
 4 |     <annotationProcessing>
 5 |       <profile name="Maven default annotation processors profile" enabled="true">
 6 |         <sourceOutputDir name="target/generated-sources/annotations" />
 7 |         <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
 8 |         <outputRelativeToContentRoot value="true" />
 9 |         <module name="excelutils" />
10 |       </profile>
11 |     </annotationProcessing>
12 |   </component>
13 | </project>


--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project version="4">
 3 |   <component name="ExternalStorageConfigurationManager" enabled="true" />
 4 |   <component name="MavenProjectsManager">
 5 |     <option name="originalFiles">
 6 |       <list>
 7 |         <option value="$PROJECT_DIR$/pom.xml" />
 8 |       </list>
 9 |     </option>
10 |   </component>
11 |   <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="1.8" project-jdk-type="JavaSDK">
12 |     <output url="file://$PROJECT_DIR$/out" />
13 |   </component>
14 | </project>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # excelutils
 2 | # 一个通用的Excel导入导出工具
 3 | 使用ExcelUtils里面的parseExcelToList方法进行导入
 4 | 使用ExcelUtils里面的exportExcel方法进行导出
 5 | 
 6 | 以下四个注解是导入导出的实体类需要依赖的注解
 7 | EnableExport
 8 | 该注解使用在类上，设置允许导入导出
 9 | EnableExportField
10 | 该注解设置在字段上，设置允许导出该字段，并且可以设置宽度，标题名，背景颜色
11 | EnableSelectList
12 | 该注解设置在字段上，设置是否使用下拉列表
13 | ImportIndex
14 | 该注解设置在字段上，设置允许导入，并且设置导入时对应的Excel列索引
15 | 
16 | ColorEnum
17 | 该枚举是一个颜色枚举，里面有一些常用颜色
18 | 
19 |  
20 |     使用示例：
21 |     实体类：
22 |     @EnableExport(fileName = "")
23 |     public class SlrEmpSalary implements Serializable {
24 |     @ImportIndex(index = 0)
25 |       @EnableExportField(colName = "序号", colWidth = 80)
26 |       private int seqNumber;
27 |       @ImportIndex(index = 1)
28 |       @EnableExportField(colName = "员工编号", colWidth = 160,cellColor = ColorEnum.RED)
29 |       private String employeeCode;
30 |       @ImportIndex(index = 2)
31 |       @EnableExportField(colName = "员工姓名", colWidth = 160)
32 |       private String employeeName;}
33 |     
34 |     导入使用方法：
35 |     //文件输入流
36 |      inputStream =uploadedFile.getInputStream();
37 |      //获取对象集合
38 |      List< SlrEmpSalary> empSalaryList =
39 |                 (List< SlrEmpSalary>)ExcelUtils.parseExcelToList(inputStream,  SlrEmpSalary.class);
40 |                 
41 |      导出使用方法：
42 |      //导出数据
43 |      List< SlrEmpSalary> dataList = new ArrayList<SlrEmpSalary>();
44 |      //导出
45 |      FileUtils.exportExcel(outputStream, dataList,  SlrEmpSalary.class, Const.ALL_SELECT_LIST_MAP, exportTitle);
46 |                 
47 |                 
48 |                 
49 |     
50 |     
51 |     
52 | 


--------------------------------------------------------------------------------
/excelutils.iml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <module type="JAVA_MODULE" version="4" />


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://maven.apache.org/POM/4.0.0"
 3 |          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5 |     <modelVersion>4.0.0</modelVersion>
 6 | 
 7 |     <groupId>com.jenkin.excel</groupId>
 8 |     <artifactId>excel-utils</artifactId>
 9 |     <version>1.0-SNAPSHOT</version>
10 |     <dependencies>
11 | 
12 |     <!--进行数据解析Fastjson会自动处理对象中的泛型，将其解析成原来定义好的对象， -->
13 |     <dependency>
14 |         <groupId>com.alibaba</groupId>
15 |         <artifactId>fastjson</artifactId>
16 |         <version>1.1.41</version>
17 |     </dependency>
18 |     <!-- 引入poi，解析workbook视图 -->
19 |     <dependency>
20 |         <groupId>org.apache.poi</groupId>
21 |         <artifactId>poi</artifactId>
22 |         <version>3.8</version>
23 |     </dependency>
24 |     <dependency>
25 |         <groupId>org.apache.poi</groupId>
26 |         <artifactId>poi-ooxml</artifactId>
27 |         <version>3.8</version>
28 |     </dependency>
29 | 
30 |     </dependencies>
31 | 
32 | </project>


--------------------------------------------------------------------------------
/src/main/java/com/jenkin/excel/ExcelUtils.java:
--------------------------------------------------------------------------------
  1 | package com.jenkin.excel;
  2 | 
  3 | import com.alibaba.fastjson.util.TypeUtils;
  4 | 
  5 | 
  6 | import com.jenkin.excel.anno.EnableExport;
  7 | import com.jenkin.excel.anno.EnableExportField;
  8 | import com.jenkin.excel.anno.EnableSelectList;
  9 | import com.jenkin.excel.anno.ImportIndex;
 10 | import com.jenkin.excel.enums.ColorEnum;
 11 | import org.apache.poi.hssf.usermodel.*;
 12 | import org.apache.poi.ss.usermodel.*;
 13 | import org.apache.poi.ss.util.CellRangeAddress;
 14 | import org.apache.poi.ss.util.CellRangeAddressList;
 15 | import org.apache.poi.ss.util.RegionUtil;
 16 | import org.apache.poi.xssf.usermodel.XSSFDataValidation;
 17 | import java.io.*;
 18 | import java.lang.reflect.Field;
 19 | import java.lang.reflect.InvocationTargetException;
 20 | import java.lang.reflect.Method;
 21 | 
 22 | import java.util.ArrayList;
 23 | import java.util.HashMap;
 24 | import java.util.List;
 25 | import java.util.Map;
 26 | import java.util.regex.Matcher;
 27 | import java.util.regex.Pattern;
 28 | import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
 29 | public class ExcelUtils {
 30 |     /**  所有的下拉列表数据存在这个map中，key是对应的Excel列的序号，从0开始，value为下拉列表键对值 **/
 31 |     public static final  Map<Integer,Map<String,String>> ALL_SELECT_LIST_MAP = new HashMap<Integer,Map<String,String>> ();
 32 |         /**
 33 |          * 将Excel转换为对象集合
 34 |          * @param excel Excel 文件
 35 |          * @param clazz pojo类型
 36 |          * @return
 37 |          */
 38 |         public static List<?> parseExcelToList(File excel,Class clazz){
 39 |             List<Object> res = new ArrayList<Object>();
 40 |             // 创建输入流，读取Excel
 41 |             InputStream is = null;
 42 |             Sheet sheet = null;
 43 |             try {
 44 |                 is = new FileInputStream(excel.getAbsolutePath());
 45 |                 if (is != null) {
 46 |                     Workbook workbook = WorkbookFactory.create(is);
 47 |                     //默认只获取第一个工作表
 48 |                     sheet = workbook.getSheetAt(0);
 49 |                     if (sheet != null) {
 50 |                         int i = 2;
 51 |                         String values[] ;
 52 |                         Row row = sheet.getRow(i);
 53 |                         while (row != null) {
 54 |                             //获取单元格数目
 55 |                             int cellNum = row.getPhysicalNumberOfCells();
 56 |                             values = new String[cellNum];
 57 |                             for (int j = 0; j <= cellNum; j++) {
 58 |                                 Cell cell =   row.getCell(j);
 59 |                                 if (cell != null) {
 60 |                                     //设置单元格内容类型
 61 |                                     cell.setCellType(Cell.CELL_TYPE_STRING );
 62 |                                     //获取单元格值
 63 |                                     String value = cell.getStringCellValue() == null ? null : cell.getStringCellValue();
 64 |                                     values[j]=value;
 65 |                                 }
 66 |                             }
 67 |                             Field[] fields = clazz.getDeclaredFields();
 68 |                             Object obj = clazz.newInstance();
 69 |                             for(Field f : fields){
 70 |                                 if(f.isAnnotationPresent(ImportIndex.class)){
 71 |                                     ImportIndex annotation = f.getAnnotation(ImportIndex.class);
 72 |                                     int index = annotation.index();
 73 |                                     String useSetMethodName = annotation.useSetMethodName();
 74 |                                     if(!"".equals(useSetMethodName)){
 75 |                                         Object val =TypeUtils.cast(values[index],f.getType(),null);
 76 |                                         f.setAccessible(true);
 77 |                                         Method method = clazz.getMethod(useSetMethodName, new Class[]{f.getType(),Object.class});
 78 |                                         method.setAccessible(true);
 79 |                                         method.invoke(obj, new Object[]{f.get(obj),val});
 80 |                                     }else{
 81 |                                         f.setAccessible(true);
 82 |                                         Object val =TypeUtils.cast(values[index],f.getType(),null);
 83 |                                         f.set(obj,val);
 84 |                                     }
 85 |                                 }
 86 |                             }
 87 |                             res.add(obj);
 88 |                             i++;
 89 |                             row=sheet.getRow(i);
 90 |                         }
 91 |                     }
 92 |                 }
 93 |             } catch (Exception e) {
 94 |                 e.printStackTrace();
 95 |             }
 96 |             return res;
 97 |         }
 98 | 
 99 |         /**
100 |          * 将Excel转换为对象集合
101 |          * @param excel Excel 文件输入流
102 |          * @param clazz pojo类型
103 |          * @return
104 |          */
105 |         public static List<?> parseExcelToList(InputStream excel,Class clazz) throws IOException,
106 |                 InvalidFormatException,
107 |                 InstantiationException,
108 |                 IllegalAccessException,
109 |                 NoSuchMethodException,
110 |                 InvocationTargetException {
111 |             List<Object> res = new ArrayList<Object>();
112 |             // 创建输入流，读取Excel
113 |             InputStream is = null;
114 |             Sheet sheet = null;
115 | 
116 |             is = excel;
117 |             if (is != null) {
118 |                 Workbook workbook = WorkbookFactory.create(is);
119 |                 //默认只获取第一个工作表
120 |                 sheet = workbook.getSheetAt(0);
121 |                 if (sheet != null) {
122 |                     int i = 2;
123 |                     String values[] ;
124 |                     Row row = sheet.getRow(i);
125 |                     while (row != null) {
126 |                         //获取单元格数目
127 |                         int cellNum = row.getPhysicalNumberOfCells();
128 |                         values = new String[cellNum];
129 |                         for (int j = 0; j <= cellNum; j++) {
130 |                             Cell cell =   row.getCell(j);
131 |                             if (cell != null) {
132 |                                 //设置单元格内容类型
133 |                                 cell.setCellType(Cell.CELL_TYPE_STRING );
134 |                                 //获取单元格值
135 |                                 String value = cell.getStringCellValue() == null ? null : cell.getStringCellValue();
136 |                                 values[j]=value;
137 |                             }
138 |                         }
139 |                         Field[] fields = clazz.getDeclaredFields();
140 |                         Object obj = clazz.newInstance();
141 |                         for(Field f : fields){
142 |                             if(f.isAnnotationPresent(ImportIndex.class)){
143 | 
144 |                                 ImportIndex annotation = f.getAnnotation(ImportIndex.class);
145 |                                 int index = annotation.index();
146 |                                 Object value = values[index];
147 |                                 if(f.isAnnotationPresent(EnableSelectList.class)){
148 | 
149 |                                     value = getKeyByValue(ALL_SELECT_LIST_MAP.get(index),String.valueOf(value ) );
150 | 
151 |                                 }
152 |                                 String useSetMethodName = annotation.useSetMethodName();
153 |                                 if(!"".equals(useSetMethodName)){
154 |                                     Object val =TypeUtils.cast(value,f.getType(),null);
155 |                                     f.setAccessible(true);
156 |                                     Method method = clazz.getMethod(useSetMethodName, new Class[]{f.getType(),Object.class});
157 |                                     method.setAccessible(true);
158 |                                     method.invoke(obj, new Object[]{f.get(obj),val});
159 |                                 }else{
160 |                                     f.setAccessible(true);
161 |                                     Object val =TypeUtils.cast(value,f.getType(),null);
162 |                                     f.set(obj,val);
163 |                                 }
164 | 
165 |                             }
166 |                         }
167 |                         res.add(obj);
168 |                         i++;
169 |                         row=sheet.getRow(i);
170 |                     }
171 |                 }
172 |             }
173 | 
174 |             return res;
175 |         }
176 | 
177 |         /**
178 |          * 导出 Excel
179 |          * @param outputStream 输出流，用于写文件
180 |          * @param dataList 需要导出的数据
181 |          * @param clazz 导出数据的pojo类型
182 |          * @param selectListMap 下拉列表的列
183 |          * @param exportTitle 当该参数不为空则替换默认的标题
184 |          */
185 |         public static void exportExcel(OutputStream outputStream, List  dataList, Class clazz, Map<Integer,Map<String,String>> selectListMap,String exportTitle){
186 |             //创建一个Excel工作簿
187 |             HSSFWorkbook workbook = new HSSFWorkbook();
188 |             //建立表
189 |             HSSFSheet hssfsheet =  workbook.createSheet();
190 | 
191 |             hssfsheet.setDefaultRowHeight( ( short )(20*20) );
192 |             //检查当前pojo是否允许导出
193 |             if(clazz.isAnnotationPresent(EnableExport.class)) {
194 |                 EnableExport export = (EnableExport) clazz.getAnnotation(EnableExport.class);
195 |                 //获取所有标题名称
196 |                 List<String> colNames =new ArrayList<String>();
197 |                 //获取所有标题的背景颜色
198 |                 List<ColorEnum> colors =new ArrayList<ColorEnum>();
199 |                 //所有允许导出的字段
200 |                 List<Field> fieldList = new ArrayList<Field>();
201 |                 for(Field field : clazz.getDeclaredFields()){
202 |                     if(field.isAnnotationPresent(EnableExportField.class)){
203 |                         EnableExportField enableExportField = field.getAnnotation(EnableExportField.class);
204 |                         colNames.add(enableExportField.colName());
205 |                         colors.add(enableExportField.cellColor());
206 |                         fieldList.add(field);
207 |                     }
208 |                 }
209 |                 //设置每列的宽度
210 |                 for(int i=0;i<fieldList.size();i++){
211 |                     Field field = fieldList.get(i);
212 |                     hssfsheet.setColumnWidth(i,field.getAnnotation(EnableExportField.class).colWidth()*20);
213 |                 }
214 | 
215 |                 HSSFRow hssfRow = null;
216 |                 HSSFCell hssfcell = null;
217 | 
218 |                 //绘制表头以及菜单
219 |                 String fileName =export.fileName();
220 |                 if(exportTitle!=null){
221 |                     fileName = exportTitle;
222 |                 }
223 |                 //绘制标题
224 |                 createTitle(workbook,hssfRow,hssfcell,hssfsheet, colNames.size()-1 ,fileName,export.cellColor());
225 |                 //创建标题行（表头）
226 |                 createHeadRow(workbook,hssfRow,hssfcell,hssfsheet,colNames,colors);
227 |                 try {
228 |                     //表格样式
229 |                     HSSFCellStyle cellStyle= getBasicCellStyle(workbook);
230 |                     //插入内容
231 |                     int i=0;
232 |                     for (Object obj : dataList) {
233 |                         hssfRow = hssfsheet.createRow(i + 2);
234 |                         //设置每列的宽度
235 |                         //此处设置j=-1 ：添加一列，序号列
236 |                         for(int j=0;j<fieldList.size();j++){
237 |                             Field field = fieldList.get(j);
238 |                             field.setAccessible(true);
239 |                             Object value = field.get(obj);
240 |                             EnableExportField enableExportField = field.getAnnotation(EnableExportField.class);
241 |                             String getMethodName = enableExportField.useGetMethod();
242 |                             if(!"".equals( getMethodName )){
243 |                                 Method  method = clazz.getMethod(getMethodName, new Class[]{field.getType()});
244 |                                 method.setAccessible(true);
245 |                                 value= method.invoke(obj, new Object[]{value});
246 |                             }
247 |                             if(field.isAnnotationPresent(EnableSelectList.class)){
248 |                                 if(selectListMap!=null&& selectListMap.get(j)!=null)
249 |                                     value =selectListMap.get(j).get(value);
250 |                             }
251 |                             setCellValue(value, hssfcell, hssfRow, cellStyle, j);
252 |                         }
253 |                         i++;
254 |                     }
255 |                     //创建下拉列表
256 |                     createDataValidation(hssfsheet,selectListMap);
257 |                     workbook.write(outputStream);
258 |                     outputStream.flush();
259 |                     outputStream.close();
260 | 
261 |                 } catch (IllegalAccessException e ) {
262 |                     e.printStackTrace();
263 |                 } catch (IOException e) {
264 |                     e.printStackTrace();
265 |                 }catch (NoSuchMethodException e) {
266 |                     e.printStackTrace();
267 |                 }catch (InvocationTargetException e) {
268 |                     e.printStackTrace();
269 |                 }
270 | 
271 |             }
272 |         }
273 | 
274 |         /**
275 |          * 获取一个基本的带边框的单元格
276 |          * @param workbook
277 |          * @return
278 |          */
279 |         private static HSSFCellStyle getBasicCellStyle(HSSFWorkbook workbook){
280 |             HSSFCellStyle hssfcellstyle = workbook.createCellStyle();
281 |             hssfcellstyle.setBorderLeft(HSSFCellStyle.BORDER_THIN);
282 |             hssfcellstyle.setBorderBottom(HSSFCellStyle.BORDER_THIN);
283 |             hssfcellstyle.setBorderRight(HSSFCellStyle.BORDER_THIN);
284 |             hssfcellstyle.setBorderTop(HSSFCellStyle.BORDER_THIN);
285 |             hssfcellstyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
286 |             hssfcellstyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
287 |             hssfcellstyle.setWrapText(true);
288 |             return hssfcellstyle;
289 |         }
290 | 
291 |         /**
292 |          * 获取带有背景色的标题单元格
293 |          * @param workbook
294 |          * @return
295 |          */
296 |         private static HSSFCellStyle getTitleCellStyle(HSSFWorkbook workbook,ColorEnum color){
297 |             HSSFCellStyle hssfcellstyle =  getBasicCellStyle(workbook);
298 |             hssfcellstyle.setFillForegroundColor(color.getIndex()); // 设置背景色
299 |             hssfcellstyle.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
300 |             return hssfcellstyle;
301 |         }
302 | 
303 |         /**
304 |          * 创建一个跨列的标题行
305 |          * @param workbook
306 |          * @param hssfRow
307 |          * @param hssfcell
308 |          * @param hssfsheet
309 |          * @param allColNum
310 |          * @param title
311 |          */
312 |         private static void createTitle(HSSFWorkbook workbook, HSSFRow hssfRow , HSSFCell hssfcell, HSSFSheet hssfsheet,int allColNum,String title,ColorEnum color){
313 |             //在sheet里增加合并单元格
314 |             CellRangeAddress cra = new CellRangeAddress(0, 0, 0, allColNum);
315 |             hssfsheet.addMergedRegion(cra);
316 |             // 使用RegionUtil类为合并后的单元格添加边框
317 |             RegionUtil.setBorderBottom(1, cra, hssfsheet, workbook); // 下边框
318 |             RegionUtil.setBorderLeft(1, cra, hssfsheet, workbook); // 左边框
319 |             RegionUtil.setBorderRight(1, cra, hssfsheet, workbook); // 有边框
320 |             RegionUtil.setBorderTop(1, cra, hssfsheet, workbook); // 上边框
321 | 
322 |             //设置表头
323 |             hssfRow = hssfsheet.getRow(0);
324 |             hssfcell = hssfRow.getCell(0);
325 |             hssfcell.setCellStyle( getTitleCellStyle(workbook,color));
326 |             hssfcell.setCellType(HSSFCell.CELL_TYPE_STRING);
327 |             hssfcell.setCellValue(title);
328 |         }
329 | 
330 |         /**
331 |          * 设置表头标题栏以及表格高度
332 |          * @param workbook
333 |          * @param hssfRow
334 |          * @param hssfcell
335 |          * @param hssfsheet
336 |          * @param colNames
337 |          */
338 |         private static void createHeadRow(HSSFWorkbook workbook,HSSFRow hssfRow , HSSFCell hssfcell,HSSFSheet hssfsheet,List<String> colNames,List<ColorEnum> colors){
339 |             //插入标题行
340 |             hssfRow = hssfsheet.createRow(1);
341 |             for (int i = 0; i < colNames.size(); i++) {
342 |                 hssfcell = hssfRow.createCell(i);
343 |                 hssfcell.setCellStyle(getTitleCellStyle(workbook,colors.get(i)));
344 |                 hssfcell.setCellType(HSSFCell.CELL_TYPE_STRING);
345 |                 hssfcell.setCellValue(colNames.get(i));
346 |             }
347 |         }
348 |         /**
349 |          * excel添加下拉数据校验
350 |          * @param sheet 哪个 sheet 页添加校验
351 |          * @return
352 |          */
353 |         public static void createDataValidation(Sheet sheet, Map<Integer,Map<String,String>> selectListMap) {
354 |             if(selectListMap!=null) {
355 |                 for(Map.Entry<Integer,Map<String,String>> entry:selectListMap.entrySet()  ){
356 |                     Integer key = entry.getKey();
357 |                     Map<String,String> value = entry.getValue();
358 |                     // 第几列校验（0开始）key 数据源数组value
359 |                     if(value.size()>0) {
360 |                         int i=0;
361 |                         String[] valueArr = new String[value.size()];
362 |                         for(Map.Entry<String,String> ent :value.entrySet()){
363 |                             valueArr[i] = ent.getValue();
364 |                             i++;
365 |                         }
366 |                         CellRangeAddressList cellRangeAddressList = new CellRangeAddressList(2, 65535, key, key);
367 |                         DataValidationHelper helper = sheet.getDataValidationHelper();
368 |                         DataValidationConstraint constraint = helper.createExplicitListConstraint(valueArr);
369 |                         DataValidation dataValidation = helper.createValidation(constraint, cellRangeAddressList);
370 |                         //处理Excel兼容性问题
371 |                         if (dataValidation instanceof XSSFDataValidation) {
372 |                             dataValidation.setSuppressDropDownArrow(true);
373 |                             dataValidation.setShowErrorBox(true);
374 |                         } else {
375 |                             dataValidation.setSuppressDropDownArrow(false);
376 |                         }
377 |                         dataValidation.setEmptyCellAllowed(true);
378 |                         dataValidation.setShowPromptBox(true);
379 |                         dataValidation.createPromptBox("提示", "只能选择下拉框里面的数据");
380 |                         sheet.addValidationData(dataValidation);
381 |                     }
382 |                 }
383 |             }
384 |         }
385 |         /**
386 |          *通过value获取key值
387 |          * @param selectMap
388 |          * @param value
389 |          * @return
390 |          */
391 |         private static String getKeyByValue(Map<String,String> selectMap,String value){
392 |             if(selectMap!=null){
393 |                 for(Map.Entry<String,String> ent :selectMap.entrySet()){
394 |                     if(value!=null&&value.equals(ent.getValue()))
395 |                         return ent.getKey();
396 |                 }
397 |             }else{
398 |                 return value;
399 |             }
400 |             return null;
401 |         }
402 | 
403 | 
404 |         /**
405 |          *判断字符串是否为数字
406 |          * @param str
407 |          * @return
408 |          */
409 |         private static boolean isNumeric(String str) {
410 |             Pattern pattren =
411 |                     Pattern.compile("[-+]?(([0-9]+)([.]([0-9]+))?|([.]([0-9]+))?)$");
412 |             if (str != null && !"".equals(str.trim())) {
413 |                 Matcher matcher = pattren.matcher(str);
414 |                 if (matcher.matches()) {
415 |                     if (!str.contains(".") && str.startsWith("0")) {
416 |                         return false;
417 |                     }
418 |                     return true;
419 |                 }
420 |             }
421 |             return false;
422 |         }
423 | 
424 |         /**
425 |          *设置单元格的值
426 |          * @param value
427 |          * @param hssfcell
428 |          * @param hssfRow
429 |          * @param cellStyle
430 |          * @param cellIndex
431 |          */
432 |         private static void setCellValue(Object value,HSSFCell hssfcell,HSSFRow hssfRow,CellStyle cellStyle,int cellIndex) {
433 |             String valueStr = String.valueOf(value);
434 |             hssfcell =hssfRow.createCell(cellIndex );
435 |             //暂时认为数字类型不会有下拉列表
436 |             if (isNumeric(valueStr)) {
437 |                 hssfcell.setCellStyle(cellStyle);
438 |                 hssfcell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
439 |                 hssfcell.setCellValue(Double.valueOf(valueStr));
440 |             } else {
441 |                 hssfcell.setCellStyle(cellStyle);
442 |                 hssfcell.setCellType(HSSFCell.CELL_TYPE_STRING);
443 |                 hssfcell.setCellValue(valueStr);
444 |             }
445 |         }
446 | }
447 | 
448 | 
449 | 


--------------------------------------------------------------------------------
/src/main/java/com/jenkin/excel/anno/EnableExport.java:
--------------------------------------------------------------------------------
 1 | package com.jenkin.excel.anno;
 2 | 
 3 | 
 4 | import com.jenkin.excel.enums.ColorEnum;
 5 | 
 6 | import java.lang.annotation.ElementType;
 7 | import java.lang.annotation.Retention;
 8 | import java.lang.annotation.RetentionPolicy;
 9 | import java.lang.annotation.Target;
10 | 
11 | /**
12 |  * 设置允许导出
13 |  */
14 | @Target(ElementType.TYPE)
15 | @Retention(RetentionPolicy.RUNTIME)
16 | public @interface EnableExport {
17 |     //设置文件名/标题
18 |     String fileName();
19 |     //设置背景颜色
20 |     ColorEnum cellColor() default ColorEnum.BLUE;
21 | }


--------------------------------------------------------------------------------
/src/main/java/com/jenkin/excel/anno/EnableExportField.java:
--------------------------------------------------------------------------------
 1 | package com.jenkin.excel.anno;
 2 | 
 3 | 
 4 | import com.jenkin.excel.enums.ColorEnum;
 5 | 
 6 | import java.lang.annotation.ElementType;
 7 | import java.lang.annotation.Retention;
 8 | import java.lang.annotation.RetentionPolicy;
 9 | import java.lang.annotation.Target;
10 | 
11 | /**
12 |  * 设置该字段允许导出
13 |  * 并且可以设置宽度 
14 |  * 以及设置下拉列表字段的key 用来匹配对应的label导出
15 |  */
16 | @Target(ElementType.FIELD)
17 | @Retention(RetentionPolicy.RUNTIME)
18 | public @interface EnableExportField {
19 |      //宽度
20 |      int colWidth() default  100;
21 |      //标题名称
22 |      String colName();
23 |      //设置get方法
24 |      String useGetMethod() default "";
25 |      //设置背景颜色
26 |      ColorEnum cellColor() default ColorEnum.BLUE;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/main/java/com/jenkin/excel/anno/EnableSelectList.java:
--------------------------------------------------------------------------------
 1 | package com.jenkin.excel.anno;
 2 | 
 3 | import java.lang.annotation.ElementType;
 4 | import java.lang.annotation.Retention;
 5 | import java.lang.annotation.RetentionPolicy;
 6 | import java.lang.annotation.Target;
 7 | /**
 8 |  * 允许使用下拉列表
 9 |  */
10 | @Target(ElementType.FIELD)
11 | @Retention(RetentionPolicy.RUNTIME)
12 | public @interface EnableSelectList {
13 | }


--------------------------------------------------------------------------------
/src/main/java/com/jenkin/excel/anno/ImportIndex.java:
--------------------------------------------------------------------------------
 1 | package com.jenkin.excel.anno;
 2 | 
 3 | import java.lang.annotation.ElementType;
 4 | import java.lang.annotation.Retention;
 5 | import java.lang.annotation.RetentionPolicy;
 6 | import java.lang.annotation.Target;
 7 | 
 8 | /**
 9 |  * 导入时索引
10 |  * 从0开始
11 |  */
12 | @Target(ElementType.FIELD)
13 | @Retention(RetentionPolicy.RUNTIME)
14 | public @interface ImportIndex {
15 |      //索引
16 |      int index() ;
17 |      //设置set方法
18 |      String useSetMethodName() default "";
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/src/main/java/com/jenkin/excel/enums/ColorEnum.java:
--------------------------------------------------------------------------------
 1 | package com.jenkin.excel.enums;
 2 | 
 3 | import org.apache.poi.hssf.util.HSSFColor;
 4 | 
 5 | public enum ColorEnum {
 6 |     RED("红色", HSSFColor.RED.index),
 7 |     GREEN("绿色", HSSFColor.GREEN.index),
 8 |     BLANK("白色", HSSFColor.WHITE.index),
 9 |     YELLOW("黄色", HSSFColor.YELLOW.index),
10 |     BLUE("蓝色", HSSFColor.CORNFLOWER_BLUE.index);
11 |     private String name;
12 |     private short index;
13 |     private ColorEnum( String name, short index) {
14 |         this.name = name;
15 |         this.index = index;
16 |     }
17 | 
18 |     public String getName() {
19 |         return name;
20 |     }
21 | 
22 |     public void setName(String name) {
23 |         this.name = name;
24 |     }
25 | 
26 |     public short getIndex() {
27 |         return index;
28 |     }
29 | 
30 |     public void setIndex(short index) {
31 |         this.index = index;
32 |     }
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------