Avant de vouloir intégrer RTFTemplate, il faut bien comprendre le processus de génération de RTFtemplate.
Voici brièvement les deux "bonnes pratiques" d'intégration de RTFTemplate :
Chacune des 3 grandes étapes du processus de génération de RTFTemplate peuvent être configurées ou ré-implémentées. Elle sont représentés par des interfaces :
RTFTemplate peut être configuré à l'aide d'un descripteur Spring.
RTFTemplate peut être intégré dans une application de type client lourd ou dans une application WEB.
Voici un code basique qui permet d'utiliser RTFTemplate :
String rtfSource = "usecases/models/jakartavelocityproject/jakarta-velocity-model.rtf";
String rtfTarget = "jakarta-velocity-model.rtf.rtf";
// 1. Get default RTFtemplateBuilder
RTFTemplateBuilder builder = RTFTemplateBuilder.newRTFTemplateBuilder();
// 2. Get RTFtemplate with default Implementation of template engine (Velocity)
RTFTemplate rtfTemplate = builder.newRTFTemplate();
// 3. Set the RTF model source
rtfTemplate.setTemplate(new File(rtfSource));
// 4. Put the context
rtfTemplate.put("project", new Project("Jakarta Velocity project"));
...
// 5. Merge the RTF source model and the context
rtfTemplate.merge(rtfTarget);
Voici la description du code suivant :
Le fichier rtfTarget est le résultat du processus de génération de RTFTemplate (fusion du modèle et du contexte).
Si vous voulez utiliser RTFTemplate dans une application WEB, cliquez ici, sinon cliquer ici.
Si vous voulez optimiser RTFTemplate dans une application WEB, cliquez ici, sinon cliquer ici.
RTFTemplate est modulaire, chacune des étapes du processus peuvent être implémentés soit par des classes fournis par RTFTemplate soit par votre propre implémentation.
L'interface IRTFDocumentParser a pour rôle de parser un modèle RTF source pour obtenir un objet RTFDocument. L'implémentation par défaut de RTFTemplate est la classe net.sourceforge.rtf.handler.RTFDocumentHandler.
L'interface IRTFDocumentTransformer a pour but de transformer un objet RTFDocument pour que celui-ci soit inteprétable par le moteur de template sélectionné (voir étape suivante). Des macros spécifiques au moteurs de templates y sont ajoutés (#foreach dans le cas de Velocity et #list dans le cas de Freemarker). RTFTemplate implémente deux type de transformer :
Par défaut RTFTemplate utilise l'implémentation Velocity.
L'interface ITemplateEngine a pour de fusionner les données du contexte avec le contenu de l'objet RTFDocument transformé. Cette fusion s'effectue à l'aide d'un moteur de template. RTFTemplate implémente deux moteurs de templates :
Par défaut RTFTemplate utilise l'implémentation Velocity.
RTFTemplate utilisant des interfaces pour son processus de génération, il est possible de choisir ou de ré-implémenter une étape du processus. Il existe deux façons de configurer RTFTemplate. A l'aide d'un descripeur Spring (à l'aide du mécanisme d'IoC) ou en appelant les getters de RTFTemplate pour lui passer les implémentations souhaités.
Par défaut RTFTemplate utilise le fichier Spring rtftemplate-config.xml : Pour utiliser l'implémentation en Freemarker vous devez faire comme ceci
// 2. Get RTFtemplate with default Implementation of template engine (Freemarker)
RTFTemplate rtfTemplate = builder.newRTFTemplate(RTFTemplateBuilder.
DEFAULT_FREEMARKER_RTFTEMPLATE);
Voici le fichier de configuration Spring (par defaut) de RTFTemplate :
<beans>
<!-- **********************************************************************
********************* RTFTEMPLTE IMPLEMENTATION *********************
********************************************************************** -->
<!-- Defautlt RTFTemplate implementation with freemarker template engine -->
<bean id="ftlRTFTemplate"
class="net.sourceforge.rtf.RTFTemplate"
singleton="false" >
<property name="parser" ref="defaultRTFParser" />
<property name="transformer" ref="ftlTransformer" />
<property name="templateEngine" ref="ftl" />
</bean>
<!-- Defautlt RTFTemplate implementation with velocity template engine -->
<bean id="vmRTFTemplate"
class="net.sourceforge.rtf.RTFTemplate"
singleton="false" >
<property name="parser" ref="defaultRTFParser" />
<property name="transformer" ref="vmTransformer" />
<property name="templateEngine" ref="vm" />
</bean>
<!-- **********************************************************************
********************* RTFDOCUMENT PARSER *********************
********************************************************************** -->
<!-- Defautlt RTFDocument Parser -->
<bean id="defaultRTFParser"
class="net.sourceforge.rtf.handler.RTFDocumentHandler"
singleton="true" >
</bean>
<!-- **********************************************************************
********************* FREEMARKER TEMPLATE ENGINE *********************
********************************************************************** -->
<!-- Freemarker template engine -->
<bean id="ftl"
class="net.sourceforge.rtf.template.freemarker.FreemarkerTemplateEngineImpl"
singleton="false" >
<property name="freemarkerConfiguration" ref="ftlConfiguration" />
</bean>
<!-- Freemarker Configuration -->
<bean id="ftlConfiguration"
class="freemarker.template.Configuration"
singleton="true" >
</bean>
<!-- Freemarker RTF Document Transformer -->
<bean id="ftlTransformer"
class="net.sourceforge.rtf.template.freemarker.RTFFreemarkerTransformerImpl"
singleton="true" >
</bean>
<!-- **********************************************************************
********************* VELOCITY TEMPLATE ENGINE *********************
********************************************************************** -->
<bean id="vm"
class="net.sourceforge.rtf.template.velocity.VelocityTemplateEngineImpl"
singleton="false" >
<property name="velocityEngine" ref="vmEngine" />
</bean>
<!-- VelocityEngine Configuration -->
<bean id="vmEngine"
class="org.apache.velocity.app.VelocityEngine"
singleton="true" >
</bean>
<!-- Velocity RTF Document Transformer -->
<bean id="vmTransformer"
class="net.sourceforge.rtf.template.velocity.RTFVelocityTransformerImpl"
singleton="true" >
</bean>
</beans>
Les 3 interfaces se retrouvent dans ce fichier qui permet d'assembler des configuration de RTFTemplate. Par exemple, la définition du bean d'id vmRTFTemplate permet d'indiquer à RTFTemplate d'utiliser :
La classe RTFDocumentBuilder permet de charger la configuration Spring par défaut de RTFtemplate. Par exemple pour utiliser le moteur de template Freemarker avec RTFTemplate vous devez faire comme ceci :
// 1. Get default RTFtemplateBuilder
RTFTemplateBuilder builder = RTFTemplateBuilder.newRTFTemplateBuilder();
// 2. Get RTFtemplate with default Implementation of template engine (Freemarker)
RTFTemplate rtfTemplate = builder.newRTFTemplate("ftlRTFTemplate");
Il est possible d'utiliser votre propre configuration Spring (pour implementer les interfaces avec vos propres classes) :
// Load rtftemplate-config Spring configuration
String key =
"net/sourceforge/rtf/usecases/config/rtftemplate-config.xml";
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(key);
// 1. Get RTFtemplateBuilder with spring config
RTFTemplateBuilder builder = RTFTemplateBuilder.newRTFTemplateBuilder(key, applicationContext);
La configuration de Spring est mis en cache. Pour réutiliser votre configuration :
String key =
"net/sourceforge/rtf/usecases/config/rtftemplate-config.xml";
// 1. Get RTFtemplateBuilder with spring config
RTFTemplateBuilder builder = RTFTemplateBuilder.newRTFTemplateBuilder(key);
La configuration suivante peut s'effectuer programatiquement:
RTFTemplate rtfTemplate = new RTFTemplate(); // Parser RTFDocumentHandler parser = new RTFDocumentHandler(); rtfTemplate.setParser(parser); // Transformer IRTFDocumentTransformer transformer = new RTFVelocityTransformerImpl(); rtfTemplate.setTransformer(transformer); // Template engine VelocityTemplateEngineImpl templateEngine = new VelocityTemplateEngineImpl(); // Initialize velocity engine VelocityEngine velocityEngine = new VelocityEngine(); templateEngine.setVelocityEngine(velocityEngine); rtfTemplate.setTemplateEngine(templateEngine);