Introduction à Apache Velocity

1. Vue d'ensemble

Velocity est un moteur de création de modèles basé sur Java.

Il s’agit d’un framework Web open source conçu pour être utilisé comme composant de vue dans l’architecture MVC, et il offre une alternative à certaines technologies existantes telles que JSP.

Velocity peut être utilisé pour générer des fichiers XML, SQL, PostScript et la plupart des autres formats textuels.

Dans cet article, nous allons explorer comment l’utiliser pour créer des pages Web dynamiques.

2. Comment fonctionne Velocity

La classe principale de Velocity est leVelocityEngine.

Il orchestre l'ensemble du processus de lecture, d'analyse et de génération de contenu à l'aide d'un modèle de données et d'un modèle de vélocité.

En termes simples, voici les étapes à suivre pour toute application de vélocité typique:

Initialiser le moteur de vélocité
Lire le modèle
Placer le modèle de données en objet contextuel
Fusionner le modèle avec les données de contexte et rendre la vue

Let’s go through an example en suivant ces étapes simples:

VelocityEngine velocityEngine = new VelocityEngine();
velocityEngine.init();

Template t = velocityEngine.getTemplate("index.vm");

VelocityContext context = new VelocityContext();
context.put("name", "World");

StringWriter writer = new StringWriter();
t.merge( context, writer );

3. Dépendances Maven

Pour travailler avec Velocity, nous devons ajouter les dépendances suivantes à notre projet Maven:


    org.apache.velocity
    velocity
    1.7
    

     org.apache.velocity
     velocity-tools
     2.0

La dernière version de ces deux dépendances peut être ici:velocity etvelocity-tools.

4. Langage de modèle de vitesse

Velocity Template Language (VTL) constitue le moyen le plus simple et le plus propre d’incorporer le contenu dynamique dans une page Web à l’aide de références VTL.

La référence VTL dans le modèle de vitesse commence par un$ et est utilisée pour obtenir la valeur associée à cette référence. VTL fournit également un ensemble de directives pouvant être utilisées pour manipuler la sortie du code Java. Ces directives commencent par#.

4.1. Références

Il existe trois types de références dans Velocity, variables, propriétés et méthodes:

variables - défini dans la page à l'aide de la directive#set ou de la valeur renvoyée par le champ de l'objet Java:
```
#set ($message="Hello World")
```
properties - fait référence aux champs dans un objet; ils peuvent également faire référence à une méthodegetter de la propriété:
```
$customer.name
```
methods - reportez-vous à la méthode sur l'objet Java:
```
$customer.getName()
```

La valeur finale résultant de chaque référence est convertie en une chaîne lorsqu'elle est rendue dans la sortie finale.

4.2. Directives

VTL fournit un riche ensemble de directives:

set - il peut être utilisé pour définir la valeur d'une référence; cette valeur peut être affectée à une variable ou à une référence de propriété:
```
#set ($message = "Hello World")
#set ($customer.name = "Brian Mcdonald")
```

Les directivesconditionals -#if, #elseif et#else fournissent un moyen de générer le contenu basé sur des contrôles conditionnels:

#if($employee.designation == "Manager")
     Manager 
#elseif($employee.designation == "Senior Developer")
     Senior Software Engineer 
#else
     Trainee 
#end

La directiveloops -#foreach permet de boucler sur une collection d'objets:


    #foreach($product in $productList)
         $product 
    #end

L'élémentinclude -#include offre la possibilité d'importer des fichiers dans le modèle:
```
#include("one.gif","two.txt","three.html"...)
```
L'instructionparse -#parse permet au concepteur de modèle d'importer un autre fichier local qui contient VTL; Velocity analysera ensuite le contenu et le rendra:
```
#parse (Template)
```
La directiveevaluate -#evaluate peut être utilisée pour évaluer dynamiquement VTL; cela permet au modèle d'évaluer unString au moment du rendu, par exemple pour internationaliser le modèle:
```
#set($firstName = "David")
#set($lastName = "Johnson")

#set($dynamicsource = "$firstName$lastName")

#evaluate($dynamicsource)
```
La directivebreak -#break arrête tout rendu supplémentaire de la portée d'exécution actuelle (c.-à-d. #foreach,#parse)
La directivestop -#stop arrête tout rendu et exécution ultérieurs du modèle.
La directivevelocimacros -#macro permet au concepteur de modèle de définir un segment répété de VTL:
```
#macro(tablerows)
    
        
        
    
#end
```
Cette macro peut maintenant être placée n'importe où dans le modèle en tant que #tablerows():
```
#macro(tablerows $color $productList)
    #foreach($product in $productList)
        
            $product.name
        
    #end
#end
```

4.3. Autres caractéristiques

math - une poignée de fonctions mathématiques intégrées, qui peuvent être utilisées dans les modèles:
```
#set($percent = $number / 100)
#set($remainder = $dividend % $divisor)
```

range operator - qui peut être utilisé avec#set et#foreach:

#set($array = [0..10])

#foreach($elem in $arr)
    $elem
#end

5. Servlet de vitesse

Le travail principal du moteur Velocity est de générer un contenu basé sur un modèle.

Le moteur ne contient en lui-même aucune fonctionnalité liée au Web. Pour mettre en œuvre une application Web, nous devons utiliser un servlet ou une infrastructure basée sur un servlet.

