Base class for all JasperReports views. Applies on-the-fly compilation
of report designs as required and coordinates the rendering process.
The resource path of the main report needs to be specified as url.

This class is responsible for getting report data from the model that has
been provided to the view. The default implementation checks for a model object
under the specified reportDataKey first, then falls back to looking
for a value of type JRDataSource, java.util.Collection,
object array (in that order).

If no JRDataSource can be found in the model, then reports will
be filled using the configured javax.sql.DataSource if any. If neither
a JRDataSource or javax.sql.DataSource is available then
an IllegalArgumentException is raised.

Provides support for sub-reports through the subReportUrls and
subReportDataKeys properties.

When using sub-reports, the master report should be configured using the
url property and the sub-reports files should be configured using
the subReportUrls property. Each entry in the subReportUrls
Map corresponds to an individual sub-report. The key of an entry must match up
to a sub-report parameter in your report file of type
net.sf.jasperreports.engine.JasperReport,
and the value of an entry must be the URL for the sub-report file.

For sub-reports that require an instance of JRDataSource, that is,
they don't have a hard-coded query for data retrieval, you can include the
appropriate data in your model as would with the data source for the parent report.
However, you must provide a List of parameter names that need to be converted to
JRDataSource instances for the sub-report via the
subReportDataKeys property. When using JRDataSource
instances for sub-reports, you must specify a value for the
reportDataKey property, indicating the data to use for the main report.

Allows for exporter parameters to be configured declatively using the
exporterParameters property. This is a Map typed
property where the key of an entry corresponds to the fully-qualified name
of the static field for the JRExporterParameter and the value
of an entry is the value you want to assign to the exporter parameter.

Response headers can be controlled via the headers property. Spring
will attempt to set the correct value for the Content-Diposition header
so that reports render correctly in Internet Explorer. However, you can override this
setting through the headers property.

convertExporterParameters()
Converts the exporter parameters passed in by the user which may be keyed
by Strings corresponding to the fully qualified name of the
JRExporterParameter into parameters which are keyed by
JRExporterParameter.

setSubReportDataKeys(String[] subReportDataKeys)
Set the list of names corresponding to the model parameters that will contain
data source objects for use in sub-reports.

void

setSubReportUrls(Properties subReports)
Specify resource paths which must be loaded as instances of
JasperReport and passed to the JasperReports engine for
rendering as sub-reports, under the same keys as in this mapping.

AbstractJasperReportsView

setReportDataKey

Set the name of the model attribute that represents the report data.
If not specified, the model map will be searched for a matching value type.

A JRDataSource will be taken as-is. For other types, conversion
will apply: By default, a java.util.Collection will be converted
to JRBeanCollectionDataSource, and an object array to
JRBeanArrayDataSource.

Note: If you pass in a Collection or object array in the model map
for use as plain report parameter, rather than as report data to extract fields
from, you need to specify the key for the actual report data to use, to avoid
mis-detection of report data by type.

setSubReportDataKeys

Set the list of names corresponding to the model parameters that will contain
data source objects for use in sub-reports. Spring will convert these objects
to instances of JRDataSource where applicable and will then
include the resulting JRDataSource in the parameters passed into
the JasperReports engine.

The name specified in the list should correspond to an attribute in the
model Map, and to a sub-report data source parameter in your report file.
If you pass in JRDataSource objects as model attributes,
specifing this list of keys is not required.

If you specify a list of sub-report data keys, it is required to also
specify a reportDataKey for the main report, to avoid confusion
between the data source objects for the various reports involved.

setExporterParameters

Set the exporter parameters that should be used when rendering a view.

Parameters:

parameters - Map with the fully qualified field name
of the JRExporterParameter instance as key
(e.g. "net.sf.jasperreports.engine.export.JRHtmlExporterParameter.IMAGES_URI")
and the value you wish to assign to the parameter as value

convertExporterParameters

protected final void convertExporterParameters()

Converts the exporter parameters passed in by the user which may be keyed
by Strings corresponding to the fully qualified name of the
JRExporterParameter into parameters which are keyed by
JRExporterParameter.

convertParameterValue

Convert the supplied parameter value into the actual type required by the
corresponding JRExporterParameter.

The default implementation simply converts the String values "true" and
"false" into corresponding Boolean objects, and tries to convert
String values that start with a digit into Integer objects
(simply keeping them as String if number conversion fails).

exposeLocalizationContext

Expose current Spring-managed Locale and MessageSource to JasperReports i18n
($R expressions etc). The MessageSource should only be exposed as JasperReports
resource bundle if no such bundle is defined in the report itself.

Default implementation exposes the Spring RequestContext Locale and a
MessageSourceResourceBundle adapter for the Spring ApplicationContext,
analogous to the JstlUtils.exposeLocalizationContext method.

fillReport

Create a populated JasperPrint instance from the configured
JasperReport instance.

By default, thois method will use any JRDataSource instance
(or wrappable Object) that can be located using getReportData(java.util.Map).
If no JRDataSource can be found, this method will use a JDBC
Connection obtained from the configured javax.sql.DataSource
(or a DataSource attribute in the model). If no JDBC DataSource can be found
either, the JasperReports engine will be invoked with plain model Map,
assuming that the model contains parameters that identify the source
for report data (e.g. Hibernate or JPA queries).

getReport

The default implementation returns the report as statically configured
through the 'url' property (and loaded by loadReport()).
Can be overridden in subclasses in order to dynamically obtain a
JasperReport instance. As an alternative, consider
overriding the fillReport(java.util.Map) template method itself.

Returns:

an instance of JasperReport

getReportData

Find an instance of JRDataSource in the given model map or create an
appropriate JRDataSource for passed-in report data.

The default implementation checks for a model object under the
specified "reportDataKey" first, then falls back to looking for a value
of type JRDataSource, java.util.Collection,
object array (in that order).

convertReportData

The default implementation delegates to JasperReportUtils unless
the report data value is an instance of JRDataSourceProvider.
A JRDataSource, JRDataSourceProvider,
java.util.Collection or object array is detected.
JRDataSources are returned as is, whilst JRDataSourceProviders
are used to create an instance of JRDataSource which is then returned.
The latter two are converted to JRBeanCollectionDataSource or
JRBeanArrayDataSource, respectively.

renderReport

Subclasses should implement this method to perform the actual rendering process.

Note that the content type has not been set yet: Implementors should build
a content type String and set it via response.setContentType.
If necessary, this can include a charset clause for a specific encoding.
The latter will only be necessary for textual output onto a Writer, and only
in case of the encoding being specified in the JasperReports exporter parameters.

WARNING: Implementors should not use response.setCharacterEncoding
unless they are willing to depend on Servlet API 2.4 or higher. Prefer a
concatenated content type String with a charset clause instead.