Cách viết một cột cụ thể trong Excel bằng Java

Hướng dẫn đơn giản này sẽ giải thích cách điều chỉnh độ rộng cột trong Excel bằng Java. Chúng tôi có thể có nhiều loại dữ liệu trong Excel có thể có độ dài khác nhau và yêu cầu điều chỉnh kích thước cột để hiển thị chính xác. Bạn sẽ tìm hiểu quy trình này để thay đổi kích thước cột trong Excel bằng cách sử dụng Java tại đây và lưu tệp đầu ra dưới dạng XLSX với sự trợ giúp của hướng dẫn từng bước và mã Java sẵn sàng để chạy

Các bước điều chỉnh độ rộng cột trong Excel bằng Java

1. Sử dụng kho lưu trữ Maven, thêm tham chiếu đến Aspose. Thư viện ô trong ứng dụng
2. Tải tệp Excel vào đối tượng Sổ làm việc có các cột sẽ được thay đổi kích thước
3. Truy cập tham chiếu trang tính mong muốn từ tập hợp các trang tính trong sổ làm việc
4. Nhận tham chiếu đến bộ sưu tập Ô từ trang tính để đặt kích thước cột riêng lẻ
5. Đặt chiều rộng của một cột cụ thể bằng cách cung cấp số cột và chiều rộng cần thiết
6. Sử dụng trực tiếp đối tượng trang tính, tự động điều chỉnh một hoặc nhiều cột cụ thể dựa trên kích thước nội dung
7. Lưu tệp Excel đã cập nhật với các cột đã thay đổi kích thước

Ở đây chúng ta đã thấy rằng để sửa đổi độ rộng cột Excel bằng Java, chúng ta tải tệp Excel đích và sau đó truy cập trang tính mong muốn trong đó. Nếu bạn muốn đặt chiều rộng cột với một giá trị cố định, bạn có thể sử dụng bộ sưu tập Ô trong trang tính và nếu muốn tự động điều chỉnh chiều rộng dựa trên nội dung trong mỗi ô, bạn có thể sử dụng các hàm autoFitColumn[] và autoFitColumns[] trong

Mã để đặt chiều rộng của cột trong Excel bằng Java

Đoạn mã ngắn này trình bày quá trình thay đổi chiều rộng bằng cách sử dụng Ô. setColumnWidth[] và cung cấp chỉ mục cột và giá trị kép mô tả chiều rộng chính xác. Tương tự, để thay đổi kích thước một cột dựa trên nội dung, bạn có thể gọi Worksheet. autoFitColumn[] bằng cách cung cấp số cột. Để đặt chiều rộng của nhiều cột trong một trang tính, hãy gọi Worksheet. autoFitColumns[] cùng với số cột bắt đầu và kết thúc

Hướng dẫn đơn giản này đã giải thích cách thay đổi độ rộng của cột trong excel bằng cách sử dụng java. Nếu bạn muốn tìm hiểu các tính năng khác của sản phẩm này, chẳng hạn như lưu tệp đầu ra dưới dạng PDF, hãy tham khảo bài viết về Cách tạo PDF từ Excel trong Java

Trong bài viết này, một cách để khái quát hóa việc ghi vào tệp Excel cho bất kỳ loại Đối tượng nào có cả loại trường đơn và hỗn hợp [mảng] đã đạt được bằng cách sử dụng Apache POI với sự hỗ trợ của tính năng Phản chiếu Java. Nhu cầu mã tùy chỉnh để viết từng loại trường và xử lý hàng-cột đã giảm, bạn nên sử dụng tùy chỉnh tối thiểu

Apache POI [Triển khai Obfuscation kém] là một thư viện nguồn mở phổ biến do Apache Software Foundation điều hành, được phát triển để đọc và ghi các tệp ở định dạng Microsoft Office, chẳng hạn như Word, PowerPoint và Excel

Mục tiêu của Apache POI là thiết kế API đa nền tảng có thể thao tác các định dạng tệp khác nhau của Microsoft Office và Open Office Documents. Vì chúng tôi đang tập trung vào việc viết các tệp Excel, chúng tôi sẽ sử dụng các định dạng tệp sau của Apache POI cho bảng tính

