Einführung in die Apache-Geschwindigkeit

1. Übersicht

Velocity ist eine Java-basierte Template-Engine.

Es handelt sich um ein Open Source-Webframework, das als Ansichtskomponente in der MVC-Architektur verwendet werden kann und eine Alternative zu einigen vorhandenen Technologien wie JSP bietet.

Mit Velocity können XML-Dateien, SQL, PostScript und die meisten anderen textbasierten Formate generiert werden.

In diesem Artikel werden wir untersuchen, wie damit dynamische Webseiten erstellt werden können.

2. Wie Geschwindigkeit funktioniert

Die Kernklasse von Velocity ist die VelocityEngine .

Es koordiniert den gesamten Prozess des Lesens, Parsens und Generierens von Inhalten mithilfe eines Datenmodells und einer Geschwindigkeitsvorlage.

Einfach ausgedrückt, hier sind die Schritte, die wir für jede typische Geschwindigkeitsanwendung ausführen müssen:

  • Initialisieren Sie den Geschwindigkeitsmotor
  • Lesen Sie die Vorlage
  • Setzen Sie das Datenmodell in ein Kontextobjekt
  • Führen Sie die Vorlage mit Kontextdaten zusammen und rendern Sie die Ansicht

Lassen Sie uns anhand dieser einfachen Schritte ein Beispiel durchgehen :

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. Maven-Abhängigkeiten

Um mit Velocity arbeiten zu können, müssen wir unserem Maven-Projekt folgende Abhängigkeiten hinzufügen:

 org.apache.velocity velocity 1.7   org.apache.velocity velocity-tools 2.0 

Die neueste Version dieser beiden Abhängigkeiten kann hier sein: Geschwindigkeit und Geschwindigkeitswerkzeuge.

4. Velocity Template Language

Velocity Template Language (VTL) bietet die einfachste und sauberste Möglichkeit, den dynamischen Inhalt mithilfe von VTL-Referenzen in eine Webseite zu integrieren.

Die VTL-Referenz in der Geschwindigkeitsvorlage beginnt mit einem $ und wird verwendet, um den dieser Referenz zugeordneten Wert abzurufen. VTL bietet auch eine Reihe von Anweisungen, mit denen die Ausgabe des Java-Codes bearbeitet werden kann. Diese Anweisungen beginnen mit #.

4.1. Verweise

Es gibt drei Arten von Referenzen in Geschwindigkeit, Variablen, Eigenschaften und Methoden:

  • Variablen - innerhalb der Seite mithilfe der Direktive #set oder des vom Feld des Java-Objekts zurückgegebenen Werts definiert:
    #set ($message="Hello World")
  • Eigenschaften - beziehen sich auf Felder innerhalb eines Objekts; Sie können sich auch auf eine Getter- Methode der Eigenschaft beziehen :
    $customer.name
  • Methoden - beziehen Sie sich auf die Methode für Java-Objekt:
    $customer.getName()

Der endgültige Wert, der sich aus jeder Referenz ergibt, wird beim Rendern in die endgültige Ausgabe in eine Zeichenfolge konvertiert.

4.2. Richtlinien

VTL bietet eine Vielzahl von Anweisungen:

  • set - kann zum Einstellen des Referenzwerts verwendet werden; Dieser Wert kann einer Variablen oder einer Eigenschaftsreferenz zugewiesen werden:
    #set ($message = "Hello World") #set ($customer.name = "Brian Mcdonald")
  • Bedingungen - Die Direktiven #if, #elseif und #else bieten eine Möglichkeit, den Inhalt basierend auf bedingten Prüfungen zu generieren:
    #if($employee.designation == "Manager") 

    Manager

    #elseif($employee.designation == "Senior Developer")

    Senior Software Engineer

    #else

    Trainee

    #end
  • Schleifen - Die Direktive #foreach ermöglicht das Durchlaufen einer Sammlung von Objekten:
    
          
      #foreach($product in $productList)
    • $product
    • #end
  • include - Das Element #include bietet die Möglichkeit, Dateien in die Vorlage zu importieren:
    #include("one.gif","two.txt","three.html"...)
  • analysieren - #parse Anweisung ermöglicht die Vorlage Designer eine andere lokale Datei zu importieren , die VTL enthält; Velocity analysiert dann den Inhalt und rendert ihn:
    #parse (Template)
  • evaluate#evaluate directive can be used to evaluate VTL dynamically; this allows the template to evaluate a String at render time, for example to internationalise the template:
    #set($firstName = "David") #set($lastName = "Johnson") #set($dynamicsource = "$firstName$lastName") #evaluate($dynamicsource)
  • break#break directive stops any further rendering of current execution scope (i.e. #foreach, #parse)
  • stop#stop directive stops any further rendering and execution of the template.
  • velocimacros#macro directive allows the template designer to define a repeated segment of VTL:
    #macro(tablerows)  #end

    This macro now can be put in any place in the template as #tablerows():

    #macro(tablerows $color $productList) #foreach($product in $productList) $product.name #end #end

