Pengenalan kepada Kecepatan Apache

1. Gambaran keseluruhan

Velocity adalah mesin templat berasaskan Java.

Ini adalah kerangka web sumber terbuka yang dirancang untuk digunakan sebagai komponen pandangan dalam seni bina MVC, dan memberikan alternatif kepada beberapa teknologi yang ada seperti JSP.

Velocity dapat digunakan untuk menghasilkan fail XML, SQL, PostScript dan kebanyakan format berasaskan teks yang lain.

Dalam artikel ini, kita akan meneroka bagaimana ia dapat digunakan untuk membuat laman web dinamik.

2. Bagaimana Velocity Berfungsi

Kelas teras Velocity adalah VelocityEngine .

Ia mengatur keseluruhan proses membaca, menghuraikan dan menghasilkan kandungan menggunakan model data dan templat halaju.

Ringkasnya, berikut adalah langkah-langkah yang perlu kita ikuti untuk sebarang aplikasi halaju biasa:

  • Memulakan enjin halaju
  • Baca templat
  • Letakkan model data dalam objek konteks
  • Gabungkan templat dengan data konteks dan buat paparan

Mari kita ikuti contoh berikut langkah mudah ini:

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. Pergantungan Maven

Untuk bekerjasama dengan Velocity, kita perlu menambahkan kebergantungan berikut pada projek Maven kami:

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

Versi terkini kedua-dua kebergantungan ini boleh didapati di sini: alat kelajuan dan kelajuan.

4. Bahasa Templat Kecepatan

Velocity Template Language (VTL) menyediakan kaedah termudah dan paling bersih untuk memasukkan kandungan dinamik dalam laman web dengan menggunakan rujukan VTL.

Rujukan VTL dalam templat halaju bermula dengan $ dan digunakan untuk mendapatkan nilai yang berkaitan dengan rujukan itu. VTL juga menyediakan seperangkat arahan yang dapat digunakan untuk memanipulasi output dari kod Java. Arahan tersebut bermula dengan #.

4.1. Rujukan

Terdapat tiga jenis rujukan dalam Kecepatan, pemboleh ubah, sifat dan kaedah:

  • pemboleh ubah - ditentukan dalam halaman menggunakan arahan #set atau nilai yang dikembalikan dari medan objek Java:
    #set ($message="Hello World")
  • sifat - merujuk bidang dalam objek; mereka juga boleh merujuk kepada getter kaedah harta:
    $customer.name
  • kaedah - rujuk kaedah pada objek Java:
    $customer.getName()

Nilai akhir yang dihasilkan dari setiap rujukan diubah menjadi rentetan ketika diberikan menjadi output akhir.

4.2. Arahan

VTL memberikan pelbagai arahan:

  • set - ia boleh digunakan untuk menetapkan nilai rujukan; nilai ini boleh diberikan kepada pemboleh ubah atau rujukan harta tanah:
    #set ($message = "Hello World") #set ($customer.name = "Brian Mcdonald")
  • arahan bersyarat - #if, #elseif dan #else memberikan cara untuk menghasilkan kandungan berdasarkan pemeriksaan bersyarat:
    #if($employee.designation == "Manager") 

    Manager

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

    Senior Software Engineer

    #else

    Trainee

    #end
  • gelung - Arahan #foreach membolehkan melonggarkan koleksi objek:
    
          
      #foreach($product in $productList)
    • $product
    • #end
  • termasuk - #include elemen menyediakan keupayaan untuk fail import ke dalam template:
    #include("one.gif","two.txt","three.html"...)
  • parse - #parse statement membenarkan pereka templat mengimport fail tempatan lain yang mengandungi VTL; Velocity kemudian akan menguraikan kandungan dan menjadikannya:
    #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

Dalam artikel ini, kita telah belajar bagaimana Velocity adalah alat yang berguna untuk membuat halaman web yang dinamis. Juga, kami telah melihat pelbagai cara menggunakan servlet yang disediakan dengan kelajuan.

Kami juga mempunyai artikel yang berfokus pada konfigurasi Velocity dengan Spring MVC di Baeldung.

Kod lengkap untuk tutorial ini boleh didapati di GitHub.