帆软FineReport如何使用程序数据集

大多数情况下，FineReport直接在设计器里使用“数据集查询”，直接写SQL就能满足报表要求，但对于一些复杂的报表，有时候SQL处理并不方便，这时可以把查询结果在应用层做一些预处理后，再传递给报表，即所谓的“程序数据集”，FineReport的帮助文档上给了一个示例：

  1 package com.fr.data;   

  2   

  3 import java.sql.Connection;   

  4 import java.sql.DriverManager;   

  5 import java.sql.ResultSet;   

  6 import java.sql.ResultSetMetaData;   

  7 import java.sql.Statement;   

  8 import java.util.ArrayList;   

  9 import com.fr.base.FRContext;   

 10 import com.fr.data.AbstractTableData;   

 11 import com.fr.base.Parameter;   

 12   

 13 public class ParamTableDataDemo extends AbstractTableData {   

 14     // 列名数组，保存程序数据集所有列名   

 15     private String[] columnNames = null;   

 16     // 定义程序数据集的列数量   

 17     private int columnNum = 10;   

 18     // 保存查询表的实际列数量   

 19     private int colNum = 0;   

 20     // 保存查询得到列值   

 21     private ArrayList valueList = null;   

 22   

 23     // 构造函数，定义表结构，该表有10个数据列，列名为column#0，column#1，。。。。。。column#9   

 24     public ParamTableDataDemo() {   

 25         // 定义tableName参数   

 26         this.parameters = new Parameter[] { new Parameter("tableName") };   

 27         // 定义程序数据集列名   

 28         columnNames = new String[columnNum];   

 29         for (int i = 0; i < columnNum; i++) {   

 30             columnNames[i] = "column#" + String.valueOf(i);   

 31         }   

 32     }   

 33   

 34     // 实现其他四个方法   

 35     public int getColumnCount() {   

 36         return columnNum;   

 37     }   

 38   

 39     public String getColumnName(int columnIndex) {   

 40         return columnNames[columnIndex];   

 41     }   

 42   

 43     public int getRowCount() {   

 44         init();   

 45         return valueList.size();   

 46     }   

 47   

 48     public Object getValueAt(int rowIndex, int columnIndex) {   

 49         init();   

 50         if (columnIndex >= colNum) {   

 51             return null;   

 52         }   

 53         return ((Object[]) valueList.get(rowIndex))[columnIndex];   

 54     }   

 55   

 56     // 准备数据   

 57     public void init() {   

 58         // 确保只被执行一次   

 59         if (valueList != null) {   

 60             return;   

 61         }   

 62         // 保存得到的数据库表名   

 63         String tableName = parameters[0].getValue().toString();   

 64         // 构造SQL语句,并打印出来   

 65         String sql = "select * from " + tableName + ";";   

 66         FRContext.getLogger().info("Query SQL of ParamTableDataDemo: \n" + sql);   

 67         // 保存得到的结果集   

 68         valueList = new ArrayList();   

 69         // 下面开始建立数据库连接，按照刚才的SQL语句进行查询   

 70         Connection conn = this.getConnection();   

 71         try {   

 72             Statement stmt = conn.createStatement();   

 73             ResultSet rs = stmt.executeQuery(sql);   

 74             // 获得记录的详细信息，然后获得总列数   

 75             ResultSetMetaData rsmd = rs.getMetaData();   

 76             colNum = rsmd.getColumnCount();   

 77             // 用对象保存数据   

 78             Object[] objArray = null;   

 79             while (rs.next()) {   

 80                 objArray = new Object[colNum];   

 81                 for (int i = 0; i < colNum; i++) {   

 82                     objArray[i] = rs.getObject(i + 1);   

 83                 }   

 84                 // 在valueList中加入这一行数据   

 85                 valueList.add(objArray);   

 86             }   

 87             // 释放数据库资源   

 88             rs.close();   

 89             stmt.close();   

 90             conn.close();   

 91             // 打印一共取到的数据行数量   

 92             FRContext.getLogger().info(   

 93                     "Query SQL of ParamTableDataDemo: \n" + valueList.size()   

 94                             + " rows selected");   

 95         } catch (Exception e) {   

 96             e.printStackTrace();   

 97         }   

 98     }   

 99   

100     // 获取数据库连接 driverName和 url 可以换成您需要的   

101     public Connection getConnection() {   

102         String driverName = "sun.jdbc.odbc.JdbcOdbcDriver";   

103         String url = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ=D:\\FineReport_7.0\\WebReport\\FRDemo.mdb";   

104         String username = "";   

105         String password = "";   

106         Connection con = null;   

107         try {   

108             Class.forName(driverName);   

109             con = DriverManager.getConnection(url, username, password);   

110         } catch (Exception e) {   

111             e.printStackTrace();   

112             return null;   

113         }   

114         return con;   

115     }   

116   

117     // 释放一些资源，因为可能会有重复调用，所以需释放valueList，将上次查询的结果释放掉   

118     public void release() throws Exception {   

119         super.release();   

120         this.valueList = null;   

121     }   

122 }  