HSSF [Định dạng bảng tính khủng khiếp] − Nó được sử dụng cho định dạng tệp xlsx của các tệp MS-Excel [97–2007]

XSSF [Định dạng bảng tính XML] − Nó được sử dụng cho định dạng tệp xlsx của tệp MS-Excel [2007 trở lên]

Mỗi thư viện Apache POI được dành riêng để thao tác từng loại tệp cụ thể. Thư viện XSSF chứa các lớp xử lý định dạng xlsx Excel. Hình bên dưới hiển thị các lớp và giao diện liên quan đến POI của Apache để thao tác với các tệp xlsx Excel

Hơn nữa, nó cung cấp hỗ trợ tuyệt vời cho các tính năng excel bổ sung như làm việc với Công thức, tạo kiểu ô bằng cách tô màu và đường viền, phông chữ, đầu trang và chân trang, xác thực dữ liệu, hình ảnh, siêu liên kết, v.v.

Hãy đi sâu vào công việc

Các bước chính này sẽ được tuân thủ để thực hiện

1. Thiết lập dự án Spring Boot với các phụ thuộc Apache POI và các phụ thuộc cần thiết khác
2. Tạo điểm cuối API để gửi yêu cầu HTTP để tải xuống tệp Excel
3. Xác định các giao diện Chú thích Java sẽ được sử dụng để phản ánh lớp động
4. Định nghĩa lớp Java POJO sẽ được sử dụng để ghi vào trang tính Excel. Và thiết lập lớp POJO để giữ siêu dữ liệu cho từng trường của lớp trên
5. Triển khai trình ghi Xlsx chung với phản ánh lớp động và dữ liệu bảng tính POI vào sổ làm việc
6. Tìm nạp danh sách các đối tượng lớp POJO và chuyển đến người viết và nhận phản hồi dưới dạng một mảng byte
7. Gửi phản hồi API dưới dạng mảng byte dữ liệu với các chi tiết tiêu đề có liên quan của openxmlformats dưới dạng MediaType

Thiết lập dự án Spring Boot với các phụ thuộc Apache POI và các phụ thuộc cần thiết khác

   org.apache.poi
   poi
   4.1.2


   org.apache.poi
   poi-ooxml
   4.1.2

Tạo điểm cuối API để nhận yêu cầu HTTP để tải xuống tệp Excel

@RequestMapping[method = RequestMethod.POST, value = "/download-users-excel"]
public ResponseEntity downloadUsersExcel[] {
    try {
        final byte[] data = userService.getUserXlsData[];
        HttpHeaders header = new HttpHeaders[];
    header.setContentType[MediaType.parseMediaType["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8"]];
        header.set[HttpHeaders.CONTENT_DISPOSITION, "inline; filename= users.xlsx"];
        header.setContentLength[data.length];
        return new ResponseEntity[data, header, HttpStatus.OK];
    } catch [Exception e] {
        return new ResponseEntity[null, HttpStatus.INTERNAL_SERVER_ERROR];
    }
}

Xác định các giao diện Chú thích Java sẽ được sử dụng để phản ánh lớp động

@Documented
@Target[ElementType.TYPE]
@Retention[RetentionPolicy.RUNTIME]
public @interface XlsxSheet {
    String value[];
}@Documented
@Target[ElementType.FIELD]
@Retention[RetentionPolicy.RUNTIME]
public @interface XlsxSingleField {
    int columnIndex[];
}@Documented
@Target[ElementType.FIELD]
@Retention[RetentionPolicy.RUNTIME]
public @interface XlsxCompositeField {
    int from[];
    int to[];
}

Định nghĩa lớp Java POJO sẽ được sử dụng để ghi vào trang tính Excel

Ở đây với mục đích trình diễn, một POJO bao gồm chi tiết Người dùng với danh sách DietPlan được sử dụng

@Getter
@NoArgsConstructor
@AllArgsConstructor
@Setter
@XlsxSheet[value = "Users"]
public class XlsxUser {

