Birt: problèmes de mémoire

[nicolemans72]

Bonjour à tous.

Je suis en train de développer une application en Java (tournant sur un serveur tomcat) et utilisant le BirtEngine pour générer des reports.

Or, le serveur crash presque quotidiennement, probablement à cause de problèmes de mémoire dus à Birt

Pourtant, je n'utilise qu'un seul BirtEngine pour générer mes reports, je ne vois aucune raison d'avoir une surcharge de mémoire. Voici le code que j'utilise pour lancer mon BirtEngine:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
package bsa.common.integration;
 
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Properties;
import java.util.logging.Level;
 
import javax.servlet.ServletContext;
 
import org.eclipse.birt.core.exception.BirtException;
import org.eclipse.birt.core.framework.Platform;
import org.eclipse.birt.report.engine.api.EngineConfig;
import org.eclipse.birt.report.engine.api.IReportEngine;
import org.eclipse.birt.report.engine.api.IReportEngineFactory;
 
public class BirtEngine {
 
	private static IReportEngine birtEngine = null;
 
	private static Properties configProps = new Properties();
 
	private final static String configFile = "config.properties";
 
/*	
	public static synchronized void initBirtConfig() {
		loadEngineProps();
	}
*/
 
	public static synchronized IReportEngine getBirtEngine(ServletContext sc) {
		if (birtEngine == null) {
 
			loadEngineProps(sc);
 
			EngineConfig config = new EngineConfig();
			if (configProps != null) {
				String logLevel = configProps.getProperty("logLevel");
				Level level = Level.OFF;
				if ("SEVERE".equalsIgnoreCase(logLevel)) {
					level = Level.SEVERE;
				} else if ("WARNING".equalsIgnoreCase(logLevel)) {
					level = Level.WARNING;
				} else if ("INFO".equalsIgnoreCase(logLevel)) {
					level = Level.INFO;
				} else if ("CONFIG".equalsIgnoreCase(logLevel)) {
					level = Level.CONFIG;
				} else if ("FINE".equalsIgnoreCase(logLevel)) {
					level = Level.FINE;
				} else if ("FINER".equalsIgnoreCase(logLevel)) {
					level = Level.FINER;
				} else if ("FINEST".equalsIgnoreCase(logLevel)) {
					level = Level.FINEST;
				} else if ("OFF".equalsIgnoreCase(logLevel)) {
					level = Level.OFF;
				}
 
				config.setLogConfig(configProps.getProperty("logDirectory"),
						level);
			}
 
			String appDir = System.getProperty("catalina.home"); // repertoire TomCat
			appDir += configProps.getProperty("birtTomcatPath"); // rep. du reportEngine
			config.setEngineHome(appDir);
 
			/*
			 * IPlatformContext context = new PlatformServletContext( sc );
			 * 
			 * config.setPlatformContext( context );
			 */
 
			try {
				Platform.startup(config);
			} catch (BirtException e) {
				e.printStackTrace();
			}
 
			IReportEngineFactory factory = (IReportEngineFactory) Platform
					.createFactoryObject(IReportEngineFactory.EXTENSION_REPORT_ENGINE_FACTORY);
			birtEngine = factory.createReportEngine(config);
 
		}
		return birtEngine;
	}
 
	public static synchronized void destroyBirtEngine() {
		if (birtEngine == null) {
			return;
		}
		birtEngine.shutdown();
		Platform.shutdown();
		birtEngine = null;
	}
 
	public Object clone() throws CloneNotSupportedException {
		throw new CloneNotSupportedException();
	}
 
 
 
	private static void loadEngineProps(ServletContext sc) {
		try {
			String pathName = sc.getRealPath("/");
			 pathName += "WEB-INF/classes/" + configFile;
			 InputStream in = new FileInputStream(pathName);
			 configProps.load(in);
 
			 /*
			  	// Parcours des variables environmentales
				Set keySet = envMap.keySet();
				Iterator it = keySet.iterator();
				System.out.println(":	Key " +  "\t\t\t\t\t\t\t\t\t\t | " + "Value \t\t\t\t\t\t\t|");
				while (it.hasNext()) {
					String key = (String) it.next();
					System.out.println(":" + key + "\t | " + envMap.get(key) + "\t|");
				}
 
				// sert uniquement à afficher toutes les propriétés Systèmes..
				Properties p = System.getProperties();
				Enumeration enu = p.keys();
 
				while (enu.hasMoreElements()) {
					String key = (String) enu.nextElement();
					System.out.println(key + "\t -> \t" + p.getProperty(key));
				}
			*/
 
	}
		catch (Exception e) {
			e.printStackTrace();
		}
	}
 
	public static String getConfigFile() {
		return configFile;
	}
 
	public static Properties getConfigProps() {
		return configProps;
	}
 
	public static void setConfigProps(Properties configProps) {
		BirtEngine.configProps = configProps;
	}
 
}

et le Servlet qui le lance:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
package bsa.common.integration;
 
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Properties;
 
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.eclipse.birt.core.framework.Platform;
import org.eclipse.birt.report.engine.api.EngineConstants;
import org.eclipse.birt.report.engine.api.HTMLRenderContext;
import org.eclipse.birt.report.engine.api.HTMLRenderOption;
import org.eclipse.birt.report.engine.api.IReportEngine;
import org.eclipse.birt.report.engine.api.IReportRunnable;
import org.eclipse.birt.report.engine.api.IRunAndRenderTask;
 