4.3. Other Features

  • math – a handful built-in mathematical functions, which can be used in templates:
    #set($percent = $number / 100) #set($remainder = $dividend % $divisor)
  • range operator – that can be used in conjunction with #set and #foreach:
    #set($array = [0..10]) #foreach($elem in $arr) $elem #end

5. Velocity Servlet

The primary job of the Velocity Engine is to generate content based on a template.

The Engine doesn't contain any web related functionalities in itself. To implement a web application, we need to use a servlet or servlet-based framework.

Velocity provides one out of the box implementation VelocityViewServlet, which is a part of the velocity-tools subproject.

To make use of the built-in functionality provided by VelocityViewServlet, we can extend our servlet from VelocityViewServlet and override the handleRequest() method:

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. Web Configuration

Let's now see how to configure the VelocityViewServlet in the web.xml.

We need to specify the optional initialization parameters which include velocity.properties and toolbox.xml:

 apache-velocity //...  velocity org.apache.velocity.tools.view.VelocityViewServlet  org.apache.velocity.properties /WEB-INF/velocity.properties   //...  

We also need to specify the mapping for this servlet. All the requests for velocity templates (*.vm) need to be served by the velocity servlet:

 velocityLayout *.vm 

6.2. Resource Loader

Velocity provides flexible resource loader system. It allows one or more resource loader to be in operation at the same time:

  • FileResourceLoader
  • JarResourceLoader
  • ClassPathResourceLoader
  • URLResourceLoader
  • DataSourceResourceLoader
  • WebappResourceLoader

These resource loaders are configured in velocity.properties:

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

7. Velocity Template

Velocity template is the place where all the view generation logic is written. These pages are written using Velocity Template Language (VTL):

 ...   ... 

$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()

8. Managing the Page Layout

Velocity provides a simple layout control and customizable error screens for Velocity Tool based application.

VelocityLayoutServlet encapsulates this capability to render the specified layouts. VelocityLayoutServlet is an extension to VelocityViewServlet.

8.1. Web Configuration

Let's see how to configure the VelocityLayoutServlet. The servlet is defined for intercepting the requests for velocity template pages and the layout specific properties are defined in velocity.properties file:

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

8.2. Layout Templates

Layout template defines the typical structure of a velocity page. By default, the VelocityLayoutServlet searches for Default.vm under the layout folder. Overriding few properties can change this location:

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

The layout file consists of header template, footer template, and a velocity variable $screen_content which renders the contents of requested velocity page:

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

8.3. Layout Specification in the Requested Screen

Layout for a particular screen can be defined as a velocity variable at the beginning of a page. That is done by putting this line in the page:

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

8.4. Layout Specification in the Request Parameter

We can add a request parameter in the query string layout=MyOtherLayout.vm and VLS will find it and render the screen within that layout instead of searching for default layout.

8.5. Error Screens

Customized error screen can be implemented using velocity layout. VelocityLayoutServlet provides two variables $error_cause and $stack_trace to present the exception details.

Error page can be configured in velocity.properties file:

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

9. Conclusion

In diesem Artikel haben wir gelernt, wie Velocity ein nützliches Werkzeug zum Rendern der dynamischen Webseiten ist. Wir haben auch verschiedene Möglichkeiten zur Verwendung von Servlets mit Geschwindigkeitsbereitstellung gesehen.

Wir haben auch einen Artikel über eine Velocity-Konfiguration mit Spring MVC hier in Baeldung.

Der vollständige Code für dieses Tutorial ist auf GitHub verfügbar.