    @XlsxSingleField[columnIndex = 0]
    private String name;
    @XlsxSingleField[columnIndex = 1]
    private String gender;
    @XlsxSingleField[columnIndex = 2]
    private Integer age;
    @XlsxSingleField[columnIndex = 3]
    private Double bmiValue;
    @XlsxSingleField[columnIndex = 4]
    private Boolean isOverweight;
    @XlsxSingleField[columnIndex = 5]
    private List activities;
    @XlsxCompositeField[from = 6, to = 7]
    private List plans;

    @Getter
    @AllArgsConstructor
    @NoArgsConstructor
    @Setter
    public static class XlsxDietPlan {
        @XlsxSingleField[columnIndex = 6]
        private String mealName;
        @XlsxSingleField[columnIndex = 7]
        private Double calories;
    }

}

Như được hiển thị ở trên, Chú thích được xác định trước đó được sử dụng để cung cấp siêu dữ liệu cho lớp POJO và các trường của nó. Siêu dữ liệu này sẽ được đánh giá trong thời gian chạy để phản ánh lớp POJO và điền vào sổ làm việc trong trình ghi chung

Thiết lập lớp POJO để giữ siêu dữ liệu cho từng trường của lớp trên

Nếu chúng ta quan sát nó, lớp tập dữ liệu khả thi có thể bao gồm các cấu trúc dữ liệu sau

1. Các trường đơn [Số nguyên, Chuỗi, Float, Double, Boolean]
2. Các trường mảng [Danh sách các trường đơn lẻ]
3. Các trường tổng hợp [Danh sách các đối tượng bao gồm các trường đơn lẻ]

Vì vậy, mỗi trường được ánh xạ tới một phiên bản XlsxField chứa siêu dữ liệu về trường lớp POJO sẽ hữu ích sau này

@Getter
@NoArgsConstructor
@AllArgsConstructor
@Setter
public class XlsxField {
    private String fieldName;
    private int cellIndex;
    private int cellIndexFrom;
    private int cellIndexTo;
    private boolean isAnArray;
    private boolean isComposite;
}

Triển khai trình ghi Xlsx chung với phản ánh lớp động và dữ liệu bảng tính POI vào sổ làm việc

@Service
public class XlsxFileWriter implements XlsxWriter {


   private static final Logger logger = LoggerFactory.getLogger[XlsxFileWriter.class];

