BIRT dans l'application de démarrage du printemps

Question

Je dois créer une fonction de rapport (fonction) dans une application Web existante à démarrage par ressort. La suggestion était d'utiliser BIRT, que je pourrais intégrer à l'application Web Spring Boot. 

J'ai trouvé l'article ci-dessous et j'ai pu exécuter les rapports dans un projet de démarrage de démarrage de printemps (avec http://start.spring.io/ ). Cet article, assez ancien, m'a aidé à obtenir un exemple concret. https://spring.io/blog/2012/01/30/spring-framework-birt . Cet article est fondamentalement exactement ce que je veux, mais dans une application Web de démarrage de printemps.

Le défi que j’ai à relever est d’exécuter le rapport à l’aide du visualiseur BIRT, qui comprend des fonctionnalités supplémentaires de Nice. (Impression, données Expoet, PDF, pagination, etc.)

Je ne trouve aucun exemple de démarrage de printemps utilisant BIRT comme décrit dans cet article. 

Mes questions sont:

1. Existe-t-il une alternative ou une autre façon de créer des rapports dans une application Web de démarrage printanier? (Évidemment, ne pas vouloir réinventer la roue en créant de toutes pièces une fonctionnalité semblable à BIRT ou exécuter le moteur de rapport séparément de l'application Web, dans la mesure du possible) 

2. BIRT travaille-t-il (avec le spectateur) dans une application Web de démarrage pour le printemps et est-il disposé à partager ou à m'éduquer sur la meilleure façon de le faire? (J'ai essayé de faire fonctionner la page JSP avec Spring Boot, mais je suis incapable de réussir avec autant de succès ... plus un manque d'expérience qu'autre chose)

Quelqu'un peut m'aider s'il vous plaît. 

Cordialement, Henk

Answer 1

Les dépendances, une instance de IReportEngine et les répertoires constituent la partie la plus difficile de la configuration de BIRT dans une application Web à démarrage différé. Cet exemple comporte un peu de gestion des erreurs et dépend de variables d’environnement pour spécifier les chemins d'accès aux répertoires importants.

L'un des avantages de cette configuration est qu'il s'agit d'une API ReST autonome permettant de générer et de générer des rapports. En contrepartie, cela ne dépend pas du tout de JSP.

Je l'exécute dans un conteneur Docker.

À l'origine, il était prévu d'utiliser certaines des interfaces pour essayer d'autres cadres de production de rapports tels que les rapports Jasper ou autre chose.

Ce n'est pas exactement ce que vous demandez, même si à mon avis cela est préférable dans certains contextes. Vous avez beaucoup de flexibilité pour utiliser, configurer et déployer le programme d’exécution de rapports BIRT en tant qu’application de ce type. Cela n'utilise pas le visualiseur BIRT préemballé fourni par Actian.

Je créerais un conteneur de données pour les rapports appelé birt-report-runner-data , puis mettrais tous les répertoires de journalisation et de rapports sur ce conteneur que vous pourrez ensuite monter sur votre conteneur BIRT.

Composants principaux

Fichier principal (BirtReportRunnerApplication.Java)

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BirtReportRunnerApplication {

    public static void main(String[] args) {
        SpringApplication.run(BirtReportRunnerApplication.class, args);
    }
}

Le contrôleur doit recevoir les demandes de rapport (ReportController.Java)

package com.example.core.web.controller;

import com.example.core.model.BIRTReport;
import com.example.core.service.ReportRunner;
import com.example.core.web.dto.ReportRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController("ReportController")
@RequestMapping("/reports")
public class ReportController {

    private Logger logger = LoggerFactory.getLogger(ReportController.class);

    @Autowired
    @Qualifier("birt")
    ReportRunner reportRunner;

    @RequestMapping(value = "/birt", method = RequestMethod.POST)
    public ResponseEntity<byte[]> getBIRTReport(@RequestBody ReportRequest reportRequest) {
        byte[] reportBytes;
        ResponseEntity<byte[]> responseEntity;
        try {
            logger.info("REPORT REQUEST NAME:   " + reportRequest.getReportName());
            reportBytes =
                new BIRTReport(
                    reportRequest.getReportName(),
                    reportRequest.getReportParameters(),
                    reportRunner)
                    .runReport().getReportContent().toByteArray();

            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setContentType(MediaType.parseMediaType("application/pdf"));
            String fileName = reportRequest.getReportName() + ".pdf";
            httpHeaders.setContentDispositionFormData(fileName, fileName);
            httpHeaders.setCacheControl("must-revalidate, post-check=0, pre-check=0");
            responseEntity = new ResponseEntity<byte[]>(reportBytes, httpHeaders, HttpStatus.OK);
        } catch (Exception e) {
            responseEntity = new ResponseEntity<byte[]>(HttpStatus.NOT_IMPLEMENTED);
            return responseEntity;
        }
        return responseEntity;
    }
}

