Java 需要报告设计建议

我正在为以下报表设计编写iReport。请看下面给出的格式：-

在研究了这个设计之后，我可以得出以下几点结论

此报告基本上基于员工，他们的工作根据他们使用的应用程序及其状态进行总结

在我看来，这似乎是一个交叉表报告

如果我使用POJO作为数据源，基本上，如果我设计DTO，它将类似于POJO，包含员工列表。该员工POJO本身将是一个应用程序类型集合，而这些应用程序类型又将有一个状态列表 我是JasperReports的新手。我期待的是，我们如何在 以实现报表设计。欢迎提出任何建议。示例DTO设计是

包com.renaissance.model

import java.util.List;

public class Employee {
  private long employeeNo ;
  private List<ApplicationType> applicationTypes;

  public Employee(long employeeNo, List<ApplicationType> applicationTypes) {
    this.employeeNo = employeeNo;
    this.applicationTypes = applicationTypes;
  }

  public Employee() {

  }

  public long getEmployeeNo() {
    return employeeNo;
  }

  public void setEmployeeNo(long employeeNo) {
    this.employeeNo = employeeNo;
  }

  public List<ApplicationType> getApplicationTypes() {
    return applicationTypes;
  }

  public void setApplicationTypes(List<ApplicationType> applicationTypes) {
    this.applicationTypes = applicationTypes;
  }
}


package com.renaissance.model;

import java.util.List;

public class ApplicationType {
  private long appTypeId ;
  private String appName ;
  private List<ApplicationStatus> applicationStatuses;

  public List<ApplicationStatus> getApplicationStatuses() {
    return applicationStatuses;
  }

  public void setApplicationStatuses(List<ApplicationStatus> applicationStatuses) {
    this.applicationStatuses = applicationStatuses;
  }

  public long getAppTypeId() {
    return appTypeId;
  }

  public void setAppTypeId(long appTypeId) {
    this.appTypeId = appTypeId;
  }

  public String getAppName() {
    return appName;
  }

  public void setAppName(String appName) {
    this.appName = appName;
  }

  public ApplicationType(long appTypeId, String appName) {
    this.appTypeId = appTypeId;
    this.appName = appName;
  }

  public ApplicationType() {

  }
}

package com.renaissance.model;

public class ApplicationStatus {
  private long appStatusId ;
  private String appStatusNameEn ;

  public ApplicationStatus(long appStatusId, String appStatusNameEn) {
    this.appStatusId = appStatusId;
    this.appStatusNameEn = appStatusNameEn;
  }

  public ApplicationStatus() {

  }

  public long getAppStatusId() {
    return appStatusId;
  }

  public void setAppStatusId(long appStatusId) {
    this.appStatusId = appStatusId;
  }

  public String getAppStatusNameEn() {
    return appStatusNameEn;
  }

  public void setAppStatusNameEn(String appStatusNameEn) {
    this.appStatusNameEn = appStatusNameEn;
  }
}

import java.util.List；
公营雇员{
私人长期雇员；
私有列表应用程序类型；
公共雇员（长期雇员否，列表应用程序类型）{
this.employeeNo=employeeNo；
this.applicationTypes=applicationTypes；
}
公职人员（）{
}
公共长期雇员人数（）{
返回雇员o；
}
公共无效setEmployeeNo（长employeeNo）{
this.employeeNo=employeeNo；
}
公共列表getApplicationTypes（）{
返回应用程序类型；
}
public void setApplicationTypes（列出applicationTypes）{
this.applicationTypes=applicationTypes；
}
}
包com.renaissance.model；
导入java.util.List；
公共类应用程序类型{
私有长appTypeId；
私有字符串appName；
私有列表应用程序状态；
公共列表GetApplicationStatus（）{
返回应用程序状态；
}
公共void集合应用程序状态（列出应用程序状态）{
this.applicationstatus=applicationstatus；
}
公共长getAppTypeId（）{
返回appTypeId；
}
public void setAppTypeId（长appTypeId）{
this.appTypeId=appTypeId；
}
公共字符串getAppName（）{
返回appName；
}
public void setAppName（字符串appName）{
this.appName=appName；
}
公共应用程序类型（长appTypeId，字符串appName）{
this.appTypeId=appTypeId；
this.appName=appName；
}
公共应用程序类型（）{
}
}
包com.renaissance.model；
公共类应用程序状态{
私有长appStatusId；
私有字符串appStatusNameEn；
公共应用程序状态（长appStatusId，字符串appStatusNameEn）{
this.appStatusId=appStatusId；
this.appStatusNameEn=appStatusNameEn；
}
公共应用程序状态（）{
}
公共长getAppStatusId（）{
返回appStatusId；
}
公共无效setAppStatusId（长appStatusId）{
this.appStatusId=appStatusId；
}
公共字符串getAppStatusNameEn（）{
返回appStatusNameEn；
}
public void setAppStatusNameEn（字符串appStatusNameEn）{
this.appStatusNameEn=appStatusNameEn；
}
}