    @Override
    public  void write[List data, ByteArrayOutputStream bos, String[] columnTitles, Workbook workbook] {

        if [data.isEmpty[]] {
            logger.error["No data received to write Xls file.."];
            return;
        }

        long start = System.currentTimeMillis[];

//      setting up the basic styles for the workbook
        Font boldFont = getBoldFont[workbook];
        Font genericFont = getGenericFont[workbook];
        CellStyle headerStyle = getLeftAlignedCellStyle[workbook, boldFont];
        CellStyle currencyStyle = setCurrencyCellStyle[workbook];
        CellStyle centerAlignedStyle = getCenterAlignedCellStyle[workbook];
        CellStyle genericStyle = getLeftAlignedCellStyle[workbook, genericFont];

   try {
// using POJO class metadata for the sheet name
    XlsxSheet annotation = data.get[0].getClass[].getAnnotation[XlsxSheet.class];
    String sheetName = annotation.value[];
    Sheet sheet = workbook.createSheet[sheetName];

//  get the metadata for each field of the POJO class into a list
    List xlsColumnFields = getFieldNamesForClass[data.get[0].getClass[]];

      int tempRowNo = 0;
      int recordBeginRowNo = 0;
      int recordEndRowNo = 0;

//    set spreadsheet titles
      Row mainRow = sheet.createRow[tempRowNo];
      Cell columnTitleCell;

      for [int i = 0; i < columnTitles.length; i++] {
        columnTitleCell = mainRow.createCell[i];
        columnTitleCell.setCellStyle[headerStyle];
        columnTitleCell.setCellValue[columnTitles[i]];
      }
      recordEndRowNo++;

//    get class of the passed dataset
      Class clazz = data.get[0].getClass[];//    looping the past dataset
      for [T record : data] {
        tempRowNo = recordEndRowNo;
        recordBeginRowNo = tempRowNo;
        mainRow = sheet.createRow[tempRowNo++];
        boolean isFirstValue;
        boolean isFirstRow;
        boolean isRowNoToDecrease = false;
        Method xlsMethod;
        Object xlsObjValue;
        ArrayList objValueList;
                
//      get max size of the record if its multiple row
        int maxListSize = getMaxListSize[record, xlsColumnFields, clazz];
                
                
//      looping through the fields of the current record
        for [XlsxField xlsColumnField : xlsColumnFields] {
//       writing a single field
         if [!xlsColumnField.isAnArray[] && !xlsColumnField.isComposite[]] {
            writeSingleFieldRow[mainRow, xlsColumnField, clazz, currencyStyle, centerAlignedStyle, genericStyle,
                                record, workbook];

//       overlooking the next field and adjusting the starting row
         if [isNextColumnAnArray[xlsColumnFields, xlsColumnField, clazz, record]] {
             isRowNoToDecrease = true;
             tempRowNo = recordBeginRowNo + 1;
          }

//       writing an single array field
         } else if [xlsColumnField.isAnArray[] && !xlsColumnField.isComposite[]] {
           xlsMethod = getMethod[clazz, xlsColumnField];
           xlsObjValue = xlsMethod.invoke[record, [Object[]] null];
           objValueList = [ArrayList] xlsObjValue;
           isFirstValue = true;

//       looping through the items of the single array
         for [Object objectValue : objValueList] {
            Row childRow;
            if [isFirstValue] {
             childRow = mainRow;
             writeArrayFieldRow[childRow, xlsColumnField, objectValue, currencyStyle, centerAlignedStyle, genericStyle, workbook];
             isFirstValue = false;
            } else if [isRowNoToDecrease] {
             childRow = getOrCreateNextRow[sheet, tempRowNo++];
             writeArrayFieldRow[childRow, xlsColumnField, objectValue, currencyStyle, centerAlignedStyle,genericStyle, workbook];
             isRowNoToDecrease = false;
            } else {
             childRow = getOrCreateNextRow[sheet, tempRowNo++];
             writeArrayFieldRow[childRow, xlsColumnField, objectValue, currencyStyle, centerAlignedStyle, genericStyle, workbook];
            }
          }

 //      overlooking the next field and adjusting the starting row
         if [isNextColumnAnArray[xlsColumnFields, xlsColumnField, clazz, record]] {
            isRowNoToDecrease = true;
            tempRowNo = recordBeginRowNo + 1;
         }

//      writing a composite array field
         } else if [xlsColumnField.isAnArray[] && xlsColumnField.isComposite[]] {
           xlsMethod = getMethod[clazz, xlsColumnField];
           xlsObjValue = xlsMethod.invoke[record, [Object[]] null];
           objValueList = [ArrayList] xlsObjValue;
           isFirstRow = true;

//       looping through the items of the composite array
           for [Object objectValue : objValueList] {
             Row childRow;
             List xlsCompositeColumnFields = getFieldNamesForClass[objectValue.getClass[]];
             if [isFirstRow] {
               childRow = mainRow;
               for [XlsxField xlsCompositeColumnField : xlsCompositeColumnFields] {  
                                                                  writeCompositeFieldRow[objectValue, xlsCompositeColumnField, childRow, currencyStyle,centerAlignedStyle, genericStyle, workbook];
               }
              isFirstRow = false;
              } else if [isRowNoToDecrease] {
               childRow = getOrCreateNextRow[sheet, tempRowNo++];
               for [XlsxField xlsCompositeColumnField : xlsCompositeColumnFields] {
                                    writeCompositeFieldRow[objectValue, xlsCompositeColumnField, childRow, currencyStyle, centerAlignedStyle, genericStyle, workbook];
            }
            isRowNoToDecrease = false;
           } else {
            childRow = getOrCreateNextRow[sheet, tempRowNo++];
            for [XlsxField xlsCompositeColumnField : xlsCompositeColumnFields] {
                                    writeCompositeFieldRow[objectValue, xlsCompositeColumnField, childRow, currencyStyle, centerAlignedStyle, genericStyle, workbook];
           }
          }
         }

//       overlooking the next field and adjusting the starting row
         if [isNextColumnAnArray[xlsColumnFields, xlsColumnField, clazz, record]] {
            isRowNoToDecrease = true;
            tempRowNo = recordBeginRowNo + 1;
           }
         }
       }

//      adjusting the ending row number for the current record
        recordEndRowNo = maxListSize + recordBeginRowNo;
     }

// auto sizing the columns of the whole sheet
   autoSizeColumns[sheet, xlsColumnFields.size[]];            
   workbook.write[bos];
   logger.info["Xls file generated in [{}] seconds", processTime[start]];
  } catch [Exception e] {
    logger.info["Xls file write failed", e];
  }
}