View Code

这个示例我个人觉得有二个地方不太方便：
1、db连接串硬编码写死在代码里，维护起来不太方便，目前大多数b/s应用，对于数据库连接，通常是利用spring在xml里配置datasource bean，运行时动态注入

2、将查询出的结果，填充到数据集时，采用的是数字索引(见82行)，代码虽然简洁，但是可读性比较差

折腾一番后，于是便有了下面的改进版本：

  1 package infosky.ckg.fr.data;

  2 

  3 import infosky.ckg.utils.AppContext;

  4 import java.sql.Connection;

  5 import java.sql.ResultSet;

  6 import java.sql.Statement;

  7 import java.util.LinkedHashMap;

  8 import java.util.LinkedHashSet;

  9 import javax.sql.DataSource;

 10 import com.fr.base.Parameter;

 11 import com.fr.data.AbstractTableData;

 12 import com.fr.general.data.TableDataException;

 13 

 14 public class ParameterLinkedHashSetDataDemo extends AbstractTableData {

 15 

 16     private static final long serialVersionUID = 8818000311745955539L;

 17 

 18     // 字段名枚举

 19     enum FIELD_NAME {

 20         EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE, JOB_ID, SALARY

 21     }

 22 

 23     private String[] columNames;

 24 

 25     private LinkedHashSet<LinkedHashMap<String, Object>> rowData;

 26 

 27     public ParameterLinkedHashSetDataDemo() {

 28         this.parameters = new Parameter[] { new Parameter("jobId"),

 29                 new Parameter("minSalary"), new Parameter("maxSalary") };

 30 

 31         // 填充字段名

 32         columNames = new String[FIELD_NAME.values().length];

 33         int i = 0;

 34         for (FIELD_NAME fieldName : FIELD_NAME.values()) {

 35             columNames[i] = fieldName.toString();

 36             i++;

 37         }

 38 

 39     }

 40 

 41     @Override

 42     public int getColumnCount() throws TableDataException {

 43         return columNames.length;

 44     }

 45 

 46     @Override

 47     public String getColumnName(int columnIndex) throws TableDataException {

 48         return columNames[columnIndex];

 49     }

 50 

 51     @Override

 52     public int getRowCount() throws TableDataException {

 53         queryData();

 54         return rowData.size();

 55     }

 56 

 57     @Override

 58     public Object getValueAt(int rowIndex, int columnIndex) {

 59         queryData();

 60         int tempRowIndex = 0;

 61         for (LinkedHashMap<String, Object> row : rowData) {

 62             if (tempRowIndex == rowIndex) {

 63                 return row.get(columNames[columnIndex]);

 64             }

 65             tempRowIndex += 1;

 66         }

 67         return null;

 68     }

 69 

 70     // 查询数据

 71     private void queryData() {

 72         // 确保只被执行一次

 73         if (rowData != null) {

 74             return;

 75         }

 76 

 77         // 传入的参数

 78         String jobId = parameters[0].getValue().toString();

 79         float minSalary = Float.parseFloat(parameters[1].getValue().toString());

 80         float maxSalary = Float.parseFloat(parameters[2].getValue().toString());

 81 

 82         // 拼装SQL

 83         String sql = "select * from EMPLOYEES where JOB_ID='" + jobId

 84                 + "' and SALARY between " + minSalary + " and " + maxSalary;

 85 

 86         rowData = new LinkedHashSet<LinkedHashMap<String, Object>>();

 87 

 88         Connection conn = this.getConnection();

 89         try {

 90             Statement stmt = conn.createStatement();

 91             // 执行查询

 92             ResultSet rs = stmt.executeQuery(sql);

 93             while (rs.next()) {

 94                 // 填充行数据

 95                 // 注：字段赋值的顺序，要跟枚举里的顺序一样

 96                 LinkedHashMap<String, Object> row = new LinkedHashMap<String, Object>();

 97                 row.put(FIELD_NAME.EMPLOYEE_ID.toString(),

 98                         rs.getInt(FIELD_NAME.EMPLOYEE_ID.toString()));

 99                 row.put(FIELD_NAME.FIRST_NAME.toString(),

100                         rs.getString(FIELD_NAME.FIRST_NAME.toString()));

101                 row.put(FIELD_NAME.LAST_NAME.toString(),

102                         rs.getString(FIELD_NAME.LAST_NAME.toString()));

103                 row.put(FIELD_NAME.EMAIL.toString(),

104                         rs.getString(FIELD_NAME.EMAIL.toString()));

105                 row.put(FIELD_NAME.PHONE_NUMBER.toString(),

106                         rs.getString("PHONE_NUMBER"));

107                 row.put(FIELD_NAME.HIRE_DATE.toString(),

108                         rs.getDate(FIELD_NAME.HIRE_DATE.toString()));

109                 row.put(FIELD_NAME.JOB_ID.toString(),

110                         rs.getString(FIELD_NAME.JOB_ID.toString()));

111                 row.put(FIELD_NAME.SALARY.toString(),

112                         rs.getFloat(FIELD_NAME.SALARY.toString()));

113                 rowData.add(row);

114             }

115             rs.close();

116             stmt.close();

117             conn.close();

118         } catch (Exception e) {

119             e.printStackTrace();

120         }

121 

122     }

123 

124     // 获取数据库连接

125     private Connection getConnection() {

126         Connection con = null;

127         try {

128             DataSource dataSource = AppContext.getInstance().getAppContext()

129                     .getBean("dataSource", DataSource.class);

130             con = dataSource.getConnection();

131         } catch (Exception e) {

132             e.printStackTrace();

133             return null;

134         }

135         return con;

136     }

137 

138     // 释放资源

139     public void release() throws Exception {

140         super.release();

141         this.rowData = null;

142     }

143 

144 }