驱动程序

package com.renaissance.reporting;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import com.renaissance.model.ApplicationStatus;
import com.renaissance.model.ApplicationType;
import com.renaissance.model.Employee;
import net.sf.jasperreports.engine.JRDataSource;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRExporterParameter;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.export.JRPdfExporter;

public class GenerateReport {
  public static final String REPORT_DIRECTORY = "c:\\reporting";
  public static void main(String[] args) throws IOException, JRException {
    JRDataSource jrDataSource = prepareDataSource();
    JasperPrint jasperPrint =  generateJasperReportPrint(jrDataSource,REPORT_DIRECTORY+"\\crosstabTest.jasper");
    JRPdfExporter pdfExporter = new JRPdfExporter();
    pdfExporter.setParameter(JRExporterParameter.JASPER_PRINT,jasperPrint);
    pdfExporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME,
        REPORT_DIRECTORY + "//" + "test" + ".pdf");
    System.out.println("Exporting report...");
    pdfExporter.exportReport();
    System.out.println("Done!");

  }

  private static JRDataSource prepareDataSource(){
    List<ApplicationStatus> applicationStatuses1 = new ArrayList<ApplicationStatus>();
    List<ApplicationStatus> applicationStatuses2 = new ArrayList<ApplicationStatus>();
    List<ApplicationStatus> applicationStatuses3 = new ArrayList<ApplicationStatus>();
    List<ApplicationType> applicationTypes1 = new ArrayList<ApplicationType>();
    List<ApplicationType> applicationTypes2 = new ArrayList<ApplicationType>();
    List<ApplicationType> applicationTypes3 = new ArrayList<ApplicationType>();



    applicationStatuses1.add(new ApplicationStatus(2,"Approved")) ;
    applicationStatuses1.add(new ApplicationStatus(3,"Rejected")) ;
    applicationStatuses1.add(new ApplicationStatus(4,"NSD Cleared"));

    applicationStatuses2.add(new ApplicationStatus(10,"Approved")) ;
    applicationStatuses2.add(new ApplicationStatus(5,"Rejected")) ;
    applicationStatuses2.add(new ApplicationStatus(6,"NSD Cleared"));



    ApplicationType applicationType1 = new ApplicationType();
    ApplicationType applicationType2 = new ApplicationType();
    ApplicationType applicationType3 = new ApplicationType();
    ApplicationType applicationType4 = new ApplicationType();
    applicationType1.setAppTypeId(1);
    applicationType1.setAppName("Short Term");
    applicationType1.setApplicationStatuses(applicationStatuses1);

    applicationType2.setAppTypeId(2);
    applicationType2.setAppName("Long Term");
    applicationType2.setApplicationStatuses(applicationStatuses2);

    applicationType3.setAppTypeId(3);
    applicationType3.setAppName("Outpass");
    applicationType3.setApplicationStatuses(applicationStatuses1);


    Employee employee1 = new Employee();
    Employee employee2 = new Employee();
    employee1.setEmployeeNo(1);
    employee2.setEmployeeNo(2);
    applicationTypes1.add(applicationType1);
    applicationTypes1.add(applicationType2);
    applicationTypes2.add(applicationType3);
    employee1.setApplicationTypes(applicationTypes1);
    employee2.setApplicationTypes(applicationTypes2);

    List<Employee> employees = new ArrayList<Employee>();
    employees.add(employee1);
    employees.add(employee2);

    return new JRBeanCollectionDataSource(employees);
  }

  private static JasperPrint generateJasperReportPrint(JRDataSource dataSource, String reportPath)
      throws JRException, IOException {
    JasperPrint jasperPrint = null;
    FileInputStream inputStream = null;
    try {

      inputStream = new FileInputStream(new File(reportPath));
      jasperPrint = JasperFillManager.fillReport(inputStream, new HashMap(), dataSource);
    }
    catch(IOException e) {

      if (inputStream != null) {
        try {
          inputStream.close();
        }
        catch(IOException e1) {
          e1.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }
      }
    }
    return jasperPrint;
  }
}