Report Request DTO pour spécifier le rapport à exécuter (ReportRequest.Java)

package com.example.core.web.dto;

import com.fasterxml.jackson.annotation.JsonProperty;

import Java.util.List;

public class ReportRequest {
    private String reportName;
    private String reportParameters;

    public ReportRequest(@JsonProperty("reportName") String reportName,
                         @JsonProperty("reportParameters") String reportParameters) {
        this.reportName = reportName;
        this.reportParameters = reportParameters;
    }

    public String getReportName() {
        return reportName;
    }

    public String getReportParameters() {
        return reportParameters;
    }

    public void setReportParameters(String reportParameters) {
        this.reportParameters = reportParameters;
    }
}

Interface pour le gestionnaire de rapports (ReportRunner.Java)

package com.example.core.service;

import com.example.core.model.Report;

import Java.io.ByteArrayOutputStream;

public interface ReportRunner {

    ByteArrayOutputStream runReport(Report report);
}

La plus grande classe qui effectue le plus gros du travail (BIRTReportRunner.Java)

package com.example.core.service;

import com.example.core.model.Report;
import org.Eclipse.birt.core.exception.BirtException;
import org.Eclipse.birt.core.framework.Platform;
import org.Eclipse.birt.report.engine.api.*;
import org.Eclipse.core.internal.registry.RegistryProviderFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import Java.io.ByteArrayOutputStream;
import Java.io.File;
import Java.nio.file.Files;
import Java.nio.file.Path;
import Java.nio.file.Paths;
import Java.util.HashMap;
import Java.util.Map;
import Java.util.logging.Level;

@Service
@Qualifier("birt")
public class BIRTReportRunner implements ReportRunner {
    private static final String DEFAULT_LOGGING_DIRECTORY = "defaultBirtLoggingDirectory/";
    private Logger logger = LoggerFactory.getLogger(BIRTReportRunner.class);

    private static String reportOutputDirectory;

    private IReportEngine birtReportEngine = null;

    @Autowired
    private Environment env;

    /**
     * Starts up and configures the BIRT Report Engine
     */
    @PostConstruct
    public void startUp() {
        if(env.getProperty("birt_report_input_dir") == null)
            throw new RuntimeException("Cannot start application since birt report input directory was not specified.");
        try {
            String birtLoggingDirectory = env.getProperty("birt_logging_directory") == null ? DEFAULT_LOGGING_DIRECTORY : env.getProperty("birt_logging_directory");
            Level birtLoggingLevel = env.getProperty("birt_logging_level") == null ? Level.SEVERE : Level.parse(env.getProperty("birt_logging_level"));
            EngineConfig engineConfig = new EngineConfig();
            logger.info("BIRT LOG DIRECTORY SET TO : {}", birtLoggingDirectory);
            logger.info("BIRT LOGGING LEVEL SET TO {}", birtLoggingLevel);
            engineConfig.setLogConfig(birtLoggingDirectory, birtLoggingLevel);

            // Required due to a bug in BIRT that occurs in calling Startup after the Platform has already been started up
            RegistryProviderFactory.releaseDefault();
            Platform.startup(engineConfig);
            IReportEngineFactory reportEngineFactory = (IReportEngineFactory) Platform.createFactoryObject(IReportEngineFactory.EXTENSION_REPORT_ENGINE_FACTORY);
            birtReportEngine = reportEngineFactory.createReportEngine(engineConfig);
        } catch (BirtException e) {
            // TODO add logging aspect and find out how to log a platform startup problem from this catch block, if possible, using the aspect.
            // Possibly rethrow the exception here and catch it in the aspect.
            logger.error("Birt Startup Error: {}", e.getMessage());
        }

        reportOutputDirectory = env.getProperty("birt_temp_file_output_dir");
    }

    /**
     * Shuts down the BIRT Report Engine
     */
    @PreDestroy
    public void shutdown() {
        birtReportEngine.destroy();
        RegistryProviderFactory.releaseDefault();
        Platform.shutdown();
    }