View Code

改进的地方：
1、getConnection方法，利用Spring注入datasource，当然为了注入方便，还需要一个辅助类AppContext

 1 package infosky.ckg.utils;

 2 

 3 import org.springframework.context.support.AbstractApplicationContext;

 4 import org.springframework.context.support.ClassPathXmlApplicationContext;

 5 

 6 public class AppContext {

 7     private static AppContext instance;

 8 

 9     private AbstractApplicationContext appContext;

10 

11     public synchronized static AppContext getInstance() {

12         if (instance == null) {

13             instance = new AppContext();

14         }

15         return instance;

16     }

17 

18     private AppContext() {

19         this.appContext = new ClassPathXmlApplicationContext(

20                 "spring/root-context.xml");

21     }

22 

23     public AbstractApplicationContext getAppContext() {

24         return appContext;

25     }

26 

27 }

View Code

classes/spring/root-context.xml 里配置db连接

 1 <?xml version="1.0" encoding="UTF-8"?>

 2 <beans xmlns="http://www.springframework.org/schema/beans"

 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

 4     xsi:schemaLocation="http://www.springframework.org/schema/beans 

 5     http://www.springframework.org/schema/beans/spring-beans.xsd">

 6 

 7     <bean id="dataSource"

 8         class="org.springframework.jdbc.datasource.DriverManagerDataSource">

 9         <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />

10 

11         <property name="url" value="jdbc:oracle:thin:@localhost:1521:XE" />

12         <property name="username" value="hr" />

13         <property name="password" value="hr" />

14     </bean>

15 </beans>

View Code

2、将原来的数组，换成了LinkedHashSet<LinkedHashMap<String, Object>>，这样db查询结果填充到"数据集"时，处理代码的可读性就多好了(见queryData方法)，但也要注意到LinkedHashSet/LinkedHashMap的性能较Array而言，有所下降，正所谓：有所得必有得失。但对于复杂的汇总统计报表，展示的数据通常不会太多，所以这个问题我个人看来并不严重。