/**
 * 
 * Classe Abstraite à étendre pour disposer des fonctionnalités de Birt 
 * permet d'obtenir un rapport depuis un page JSP ou autre en passant les paramètres 
 * récupérés dans une HashMap.
 * 
 *  <p>Selon le paramètre typeDeSortie (défini dans le config.properties), le rendu sera de type :
 *  <li>pdf
 *  <li>html
 *  <li>fo
 *  <li>stream 
 * </p>
 * @web.servlet name=BirtBasicServlet
 * 
 * @author BSA Conseil(c) 2007
 * 
 */
public abstract class BirtBasicServlet extends HttpServlet {
 
	private static final long serialVersionUID = -6647863516532919344L;
 
	private IReportEngine birtReportEngine;
 
	/**
	 * Methode à implémenter de traitement de la requête en mode GET
	 * 
	 */
	public abstract void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException;
 
	/**
	 * Methode de traitement de la requête en mode POST
	 * 
	 */
	public abstract void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException;
 
	/**
	 * 
	 * 
	 * @param request
	 * @param response
	 * @throws ServletException
	 */
	protected void processRequest(HttpServletRequest request,
			HttpServletResponse response, HashMap param)
			throws ServletException {
 
		// Récupération du nom du rapport et lancement de Birt Engine.
		ServletContext sc = request.getSession().getServletContext();
 
		try {
			this.birtReportEngine = BirtEngine.getBirtEngine(sc);
		} catch (Exception e) {
			e.printStackTrace();
		}
 
		// Récupération des propriétés pour la servlet
		Properties prop = BirtEngine.getConfigProps();
		String nomRapportBirt = prop.getProperty("nomRapportBirt");
		String typeDeSortie = prop.getProperty("typeDeSortie");
		String nomRapport = request.getParameter(nomRapportBirt);
 
		// Récupération du chemin de Birt dans l'application.
		String rptPath = prop.getProperty("birtAppPath");
		String imagePath = prop.getProperty("birtImagePath");
 
		// configuration du répértoire d'images
		HTMLRenderContext renderContext = new HTMLRenderContext();
 
		renderContext.setBaseImageURL(request.getContextPath() + "/images");
		renderContext.setImageDirectory(sc.getRealPath(imagePath));
 
		HashMap<String, HTMLRenderContext> contextMap = new HashMap<String, HTMLRenderContext>();
 
		contextMap.put(EngineConstants.APPCONTEXT_HTML_RENDER_CONTEXT, renderContext);
 
		IReportRunnable design;
		IRunAndRenderTask task;
 
		try {
 
			// Ouverture du Report designer
			design = ((IReportEngine) birtReportEngine).openReportDesign(sc.getRealPath(rptPath)
					+ "/" + nomRapport + ".rptdesign");
 
			// creation d'une tache et génération du rapport
			task = ((IReportEngine) birtReportEngine).createRunAndRenderTask(design);
 
			task.setAppContext(contextMap);
 
			// Ajout des Objets Paramétrisés au rapport
			Iterator it = param.keySet().iterator();
 
			while (it.hasNext()) {
				String key = (String) it.next();
				//task.addScriptableJavaObject(key, param.get(key));
				task.setParameterValue(key, param.get(key));
			}
 
			// Récupération du format de sortie
			String output = (String) request.getParameter(typeDeSortie);
 
			if (null == output) {
				output = "html";
			} else if (output.equals("pdf")) {
				output = HTMLRenderOption.OUTPUT_FORMAT_PDF;
				response.setContentType("application/pdf");
			} else if (output.equals("html")) {
				output = HTMLRenderOption.OUTPUT_FORMAT_HTML;
				response.setContentType("text/html");
			} else if (output.equals("stream")) {
				output = HTMLRenderOption.OUTPUT_STREAM;
			} else if (output.equals("fo")) {
				output = HTMLRenderOption.OUTPUT_FORMAT_FO;
			}
 
			// Options de sorties
			HTMLRenderOption options = new HTMLRenderOption();
			options.setOutputFormat(output);
			options.setOutputStream(response.getOutputStream());
			task.setRenderOption(options);
 
			// Lancement du rapport
			task.run();
			task.close();
 
			// Fermeture de l'engine de la task
			task.getEngine().shutdown();
 
		} catch (Exception e) {
			e.printStackTrace();
			throw new ServletException(e);
 
		} finally {
 
			// Fermeture de l'engine
			this.birtReportEngine.shutdown();
 
			System.gc();
		}
	}
 
	public IReportEngine getBirtReportEngine() {
		return birtReportEngine;
	}
 
	public void setBirtReportEngine(IReportEngine birtReportEngine) {
		this.birtReportEngine = birtReportEngine;
	}
 
}

Voyez-vous une erreur dans mon code?
Quelqu'un a t-il déja rencontrer ce genre de problème?

[BiM]

Les dépassements de mémoire se font plutôt à la génération d'un état énorme qu'autre chose.

Evidemment, si tu as un état avec 12 000 images, 3 millions de lignes à génerer, et des calculs à l'intérieur, il va pas aimer...

[moritan]

Vérifie aussi la taille de la JVM qui fait tourner ton serveur Tomcat.
car à la génération de PDF Fop est gourmand. Il a besoin d'espace pour s'épanouir. et Si ton document est un peut gros, une JVM par défaut ne suffit pas. Il faut au moins 256Mo, du moins sur le serveur BIRT qu'on a mis en place.