    public File getReportFromFilesystem(String reportName) throws RuntimeException {
        String reportDirectory = env.getProperty("birt_report_input_dir");
        Path birtReport = Paths.get(reportDirectory + File.separator + reportName + ".rptdesign");
        if(!Files.isReadable(birtReport))
            throw new RuntimeException("Report " + reportName + " either did not exist or was not writable.");

        return birtReport.toFile();
    }

    /**
     * This method creates and executes the report task, the main responsibility
     * of the entire Report Service.
     * This method is key to enabling pagination for the BIRT report. The IRunTask run task
     * is created and then used to generate an ".rptdocument" binary file.
     * This binary file is then read by the separately created IRenderTask render
     * task. The render task renders the binary document as a binary PDF output
     * stream which is then returned from the method.
     * <p>
     *
     * @param birtReport the report object created at the controller to hold the data of the report request.
     * @return Returns a ByteArrayOutputStream of the PDF bytes generated by the
     */
    @Override
    public ByteArrayOutputStream runReport(Report birtReport) {

        ByteArrayOutputStream byteArrayOutputStream;
        File rptDesignFile;

        // get the path to the report design file
        try {
            rptDesignFile = getReportFromFilesystem(birtReport.getName());
        } catch (Exception e) {
            logger.error("Error while loading rptdesign: {}.", e.getMessage());
            throw new RuntimeException("Could not find report");
        }

        // process any additional parameters
        Map<String, String> parsedParameters = parseParametersAsMap(birtReport.getParameters());

        byteArrayOutputStream = new ByteArrayOutputStream();
        try {
            IReportRunnable reportDesign = birtReportEngine.openReportDesign(rptDesignFile.getPath());
            IRunTask runTask = birtReportEngine.createRunTask(reportDesign);

            if (parsedParameters.size() > 0) {
                for (Map.Entry<String, String> entry : parsedParameters.entrySet()) {
                    runTask.setParameterValue(entry.getKey(), entry.getValue());
                }
            }
            runTask.validateParameters();

            String rptdocument = reportOutputDirectory + File.separator
                    + "generated" + File.separator
                    + birtReport.getName() + ".rptdocument";
            runTask.run(rptdocument);

            IReportDocument reportDocument = birtReportEngine.openReportDocument(rptdocument);
            IRenderTask renderTask = birtReportEngine.createRenderTask(reportDocument);

            PDFRenderOption pdfRenderOption = new PDFRenderOption();
            pdfRenderOption.setOption(IPDFRenderOption.REPAGINATE_FOR_PDF, new Boolean(true));
            pdfRenderOption.setOutputFormat("pdf");
            pdfRenderOption.setOutputStream(byteArrayOutputStream);
            renderTask.setRenderOption(pdfRenderOption);

            renderTask.render();
            renderTask.close();
        } catch (EngineException e) {
            logger.error("Error while running report task: {}.", e.getMessage());
            // TODO add custom message to thrown exception
            throw new RuntimeException();
        }

        return byteArrayOutputStream;
    }

    /**
     * Takes a String of parameters started by '?', delimited by '&', and with
     * keys and values split by '=' and returnes a Map of the keys and values
     * in the String.
     *
     * @param reportParameters a String from a HTTP request URL
     * @return a map of parameters with Key,Value entries as strings
     */
    public Map<String, String> parseParametersAsMap(String reportParameters) {
        Map<String, String> parsedParameters = new HashMap<String, String>();
        String[] paramArray;
        if (reportParameters.isEmpty()) {
            throw new IllegalArgumentException("Report parameters cannot be empty");
        } else if (!reportParameters.startsWith("?") && !reportParameters.contains("?")) {
            throw new IllegalArgumentException("Report parameters must start with a question mark '?'!");
        } else {
            String noQuestionMark = reportParameters.substring(1, reportParameters.length());
            paramArray = noQuestionMark.split("&");
            for (String param : paramArray) {
                String[] paramGroup = param.split("=");
                if (paramGroup.length == 2) {
                    parsedParameters.put(paramGroup[0], paramGroup[1]);
                } else {
                    parsedParameters.put(paramGroup[0], "");
                }

            }
        }
        return parsedParameters;
    }
}

Classe d'objet de rapport (Report.Java)

package com.example.core.model;

import com.example.core.service.ReportRunner;

import Java.io.ByteArrayOutputStream;
import Java.util.List;

/**
 * A Report object has a byte representation of the report output that can be
 * used to write to any output stream. This class is designed around the concept
 * of using ByteArrayOutputStreams to write PDFs to an output stream.
 *
 *
 */
