Java注解生成Excel_Java：自定义注解+反射实现导入导出Excel文档

Java注解是一种元数据，它可以为类、方法、字段等元素添加额外的信息。在Java中，可以使用自定义注解和反射来实现导入导出Excel文档。

首先，定义一个自定义注解，用于标记需要导出的实体类的字段：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExcelField {
    /**
     * 列名
     */
    public String name();

    /**
     * 顺序
     */
    public int order();
}

然后，在实体类的字段上添加该注解：

public class User {
    @ExcelField(name = "姓名", order = 1)
    private String name;

    @ExcelField(name = "年龄", order = 2)
    private int age;

    // 省略其他字段和方法
}

接着，定义一个工具类，用于读取和写入Excel文档：

public class ExcelUtil {
    /**
     * 从Excel中读取数据
     */
    public static <T> List<T> readFromExcel(InputStream is, Class<T> clazz) {
        List<T> list = new ArrayList<>();
        try {
            Workbook workbook = WorkbookFactory.create(is);
            Sheet sheet = workbook.getSheetAt(0);
            Map<Integer, String> headers = getHeaders(sheet.getRow(0));
            for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                Row row = sheet.getRow(i);
                T obj = clazz.newInstance();
                for (int j = 0; j < row.getLastCellNum(); j++) {
                    Cell cell = row.getCell(j);
                    String value = getValue(cell);
                    String fieldName = headers.get(j);
                    Field field = clazz.getDeclaredField(fieldName);
                    field.setAccessible(true);
                    setValue(obj, field, value);
                }
                list.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 写入数据到Excel中
     */
    public static <T> void writeToExcel(List<T> list, OutputStream os) {
        try {
            Workbook workbook = new XSSFWorkbook();
            Sheet sheet = workbook.createSheet();
            Row header = sheet.createRow(0);
            Map<String, Integer> fields = getFields(list.get(0).getClass());
            List<String> fieldNames = new ArrayList<>(fields.keySet());
            Collections.sort(fieldNames);
            for (int i = 0; i < fieldNames.size(); i++) {
                String fieldName = fieldNames.get(i);
                Cell cell = header.createCell(i);
                cell.setCellValue(fields.get(fieldName));
            }
            for (int i = 0; i < list.size(); i++) {
                Row row = sheet.createRow(i + 1);
                T obj = list.get(i);
                for (int j = 0; j < fieldNames.size(); j++) {
                    String fieldName = fieldNames.get(j);
                    Field field = obj.getClass().getDeclaredField(fieldName);
                    field.setAccessible(true);
                    Object value = field.get(obj);
                    Cell cell = row.createCell(j);
                    cell.setCellValue(value.toString());
                }
            }
            workbook.write(os);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取Excel中的列名
     */
    private static Map<Integer, String> getHeaders(Row row) {
        Map<Integer, String> headers = new HashMap<>();
        for (int i = 0; i < row.getLastCellNum(); i++) {
            Cell cell = row.getCell(i);
            String value = getValue(cell);
            headers.put(i, value);
        }
        return headers;
    }

    /**
     * 获取实体类中的字段名和顺序
     */
    private static <T> Map<String, Integer> getFields(Class<T> clazz) {
        Map<String, Integer> fields = new HashMap<>();
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field : declaredFields) {
            if (field.isAnnotationPresent(ExcelField.class)) {
                ExcelField excelField = field.getAnnotation(ExcelField.class);
                fields.put(field.getName(), excelField.order());
            }
        }
        return fields;
    }

    /**
     * 设置实体类中的字段值
     */
    private static <T> void setValue(T obj, Field field, String value) throws Exception {
        String typeName = field.getType().getName();
        if ("int".equals(typeName)) {
            field.set(obj, Integer.parseInt(value));
        } else if ("java.lang.String".equals(typeName)) {
            field.set(obj, value);
        }
        // 省略其他类型的判断
    }

    /**
     * 获取单元格中的值
     */
    private static String getValue(Cell cell) {
        String value = "";
        if (cell != null) {
            switch (cell.getCellType()) {
                case STRING:
                    value = cell.getStringCellValue();
                    break;
                case NUMERIC:
                    if (DateUtil.isCellDateFormatted(cell)) {
                        Date date = cell.getDateCellValue();
                        value = new SimpleDateFormat("yyyy-MM-dd").format(date);
                    } else {
                        value = String.valueOf(cell.getNumericCellValue());
                    }
                    break;
                case BOOLEAN:
                    value = String.valueOf(cell.getBooleanCellValue());
                    break;
                case FORMULA:
                    value = String.valueOf(cell.getCellFormula());
                    break;
                default:
                    value = "";
            }
        }
        return value;
    }
}

最后，可以使用该工具类来读取和写入Excel文档：

public class Main {
    public static void main(String[] args) {
        // 从Excel中读取数据
        try (InputStream is = new FileInputStream("users.xlsx")) {
            List<User> list = ExcelUtil.readFromExcel(is, User.class);
            for (User user : list) {
                System.out.println(user.getName() + ", " + user.getAge());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 写入数据到Excel中
        List<User> list = new ArrayList<>();
        list.add(new User("张三", 20));
        list.add(new User("李四", 30));
        list.add(new User("王五", 40));
        try (OutputStream os = new FileOutputStream("users.xlsx")) {
            ExcelUtil.writeToExcel(list, os);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}