Package net.sf.jasperreports.engine

Class JasperCompileManager

  • public final class JasperCompileManager
extends Object
    Facade class for compiling report designs into the ready-to-fill form and for getting the XML representation of report design objects for storage or network transfer.

    This class exposes all the library's report compilation functionality. It has various methods that allow the users to compile JRXML report templates found in files on disk or that come from input streams. It also lets people compile in-memory report templates by directly passing a JasperDesign object and receiving the corresponding JasperReport object.

    Other utility methods include report template verification and JRXML report template generation for in-memory constructed JasperDesign class instances. These instances are especially useful in GUI tools that simplify report design work.

    The facade class relies on the report template language to determine an appropriate report compiler. The report compilation facade first reads a configuration property called net.sf.jasperreports.compiler.<language> to determine whether a compiler implementation has been configured for the specific report language. If such a property is found, its value is used as compiler implementation class name and the facade instantiates a compiler object and delegates the report compilation to it. By default, JasperReports includes configuration properties that map the Groovy and JavaScript report compilers to the groovy and javascript report languages, respectively.

    If the report uses Java as language and no specific compiler has been set for this language, the report compilation facade employs a built-in fall back mechanism that picks the best Java-based report compiler available in the environment in which the report compilation process takes place.

    The facade first reads the configuration property called net.sf.jasperreports.compiler.class to allow users to override its built-in compiler-detection logic by providing the name of the report compiler implementation to use directly.

    If the property is not provided, the facade first tries to see if the JDT compiler from the Eclipse Foundation is available in the application's classpath. If it is, the net.sf.jasperreports.jdt.JRJdtCompiler} implementation is used.

    If the JDT compiler is not available, the compilation facade then tries to locate the JDK 1.3-compatible Java compiler from Sun Microsystems. This is normally found in the tools.jar file that comes with the JDK installation.

    If all these fail, the last thing the fall back mechanism does is to try to launch the javac.exe program from the command line in order to compile the temporarily generated Java source file on the fly.

    Configuration Properties to Customize Report Compilation

    JasperReports offers various mechanisms for letting users customize its behavior. One of these mechanisms is a complete set of configuration properties. The following list contains all the configuration properties that customize report compilation.
    net.sf.jasperreports.compiler.<language>
    Such properties are used for indicating the name of the class that implements the JRCompiler interface to be instantiated by the engine for a specific report language when the default compilation is used through this facade class. The value for such a configuration property can be the name of one of the built-in implementations of this interface shipped with the library as listed previously, or the name of a custom-made implementing class.
    One can configure report compilers for custom report languages and override the default compiler mappings by setting JasperReports properties of the form net.sf.jasperreports.compiler.<language> to the desired compiler implementation class names. In particular, the mechanism that automatically chooses a Java report compiler can be superseded by explicitly setting the net.sf.jasperreports.compiler.java property to the name of one of the built-in Java compiler classes or of a custom compiler implementation class.
    Note that the classes implementing the JRCompiler interface can also be used directly in the programs without having to call them through this facade class.
    net.sf.jasperreports.compiler.classpath
    This property supplies the classpath. JDK-based compilers require that the classpath be supplied as a parameter. They cannot use the current JVM classpath. The supplied classpath resolves class references inside the Java code they are compiling.
    This property is not used by the JDT-based report compiler, which simply uses the parent application's classpath during Java source file compilation.
    net.sf.jasperreports.compiler.temp.dir
    The temporary location for the files generated on the fly is by default the current working directory. It can be changed by supplying a value to this configuration property. This is used by the JDT-based compiler only when it is requested that a copy of the on-the-fly generated Java class be kept for debugging purposes as specified by the next configuration property, because normally this report compiler does not work with files on disk.
    net.sf.jasperreports.compiler.keep.java.file
    Sometimes, for debugging purposes, it is useful to have the generated *.java file or generated script in order to fix compilation problems related to report expressions. By default, the engine deletes this file after report compilation, along with its corresponding *.class file. To keep it, however, set this configuration property to true.

    JDT Compiler-Specific Configuration Properties

    The JRJdtCompiler report compiler can use special JasperReports configuration properties to configure the underlying JDT Java compiler. This report compiler collects all the JasperReports configuration properties (the ones usually set in the jasperreports.properties file) that start with the org.eclipse.jdt.core. prefix and passes them to the JDT Java compiler when compiling the generated Java class to evaluate report expressions.

    One of the uses of this mechanism is to instruct the JDT compiler to observe Java 1.5 code compatibility. To do so, the following properties should be set:

    • org.eclipse.jdt.core.compiler.source=1.5
    • org.eclipse.jdt.core.compiler.compliance=1.5
    • org.eclipse.jdt.core.compiler.codegen.TargetPlatform=1.5
    Author:
    Teodor Danciu (teodord@users.sourceforge.net)
    See Also:
    JasperReport, JasperDesign, JRCompiler, JRVerifier, JRXmlLoader, JRXmlWriter, JRLoader, JRSaver