public abstract class Report {

    protected String name;
    protected String parameters;
    protected ByteArrayOutputStream reportContent;
    protected ReportRunner reportRunner;

    public Report(String name, String parameters, ReportRunner reportRunner) {
        this.name = name;
        this.parameters = parameters;
        this.reportRunner = reportRunner;
    }

    /**
     * This is the processing method for a Report. Once the report is ran it
     * populates an internal field with a ByteArrayOutputStream of the
     * report content generated during the run process.
     * @return Returns itself with the report content output stream created.
     */
    public abstract Report runReport();

    public ByteArrayOutputStream getReportContent() {
        return this.reportContent;
    }

    public String getName() {
        return name;
    }

    public String getParameters() {
        return parameters;
    }
}

Classe d'objet BIRTReport (BIRTReport.Java)

package com.example.core.model;

import com.example.core.service.ReportRunner;

public class BIRTReport extends Report {

    public BIRTReport(String name, String reportParameters, ReportRunner reportRunner) {
        super(name, reportParameters, reportRunner);
    }

    @Override
    public Report runReport() {
        this.reportContent = reportRunner.runReport(this);
        return this;
    }
}

Fichier de construction (build.gradle)

buildscript {
    ext {
        springBootVersion = '1.3.2.RELEASE'
    }
    repositories {
        jcenter()

    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath("io.spring.gradle:dependency-management-plugin:0.5.2.RELEASE")
    }
}

apply plugin: 'Java'
apply plugin: 'Eclipse'
apply plugin: 'idea'
apply plugin: 'spring-boot'

jar {
    baseName = 'com.example.simple-birt-runner'
    version = '1.0.0'
}

sourceCompatibility = 1.8
targetCompatibility = 1.8

ext {
    springBootVersion = '1.3.0.M5'
}

repositories {
    jcenter()
    mavenCentral()
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-actuator:${springBootVersion}")
    compile("org.springframework.boot:spring-boot-starter-web:${springBootVersion}")


    // BIRT Runtime and ReportEngine dependencies
    // These were pulled from the Actuate download site at http://download.Eclipse.org/birt/downloads/ for version 4.5.0
    compile fileTree(dir: 'lib', include: '*.jar')
    /*compile("org.Eclipse.birt.runtime:org.Eclipse.birt.runtime:4.4.2") {
        exclude group: "org.Eclipse.birt.runtime", module: "org.Apache.poi"
        exclude group: "org.Eclipse.birt.runtime", module: "org.Eclipse.orbit.mongodb"
    }*/

    compile("org.springframework.boot:spring-boot-starter-Tomcat")

    // include any runtime JDBC driver dependencies here

    testCompile("org.springframework.boot:spring-boot-starter-test")
}

Les dépendances

Obtenez toutes les dépendances dans le répertoire lib de Birt Viewer et mettez-les sur votre chemin de classe. Voici une liste complète des dépendances externes:

com.ibm.icu_54.1.1.v201501272100.jar
com.lowagie.text_2.1.7.v201004222200.jar
derby.jar
flute.jar
javax.wsdl_1.5.1.v201012040544.jar
javax.xml.stream_1.0.1.v201004272200.jar
javax.xml_1.3.4.v201005080400.jar
net.sourceforge.lpg.lpgjavaruntime_1.1.0.v201004271650.jar
org.Apache.batik.bridge_1.6.0.v201011041432.jar
org.Apache.batik.css_1.6.0.v201011041432.jar
org.Apache.batik.dom.svg_1.6.0.v201011041432.jar
org.Apache.batik.dom_1.6.1.v201505192100.jar
org.Apache.batik.ext.awt_1.6.0.v201011041432.jar
org.Apache.batik.parser_1.6.0.v201011041432.jar
org.Apache.batik.pdf_1.6.0.v201105071520.jar
org.Apache.batik.svggen_1.6.0.v201011041432.jar
org.Apache.batik.transcoder_1.6.0.v201011041432.jar
org.Apache.batik.util.gui_1.6.0.v201011041432.jar
org.Apache.batik.util_1.6.0.v201011041432.jar
org.Apache.batik.xml_1.6.0.v201011041432.jar
org.Apache.commons.codec_1.6.0.v201305230611.jar
org.Apache.commons.logging_1.1.1.v201101211721.jar
org.Apache.lucene.core_3.5.0.v20120725-1805.jar
org.Apache.poi_3.9.0.v201405241750.jar
org.Apache.xerces_2.9.0.v201101211617.jar
org.Apache.xml.resolver_1.2.0.v201005080400.jar
org.Apache.xml.serializer_2.7.1.v201005080400.jar
org.Eclipse.birt.runtime_4.5.0.jar
org.Eclipse.core.contenttype_3.5.0.v20150421-2214.jar
org.Eclipse.core.expressions_3.5.0.v20150421-2214.jar
org.Eclipse.core.filesystem_1.5.0.v20150421-0713.jar
org.Eclipse.core.jobs_3.7.0.v20150330-2103.jar
org.Eclipse.core.resources_3.10.0.v20150423-0755.jar
org.Eclipse.core.runtime.compatibility_3.2.300.v20150423-0821.jar
org.Eclipse.core.runtime_3.11.0.v20150405-1723.jar
org.Eclipse.datatools.connectivity.Apache.derby.dbdefinition_1.0.2.v201107221459.jar
org.Eclipse.datatools.connectivity.Apache.derby_1.0.103.v201212070447.jar
org.Eclipse.datatools.connectivity.console.profile_1.0.10.v201109250955.jar
org.Eclipse.datatools.connectivity.db.generic_1.0.1.v201107221459.jar
org.Eclipse.datatools.connectivity.dbdefinition.genericJDBC_1.0.2.v201310181001.jar
org.Eclipse.datatools.connectivity.oda.consumer_3.2.6.v201403131814.jar
org.Eclipse.datatools.connectivity.oda.design_3.3.6.v201403131814.jar
org.Eclipse.datatools.connectivity.oda.flatfile_3.1.8.v201403010906.jar
org.Eclipse.datatools.connectivity.oda.profile_3.2.9.v201403131814.jar
org.Eclipse.datatools.connectivity.oda_3.4.3.v201405301249.jar
org.Eclipse.datatools.connectivity.sqm.core_1.2.8.v201401230755.jar
org.Eclipse.datatools.connectivity_1.2.11.v201401230755.jar
org.Eclipse.datatools.enablement.hsqldb.dbdefinition_1.0.0.v201107221502.jar
org.Eclipse.datatools.enablement.hsqldb_1.0.0.v201107221502.jar
org.Eclipse.datatools.enablement.ibm.db2.iseries.dbdefinition_1.0.3.v201107221502.jar
org.Eclipse.datatools.enablement.ibm.db2.iseries_1.0.2.v201107221502.jar
org.Eclipse.datatools.enablement.ibm.db2.luw.dbdefinition_1.0.7.v201405302027.jar
org.Eclipse.datatools.enablement.ibm.db2.luw_1.0.3.v201401170830.jar
org.Eclipse.datatools.enablement.ibm.db2.zseries.dbdefinition_1.0.4.v201107221502.jar
org.Eclipse.datatools.enablement.ibm.db2.zseries_1.0.2.v201107221502.jar
org.Eclipse.datatools.enablement.ibm.db2_1.0.0.v201401170830.jar
org.Eclipse.datatools.enablement.ibm.informix.dbdefinition_1.0.4.v201107221502.jar
org.Eclipse.datatools.enablement.ibm.informix_1.0.1.v201107221502.jar
org.Eclipse.datatools.enablement.ibm_1.0.0.v201401170830.jar
org.Eclipse.datatools.enablement.msft.sqlserver.dbdefinition_1.0.1.v201201240505.jar
org.Eclipse.datatools.enablement.msft.sqlserver_1.0.3.v201308161009.jar
org.Eclipse.datatools.enablement.mysql.dbdefinition_1.0.4.v201109022331.jar
org.Eclipse.datatools.enablement.mysql_1.0.4.v201212120617.jar
org.Eclipse.datatools.enablement.oda.ws_1.2.6.v201403131825.jar
org.Eclipse.datatools.enablement.oda.xml_1.2.5.v201403131825.jar
org.Eclipse.datatools.enablement.Oracle.dbdefinition_1.0.103.v201206010214.jar
org.Eclipse.datatools.enablement.Oracle_1.0.0.v201107221506.jar
org.Eclipse.datatools.enablement.postgresql.dbdefinition_1.0.2.v201110070445.jar
org.Eclipse.datatools.enablement.postgresql_1.1.1.v201205252207.jar
org.Eclipse.datatools.enablement.sap.maxdb.dbdefinition_1.0.0.v201107221507.jar
org.Eclipse.datatools.enablement.sap.maxdb_1.0.0.v201107221507.jar
org.Eclipse.datatools.modelbase.dbdefinition_1.0.2.v201107221519.jar
org.Eclipse.datatools.modelbase.derby_1.0.0.v201107221519.jar
org.Eclipse.datatools.modelbase.sql.query_1.1.4.v201212120619.jar
org.Eclipse.datatools.modelbase.sql_1.0.6.v201208230744.jar
org.Eclipse.datatools.sqltools.data.core_1.2.3.v201212120623.jar
org.Eclipse.datatools.sqltools.parsers.sql.lexer_1.0.1.v201107221520.jar
org.Eclipse.datatools.sqltools.parsers.sql.query_1.2.1.v201201250511.jar
org.Eclipse.datatools.sqltools.parsers.sql_1.0.2.v201107221520.jar
org.Eclipse.datatools.sqltools.result_1.1.6.v201402080246.jar
org.Eclipse.emf.common_2.11.0.v20150512-0501.jar
org.Eclipse.emf.ecore.change_2.11.0.v20150512-0501.jar
org.Eclipse.emf.ecore.xmi_2.11.0.v20150512-0501.jar
org.Eclipse.emf.ecore_2.11.0.v20150512-0501.jar
org.Eclipse.equinox.app_1.3.300.v20150423-1356.jar
org.Eclipse.equinox.common_3.7.0.v20150402-1709.jar
org.Eclipse.equinox.preferences_3.5.300.v20150408-1437.jar
org.Eclipse.equinox.registry_3.6.0.v20150318-1503.jar
org.Eclipse.help_3.6.0.v20130326-1254.jar
org.Eclipse.osgi.services_3.5.0.v20150519-2006.jar
org.Eclipse.osgi_3.10.100.v20150529-1857.jar
org.Eclipse.update.configurator_3.3.300.v20140518-1928.jar
org.mozilla.javascript_1.7.5.v201504281450.jar
org.w3c.css.sac_1.3.1.v200903091627.jar
org.w3c.dom.events_3.0.0.draft20060413_v201105210656.jar
org.w3c.dom.smil_1.0.1.v200903091627.jar
org.w3c.dom.svg_1.1.0.v201011041433.jar

