Template configuration and data filling skills in the JXLS framework
Template configuration and data filling skills in the JXLS framework
JXLS is a Java -based open source framework that is used to quickly generate reports in Excel files.It provides a simple and powerful method to read Excel templates and fill in data.This article will introduce the template configuration and data filling techniques in the JXLS framework, and provide some Java code examples.
1. Excel template configuration
In JXLS, the Excel template is a pre -defined Excel file that contains the position and format to fill the data.You can use Microsoft Excel or other similar tools to create templates, and then analyze and fill through the JXLS framework.
2. Import jxls dependencies
First of all, you need to add JXLS dependencies to the construction file of the project.You can import the JXLS dependencies by adding the following code to the pom.xml file of the Maven project:
<dependency>
<groupId>org.jxls</groupId>
<artifactId>jxls-core</artifactId>
<version>2.9.1</version>
</dependency>
3. Template configuration
In the Excel template, the data to be filled by using a specific placeholder in the cell is used in the cell.JXLS supports different types of placeholders, including ordinary text, formulas, pictures, etc.
The following is a simple Excel template example for filling student information:
| Student Number | Name | Age |
| ---- | ------ | ---- |
| ${id} | ${name} | ${age} |
In the above examples, $ {ID}, $ {name} and $ {Age} are defined place occupying symbols that are replaced by the corresponding value when the data is filled.
4. Data filling
Once there is a template, you can use the JXLS framework to fill the data into the template.First, you need to create a Java class to save the data to be filled:
public class Student {
private int id;
private String name;
private int age;
// omit the creation function and getter/setter method
}
Then, you can use the following code to fill the data into the Excel template:
try(InputStream is = new FileInputStream("path/to/template.xls")) {
try(OutputStream os = new FileOutputStream("path/to/output.xls")) {
Context context = new PoiContext();
context.putvar ("Students", Students); // Students is a list of studnts objects
JxlsHelper.getInstance().processTemplate(is, os, context);
// The excel file after filling the data under the output path
} catch (IOException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}
In the above code, "Path/To/Template.xls" is the path of the Excel template.By connecting the "Students" variable with the Student object list, the data can be filled in the template.
5. Advanced configuration
JXLS also provides many advanced configuration options to meet more complicated needs.For example, you can use a custom converter to process specific types of data, or use commands to define complex filling logic.
The following is an example of using a custom converter:
Student Student = New Student (1, "Zhang San", 20);
Transformer transformer = (cell, value) -> {
if (cell.getColumnIndex() == 2) {
cell.setCellValue((int) value * 2);
}
};
PoiTransformerFactory.getTransformer(cell).transform(cell, student.getAge());
In the above examples, the custom converter multiplys the age value by 2 and fills the result into a specific cell.
Summarize:
This article introduces the template configuration and data filling skills in the JXLS framework.Through the template configuration, the position and format of the data to be filled can be defined.The API and tools provided by the JXLS framework can easily fill the data into the Excel template.Through advanced configuration options, you can also meet more complicated needs.It is hoped that these techniques will be helpful for developers who use the JXLS framework to generate reports.