package.com.renaissance.reporting；
导入java.io.File；
导入java.io.FileInputStream；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.HashMap；
导入java.util.List；
导入com.renaissance.model.ApplicationStatus；
导入com.renaissance.model.ApplicationType；
导入com.renaissance.model.Employee；
导入net.sf.jasperreports.engine.JRDataSource；
导入net.sf.jasperreports.engine.JRException；
导入net.sf.jasperreports.engine.jreporterParameter；
导入net.sf.jasperreports.engine.JasperFillManager；
导入net.sf.jasperreports.engine.JasperPrint；
导入net.sf.jasperreports.engine.data.JRBeanCollectionDataSource；
导入net.sf.jasperreports.engine.export.JRPdfExporter；
公共类生成器报表{
公共静态最终字符串报告\u DIRECTORY=“c:\\reporting”；
公共静态void main（字符串[]args）引发IOException、JREException{
JRDataSource JRDataSource=prepareDataSource（）；
JasperPrint JasperPrint=generateJSperReportPrint（jrDataSource，报告目录+“\\crosstabTest.jasper”）；
JRPdfExporter PDFEEXPORTER=新的JRPdfExporter（）；
pdfExporter.setParameter（jreporterParameter.JASPER_PRINT，jasperPrint）；
pdfExporter.setParameter（JRExporterParameter.OUTPUT_文件名，
报告目录+“/”+“测试”+“.pdf”）；
System.out.println（“导出报告…”）；
pdfExporter.exportReport（）；
System.out.println（“完成！”）；
}
私有静态JRDataSource prepareDataSource（）{
List applicationStatuses1=新的ArrayList（）；
List applicationStatuses2=新的ArrayList（）；
List applicationStatuses3=new ArrayList（）；
List applicationTypes1=新建ArrayList（）；
List applicationTypes2=new ArrayList（）；
List applicationTypes3=新建ArrayList（）；
申请状态1.添加（新申请状态（2，“已批准”）；
添加（新的应用程序状态（3，“已拒绝”）；
应用程序状态1.add（新应用程序状态（4，“NSD清除”）；
申请状态2.添加（新申请状态（10，“已批准”）；
添加（新的应用程序状态（5，“已拒绝”）；
添加（新的应用程序状态（6，“NSD清除”）；
ApplicationType applicationType1=新的ApplicationType（）；
ApplicationType applicationType2=新的ApplicationType（）；
ApplicationType applicationType3=新的ApplicationType（）；
ApplicationType applicationType4=新的ApplicationType（）；
applicationType1.setAppTypeId（1）；
applicationType1.setAppName（“短期”）；
applicationType1.setApplicationStatuses（ApplicationStatuse1）；
applicationType2.setAppTypeId（2）；
applicationType2.setAppName（“长期”）；
applicationType2.setApplicationStatuses（ApplicationStatuse2）；
applicationType3.setAppTypeId（3）；
applicationType3.setAppName（“Outpass”）；
applicationType3.setApplicationStatuses（ApplicationStatuse1）；
employee1=新员工（）；
employee2=新员工（）；
雇员1.setEmployeeNo（1）；
雇员2.setE