  private void writeCompositeFieldRow[Object objectValue, XlsxField xlsCompositeColumnField, Row childRow,CellStyle currencyStyle, CellStyle centerAlignedStyle, CellStyle genericStyle, Workbook workbook] throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        Method nestedCompositeXlsMethod = getMethod[objectValue.getClass[], xlsCompositeColumnField];
        Object nestedCompositeValue = nestedCompositeXlsMethod.invoke[objectValue, [Object[]] null];
        Cell compositeNewCell = childRow.createCell[xlsCompositeColumnField.getCellIndex[]];
        setCellValue[compositeNewCell, nestedCompositeValue, currencyStyle, centerAlignedStyle, genericStyle, workbook];
    }

    private void writeArrayFieldRow[Row childRow, XlsxField xlsColumnField, Object objectValue,
                                    CellStyle currencyStyle, CellStyle centerAlignedStyle, CellStyle genericStyle, Workbook workbook] {
        Cell newCell = childRow.createCell[xlsColumnField.getCellIndex[]];
        setCellValue[newCell, objectValue, currencyStyle, centerAlignedStyle, genericStyle, workbook];
    }

    private  void writeSingleFieldRow[Row mainRow, XlsxField xlsColumnField, Class clazz, CellStyle currencyStyle,CellStyle centerAlignedStyle, CellStyle genericStyle, T record, Workbook workbook] throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

  Cell newCell = mainRow.createCell[xlsColumnField.getCellIndex[]];
  Method xlsMethod = getMethod[clazz, xlsColumnField];
  Object xlsObjValue = xlsMethod.invoke[record, [Object[]] null];
  setCellValue[newCell, xlsObjValue, currencyStyle, centerAlignedStyle, genericStyle, workbook];
    }

    private  boolean isNextColumnAnArray[List xlsColumnFields, XlsxField xlsColumnField,Class clazz, T record]
            throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
  XlsxField nextXlsColumnField;
  int fieldsSize = xlsColumnFields.size[];
  Method nestedXlsMethod;
  Object nestedObjValue;
  ArrayList nestedObjValueList;
   if [xlsColumnFields.indexOf[xlsColumnField] < [fieldsSize - 1]] {
      nextXlsColumnField = xlsColumnFields.get[xlsColumnFields.indexOf[xlsColumnField] + 1];
  if [nextXlsColumnField.isAnArray[]] {
   nestedXlsMethod = getMethod[clazz, nextXlsColumnField];
   nestedObjValue = nestedXlsMethod.invoke[record, [Object[]] null];
   nestedObjValueList = [ArrayList] nestedObjValue;
                return nestedObjValueList.size[] > 1;
            }
        }
        return xlsColumnFields.indexOf[xlsColumnField] == [fieldsSize - 1];

    }

    private void setCellValue[Cell cell, Object objValue, CellStyle currencyStyle, CellStyle centerAlignedStyle,
                              CellStyle genericStyle, Workbook workbook] {
        Hyperlink link = workbook.getCreationHelper[].createHyperlink[HyperlinkType.URL];
          if [objValue != null] {
            if [objValue instanceof String] {
                String cellValue = [String] objValue;
                cell.setCellStyle[genericStyle];
                if [cellValue.contains["//"] || cellValue.contains["//"]] {
                    link.setAddress[cellValue];
                    cell.setCellValue[cellValue];
                    cell.setHyperlink[link];
                } else {
                    cell.setCellValue[cellValue];
                }
            } else if [objValue instanceof Long] {
                cell.setCellValue[[Long] objValue];
            } else if [objValue instanceof Integer] {
                cell.setCellValue[[Integer] objValue];
            } else if [objValue instanceof Double] {
                Double cellValue = [Double] objValue;
                cell.setCellStyle[currencyStyle];
                cell.setCellValue[cellValue];
            } else if [objValue instanceof Boolean] {
                cell.setCellStyle[centerAlignedStyle];
                if [objValue.equals[true]] {
                    cell.setCellValue[1];
                } else {
                    cell.setCellValue[0];
                }
            }
        }
    }

    private static List getFieldNamesForClass[Class clazz] {
        List xlsColumnFields = new ArrayList[];
        Field[] fields = clazz.getDeclaredFields[];
        for [Field field : fields] {
          XlsxField xlsColumnField = new XlsxField[];
           if [Collection.class.isAssignableFrom[field.getType[]]] {
                xlsColumnField.setAnArray[true];
                XlsxCompositeField xlsCompositeField = field.getAnnotation[XlsxCompositeField.class];
                if [xlsCompositeField != null] {
          xlsColumnField.setCellIndexFrom[xlsCompositeField.from[]];
              xlsColumnField.setCellIndexTo[xlsCompositeField.to[]];
                    xlsColumnField.setComposite[true];
                } else {
                    XlsxSingleField xlsField = field.getAnnotation[XlsxSingleField.class];
                xlsColumnField.setCellIndex[xlsField.columnIndex[]];
                }
            } else {
                XlsxSingleField xlsField = field.getAnnotation[XlsxSingleField.class];
                xlsColumnField.setAnArray[false];
                if [xlsField != null] {
                xlsColumnField.setCellIndex[xlsField.columnIndex[]];
                    xlsColumnField.setComposite[false];
                }
            }
            xlsColumnField.setFieldName[field.getName[]];
            xlsColumnFields.add[xlsColumnField];
        }
        return xlsColumnFields;
    }

    private static String capitalize[String s] {
        if [s.length[] == 0]
            return s;
        return s.substring[0, 1].toUpperCase[] + s.substring[1];
    }


    private  int getMaxListSize[T record, List xlsColumnFields, Class clazz, XlsxField xlsColumnField] throws NoSuchMethodException {
        Method method;
        try {
            method = clazz.getMethod["get" + capitalize[xlsColumnField.getFieldName[]]];
        } catch [NoSuchMethodException nme] {
            method = clazz.getMethod[xlsColumnField.getFieldName[]];
        }

        return method;
    }

    private long processTime[long start] {
        return [System.currentTimeMillis[] - start] / 1000;
    }

    private void autoSizeColumns[Sheet sheet, int noOfColumns] {
        for [int i = 0; i < noOfColumns; i++] {
            sheet.autoSizeColumn[[short] i];
        }
    }

    private Row getOrCreateNextRow[Sheet sheet, int rowNo] {
        Row row;
        if [sheet.getRow[rowNo] != null] {
            row = sheet.getRow[rowNo];
        } else {
            row = sheet.createRow[rowNo];
        }
        return row;
    }

    private CellStyle setCurrencyCellStyle[Workbook workbook] {
        CellStyle currencyStyle = workbook.createCellStyle[];
        currencyStyle.setWrapText[true];
        DataFormat df = workbook.createDataFormat[];
        currencyStyle.setDataFormat[df.getFormat["#0.00"]];
        return currencyStyle;
    }

    private Font getBoldFont[Workbook workbook] {
        Font font = workbook.createFont[];
        font.setBold[true];
        font.setFontHeight[[short] [10 * 20]];
        font.setFontName["Calibri"];
        font.setColor[IndexedColors.BLACK.getIndex[]];
        return font;
    }

    private Font getGenericFont[Workbook workbook] {
        Font font = workbook.createFont[];
        font.setFontHeight[[short] [10 * 20]];
        font.setFontName["Calibri"];
        font.setColor[IndexedColors.BLACK.getIndex[]];
        return font;
    }

    private CellStyle getCenterAlignedCellStyle[Workbook workbook] {
        CellStyle cellStyle = workbook.createCellStyle[];
        cellStyle.setAlignment[HorizontalAlignment.CENTER];
        cellStyle.setVerticalAlignment[VerticalAlignment.BOTTOM];
        cellStyle.setBorderTop[BorderStyle.NONE];
        cellStyle.setBorderBottom[BorderStyle.NONE];
        cellStyle.setBorderLeft[BorderStyle.NONE];
        cellStyle.setBorderRight[BorderStyle.NONE];
        return cellStyle;
    }

    private CellStyle getLeftAlignedCellStyle[Workbook workbook, Font font] {
        CellStyle cellStyle = workbook.createCellStyle[];
        cellStyle.setFont[font];
        cellStyle.setAlignment[HorizontalAlignment.LEFT];
        cellStyle.setVerticalAlignment[VerticalAlignment.BOTTOM];
        cellStyle.setBorderTop[BorderStyle.NONE];
        cellStyle.setBorderBottom[BorderStyle.NONE];
        cellStyle.setBorderLeft[BorderStyle.NONE];
        cellStyle.setBorderRight[BorderStyle.NONE];
        return cellStyle;
    }
}