Velocity fournit une implémentation prête à l'emploiVelocityViewServlet, qui fait partie du sous-projet velocity-tools.

Pour utiliser la fonctionnalité intégrée fournie parVelocityViewServlet,, nous pouvons étendre notre servlet à partir deVelocityViewServlet et remplacer la méthodehandleRequest():

public class ProductServlet extends VelocityViewServlet {

    ProductService service = new ProductService();

    @Override
    public Template handleRequest(
      HttpServletRequest request,
      HttpServletResponse response,
      Context context) throws Exception {

        List products = service.getProducts();
        context.put("products", products);

        return getTemplate("index.vm");
    }
}

6. Configuration

6.1. Configuration Web

Voyons maintenant comment configurer lesVelocityViewServlet dans lesweb.xml.

Nous devons spécifier les paramètres d'initialisation facultatifs qui incluentvelocity.properties ettoolbox.xml:


    apache-velocity
      //...

    
        velocity
        org.apache.velocity.tools.view.VelocityViewServlet

        
            org.apache.velocity.properties
            /WEB-INF/velocity.properties
        
    
        //...

Nous devons également spécifier le mappage pour ce servlet. Toutes les demandes de modèles de vitesse (*.vm) doivent être servies par le servlet de vitesse:


    velocityLayout
    *.vm

6.2. Chargeur de ressources

Velocity fournit un système de chargeur de ressources flexible. Il permet à un ou plusieurs chargeurs de ressources d'être utilisés simultanément:

FileResourceLoader
JarResourceLoader
ClassPathResourceLoader
URLResourceLoader
DataSourceResourceLoader
WebappResourceLoader

Ces chargeurs de ressources sont configurés envelocity.properties:

resource.loader=webapp
webapp.resource.loader.class=org.apache.velocity.tools.view.WebappResourceLoader
webapp.resource.loader.path =
webapp.resource.loader.cache = true

7. Modèle de vitesse

Le modèle Velocity est l’endroit où toute la logique de génération de vues est écrite. Ces pages sont écrites à l’aide de VTL (Velocity Template Language):


    ...
    
        
        ...
        $products.size() Products on Sale!
        

            We are proud to offer these fine products
            at these amazing prices.
        ...
        #set( $count = 1 )
        
            #foreach( $product in $products )
            
            #set( $count = $count + 1 )
            #end
        
            
                Serial #
                Product Name
                Price
            

                $count)
                $product.getName()
                $product.getPrice()

Serial #	Product Name	Price
$count)	$product.getName()	$product.getPrice()

8. Gérer la mise en page

Velocity fournit un contrôle de mise en page simple et des écrans d'erreur personnalisables pour les applications basées sur Velocity Tool.

VelocityLayoutServlet encapsule cette capacité à rendre les dispositions spécifiées. VelocityLayoutServlet est une extension deVelocityViewServlet.

8.1. Configuration Web

Voyons comment configurer lesVelocityLayoutServlet. Le servlet est défini pour intercepter les demandes de pages de modèle de vitesse et les propriétés spécifiques à la mise en page sont définies dans le fichiervelocity.properties:


    // ...
    
        velocityLayout
        org.apache.velocity.tools.view.VelocityLayoutServlet

        
            org.apache.velocity.properties
            /WEB-INF/velocity.properties
        
    
    // ...
    
        velocityLayout
        *.vm
    
    // ...

8.2. Modèles de mise en page

Le modèle de présentation définit la structure typique d'une page de vélocité. Par défaut, leVelocityLayoutServlet rechercheDefault.vm sous le dossier de mise en page. Remplacer quelques propriétés peut changer cet emplacement:

tools.view.servlet.layout.directory = layout/
tools.view.servlet.layout.default.template = Default.vm

Le fichier de mise en page se compose d'un modèle d'en-tête, d'un modèle de pied de page et d'une variable de vitesse$screen_content qui rend le contenu de la page de vitesse demandée:


    
        Velocity
    
    
        
            #parse("/fragments/header.vm")
        
        
            
            $screen_content
        
        
            #parse("/fragments/footer.vm")

8.3. Spécification de disposition dans l'écran demandé

La mise en page pour un écran particulier peut être définie comme une variable de vitesse au début d'une page. Cela se fait en mettant cette ligne dans la page:

#set($layout = "MyOtherLayout.vm")

8.4. Spécification de disposition dans le paramètre de demande

Nous pouvons ajouter un paramètre de requête dans la chaîne de requêtelayout=MyOtherLayout.vm et VLS le trouvera et rendra l'écran dans cette mise en page au lieu de rechercher la mise en page par défaut.

8.5. Écrans d'erreur

L'écran d'erreur personnalisé peut être implémenté à l'aide de la disposition de vélocité. VelocityLayoutServlet fournit deux variables$error_cause et$stack_trace pour présenter les détails de l'exception.

La page d'erreur peut être configurée dans le fichiervelocity.properties:

tools.view.servlet.error.template = Error.vm

9. Conclusion

Dans cet article, nous avons appris que Velocity est un outil utile pour le rendu des pages Web dynamiques. Nous avons également vu différentes manières d’utiliser les servlets fournis par vélocité.

Nous avons également un article axé sur une configuration Velocity avec Spring MVChere at example.

Le code complet de ce didacticiel est disponibleover on GitHub.

TOC

Introduction à Apache Velocity