Propriétés de l'application (application.yml)

birt:
  report:
    output:
      dir: ${birt_temp_file_output_dir}
    input:
      dir: ${birt_report_input_dir}
  logging:
    level: ${birt_logging_level}


server:
  port: 8080
  context-path: /simple-birt-runner


birt:
  logging:
    level: SEVERE

logging:
  level:
    org:
      springframework:
        web: ERROR

Dockerfile pour l'exécution (Dockerfile)

FROM Java:openjdk-8u66-jre
MAINTAINER Kent O. Johnson <[email protected]>

COPY com.example.simple-birt-runner-*.jar /opt/soft/simple-birt-runner.jar

RUN mkdir -p /reports/input \
    && mkdir /reports/output \
    && mkdir -p /reports/log/engine

WORKDIR /opt/soft

CMD Java -jar -Xms128M -Xmx4G simple-birt-runner.jar

EXPOSE 8080

Docker compose un fichier pour l'exécution d'une image (docker-compose.yml)

simple-birt-runner:
  image: soft/simple-birt-runner-release
  ports:
  - "8090:8080"
  environment:
  - birt_temp_file_output_dir=/reports/output
  - birt_report_input_dir=/reports/input
  - birt_logging_directory=/reports/log/engine
  - birt_logging_level=SEVERE
  volumes_from:
  - birt-report-runner-data

Answer 2

En ce qui concerne la réponse de @Kent Johnson. Je n'ai pas réussi à configurer le projet avec gradle, mais j'ai réussi à le construire avec maven. Ci-dessous, le pom.xml  

    <?xml version="1.0" encoding="UTF-8"?>
        <project xmlns="http://maven.Apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.Apache.org/POM/4.0.0 http://maven.Apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>birt-runner</groupId>
<artifactId>com.example.simple-birt-runner</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <Java.version>1.8</Java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-Tomcat</artifactId>
        <!--<scope>provided</scope>-->
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.Eclipse.birt.runtime/org.Eclipse.birt.runtime -->
    <dependency>
        <groupId>org.Eclipse.birt.runtime</groupId>
        <artifactId>org.Eclipse.birt.runtime</artifactId>
        <version>4.2.0</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
    </dependency>

    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>



</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>