Tìm nạp danh sách các đối tượng lớp POJO và chuyển đến người viết và nhận phản hồi dưới dạng một mảng byte

Với mục đích trình diễn, một số dữ liệu giả sẽ được sử dụng để tạo danh sách bản ghi POJO mẫu

Sau đó, một phiên bản của ByteArrayOutputStream và XSSFWorkbook được tạo. Tiêu đề của bảng tính được định nghĩa là một mảng Chuỗi. Chúng được chuyển cho người viết dưới dạng tham số. Phiên bản đã qua của ByteArrayOutputStream chứa luồng byte của dữ liệu được ghi vào sổ làm việc. Bên trong mệnh đề Cuối cùng, ByteArrayOutputStream bị đóng và mảng byte được trả về

@Service
public class UserServiceImpl implements UserService {

    private final XlsxWriter xlsxWriter;
    private static final Logger logger = LoggerFactory.getLogger[UserServiceImpl.class];

    public UserServiceImpl[XlsxWriter xlsxWriter] {
        this.xlsxWriter = xlsxWriter;
    }

    @Override
    public byte[] getUserXlsData[] throws IOException {
        List xlsxUserList = new ArrayList[];
        for [int i = 0; i < 10; i++] {
            XlsxUser user = new XlsxUser[];
            List activities = new ArrayList[Arrays.asList["Running", "Working out", "Heavy Machinery", "Walking"]];
            List plans = new ArrayList[Arrays.asList[new XlsxUser.XlsxDietPlan["Breakfast", 500.10],
                    new XlsxUser.XlsxDietPlan["Lunch", 320.25], new XlsxUser.XlsxDietPlan["Dinner", 200.80]]];
            user.setName["John Doe"];
            user.setAge[25];
            user.setBmiValue[25.36];
            user.setGender["Male"];
            user.setIsOverweight[true];
            user.setActivities[activities];
            user.setPlans[plans];
            xlsxUserList.add[user];
        }
        ByteArrayOutputStream bos = new ByteArrayOutputStream[];
        try [Workbook workbook = new XSSFWorkbook[]] {
            String[] columnTitles = new String[]{"Name", "Gender", "Age", "BMI value", "Is Overweight", "Activities", "Meal Name", "Calories"};
            xlsxWriter.write[xlsxUserList, bos, columnTitles, workbook];
        } catch [Exception e] {
            logger.error["Generating users xls file failed", e];
        } finally {
            bos.close[];
        }
        return bos.toByteArray[];
     }
}

Đầu ra mẫu

Tóm lược

Nỗ lực triển khai trình soạn thảo Excel chung và mạnh mẽ bằng cách sử dụng các tính năng cốt lõi của Apache POI và Java như Phản chiếu và Chú thích, sẽ tải xuống tệp Excel bằng yêu cầu HTTP. Điều này sẽ phù hợp với hầu hết các trường hợp sử dụng cấu trúc POJO khi nó được ghi vào trang tính Excel. Hy vọng điều này sẽ hữu ích và cũng sẽ dễ dàng tùy chỉnh

Làm cách nào để chèn một cột trong Excel bằng Java?

Làm cách nào để lấy dữ liệu cột cụ thể từ Excel trong Java?

Làm cách nào để ghi dữ liệu vào một ô trong Excel bằng Java?