Mulai Mesin Template Kecepatan

Mesin Template Velocity memungkinkan Anda merender data dari dalam aplikasi dan servlet. Terutama digunakan untuk mengembangkan Situs Web dinamis berbasis servlet, pemisahan template dan kode Java Velocity yang bersih membuatnya ideal untuk pengembangan Web MVC. Sebagai mesin templat umum, Velocity sesuai dengan banyak tujuan lain, seperti pembuatan kode, pembuatan dan transformasi XML, dan pemrosesan aliran tekstual. Artikel ini memperkenalkan Velocity Template Language (VTL) dan memberikan contoh cara menggunakan mesin Velocity, termasuk cara membuat konten Web di lingkungan servlet Java.

Velocity adalah alat pembuatan template sumber terbuka yang dikembangkan oleh komunitas sukarelawan internasional dan diselenggarakan oleh Proyek Jakarta Apache Software Foundation. Di Situs Web Jakarta Velocity Project, di mana Anda dapat mengunduh kode sumber yang tersedia secara gratis, komunitas pengguna yang berkembang dan berkembang siap menjawab pertanyaan dan menawarkan solusi untuk masalah template yang umum. Velocity terinspirasi oleh proyek WebMacro perintis, sebuah karya yang kami syukuri dalam komunitas Velocity.

Pada artikel ini, saya menyajikan primer singkat tentang Velocity Template Engine dan bahasa template-nya, Velocity Template Language (VTL). Saya juga mendemonstrasikan cara menggunakan Velocity melalui beberapa contoh.

Halo Dunia, tentu saja

Tidak ada penjelasan tentang subjek terkait pemrograman yang akan lengkap tanpa contoh Hello World. Aplikasi apa pun yang menggunakan Velocity membutuhkan dua bagian. Yang pertama adalah template, yang dalam contoh ini adalah file bernama helloworld.vm:

Halo $ nama! Selamat datang di Velocity!

Yang kedua adalah program Java terkait yang disebut HelloWorld.java:

impor java.io.StringWriter; impor org.apache.velocity.app.VelocityEngine; impor org.apache.velocity.Template; impor org.apache.velocity.VelocityContext; public class HelloWorld {public static void main (String [] args) melempar Exception {/ * pertama, dapatkan dan inisialisasi mesin * / VelocityEngine ve = new VelocityEngine (); ve.init (); / * selanjutnya, dapatkan Template * / Template t = ve.getTemplate ("helloworld.vm"); / * buat konteks dan tambahkan data * / VelocityContext context = new VelocityContext (); context.put ("name", "World"); / * sekarang membuat template menjadi StringWriter * / StringWriter writer = new StringWriter (); t.merge (konteks, penulis); / * tampilkan Dunia * / System.out.println (writer.toString ()); }}

Sekarang, ketika Anda mengkompilasi dan menjalankan program ini, Anda akan melihat hasilnya:

Halo Dunia! Selamat datang di Velocity!

Ini adalah contoh yang sepele, tetapi berisi bagian penting untuk memberi Anda gambaran tentang apa itu template Velocity.

Mengapa saya harus menggunakannya?

Dirancang sebagai alat template umum yang mudah digunakan, Velocity berguna di area aplikasi Java mana pun yang memerlukan pemformatan dan presentasi data. Anda harus menggunakan Velocity karena alasan berikut:

  • Ini beradaptasi dengan banyak area aplikasi
  • Ini menawarkan sintaks yang sederhana dan jelas untuk perancang template
  • Ini menawarkan model pemrograman sederhana untuk pengembang
  • Karena template dan kode terpisah, Anda dapat mengembangkan dan memeliharanya secara independen
  • Mesin Velocity dengan mudah diintegrasikan ke dalam lingkungan aplikasi Java apa pun, terutama servlet
  • Velocity memungkinkan templat mengakses metode publik apa pun dari objek data dalam konteks

Poin terakhir adalah penting - itu berarti Anda dapat menggunakan kembali kelas yang ada. Jadi, objek yang ingin Anda gunakan dalam template Anda tidak perlu terstruktur dengan cara tertentu, seperti JavaBeans, atau mengimplementasikan I / O khusus atau mode siklus hidup, seperti taglib JSP (JavaServer Pages). Satu-satunya persyaratan adalah bahwa metodenya bersifat publik. Anda akan melihat lebih banyak dari ini saat kami membahas bahasa template secara detail.

Salah satu kekuatan Velocity adalah bahwa Velocity sangat memaksakan pemisahan tanggung jawab fungsional dalam aplikasi. Ini dilakukan dengan membatasi akses template ke objek yang secara khusus disediakan oleh kode aplikasi. Ini berarti bahwa desainer dapat fokus secara eksklusif pada penyajian data (tampilan), dan pemrogram aplikasi dapat fokus pada kontrol aplikasi (pengontrol) dan logika bisnis serta manajemen data (model) di Model-View-Controller (MVC) pengembangan. MVC adalah pola pengembangan yang diterima dengan baik yang menyederhanakan pengembangan dan pemeliharaan berkelanjutan dari aplikasi canggih.

Dimana saya menggunakannya?

Velocity berhasil digunakan di:

  • Aplikasi Web berbasis server
  • Pembuatan kode Java dan SQL
  • Pemrosesan dan transformasi XML
  • Pemrosesan teks, seperti pembuatan file RTF

Velocity paling sering digunakan sebagai mesin rendering untuk pengembangan aplikasi Web berbasis servlet Java, sebagai pengganti atau dalam hubungannya dengan JSP dan teknologi rendering lainnya. Selain sintaks templat yang mudah dan dapat dipelihara, Velocity digunakan dalam pengembangan Web karena bahasa templatnya dapat memanipulasi dan menyajikan data, bukan membuat data. Ini mencegah pemrograman di dalam template. Ini adalah hal yang bagus; itu menjaga logika bisnis dan aplikasi kode Java Anda di tempatnya.

Velocity sangat cocok untuk pengembangan Web J2EE (Java 2 Platform, Enterprise Edition) karena platform mengakomodasi teknologi keluaran selain JSP. Meskipun JSP termasuk dalam spesifikasi J2EE, J2EE tidak memerlukan penggunaannya.

Bagaimana cara kerjanya?

You use the same general process to create a Velocity-based application as you would any application. Let's consider a more interesting example than the Hello World application above. Suppose you operate a pet store and wish to generate an email blast to announce a sale. First, you must design the email and then develop the template and code based on that design.

Design-time considerations

You need to consider three elements for your design:

  • Which data to include in the email
  • What form the data elements should take (for example, as List, Map, or String)
  • What to call those data elements

For this example, let's suppose you decide on three pets for sale, each with a different advertised price. You decide to use a map to associate each pet name and its price, and then store all three maps in a list. You call this list petList, the pet name name, and the price as price in the map. Now that you have identified the relevant data, its representation, and naming criteria, you can write the code and the template's design.

Write the code and template design

Once you agree on data specifics, Velocity lets you write the code and design the template in parallel. The designer integrates the data into the nondata presentation content (like images, text, and so on) in the template. In this case, we simply write in the email body:

 $petList.size() Pets on Sale! We are proud to offer these fine pets at these amazing prices. This month only, choose from: #foreach( $pet in $petList ) $pet.name for only $pet.price #end Call Today! 

As the programmer, you must:

  • Retrieve all data from the data sources -- a database via JDBC (Java Database Connectivity), a file, or just something calculated
  • Put that data into the context using the agreed-upon names
  • Render the template with the context to produce output

You may recall from the Hello World example that I referred to class VelocityContext as the context. Modeled after a java.util.Map, the context is an object that holds data provided by the application or servlet that the template accesses.

For this example, we get all the data from our data sources (in this case, we hardwire it into the code), organize it, and add it to the context:

 /* create our list of maps */ ArrayList list = new ArrayList(); Map map = new HashMap(); map.put("name", "horse"); map.put("price", "00.00"); list.add( map ); map = new HashMap(); map.put("name", "dog"); map.put("price", "9.99"); list.add( map ); map = new HashMap(); map.put("name", "bear"); map.put("price", ".99"); list.add( map ); /* add that list to a VelocityContext */ VelocityContext context = new VelocityContext(); context.put("petList", list); 

It appears we really want to get rid of those bears!

Now, with the data organized and placed in the context and the template ready, we can render the template against the context. Here is the code:

import java.io.StringWriter; import java.util.List; import java.util.ArrayList; import java.util.Map; import java.util.HashMap; import org.apache.velocity.Template; import org.apache.velocity.VelocityContext; import org.apache.velocity.app.VelocityEngine; public class PetStoreEmail { public static void main( String[] args ) throws Exception { /* first, get and initialize an engine */ VelocityEngine ve = new VelocityEngine(); ve.init(); /* organize our data */ ArrayList list = new ArrayList(); Map map = new HashMap(); map.put("name", "horse"); map.put("price", "00.00"); list.add( map ); map = new HashMap(); map.put("name", "dog"); map.put("price", "9.99"); list.add( map ); map = new HashMap(); map.put("name", "bear"); map.put("price", ".99"); list.add( map ); /* add that list to a VelocityContext */ VelocityContext context = new VelocityContext(); context.put("petList", list); /* get the Template */ Template t = ve.getTemplate( "petstoreemail.vm" ); /* now render the template into a Writer */ StringWriter writer = new StringWriter(); t.merge( context, writer ); /* use the output in your email body */ sendEmail( writer.toString() ); } } 

This complete program generates your email body. Because Velocity renders templates into a Writer, you can easily manage the output. In this case, the rendered output went into a String via the StringWriter, but it could easily have gone to a file, a browser, or a BLOB (binary large object) in a database. This is one reason why Velocity integrates so easily into Java applications.

The program output (your email body) looks like this:

 3 Pets on Sale! We are proud to offer these fine pets at these amazing prices. This month only, choose from: horse for only 00.00 dog for only 9.99 bear for only .99 Call Today! 

Velocity Template Language

I've shown Velocity templates for two different examples, but in neither case have I explained what the special markup did (although you could probably guess).

The Velocity Template Language (VTL) is a simple syntax providing two parts: references, a formalism for accessing objects in the context; and directives, a set of statements used for control and action. Described as "a language definition with a feature set that fits comfortably on a standard business card" (see Jim Jagielski's "Getting Up to Speed with Velocity") VTL has been intentionally kept simple and small by the community.

References

References in the template access data. They freely mix with the template's non-VTL content. Formally defined, a reference is anything in a template that starts with the '$' character and refers to something in the context. If no corresponding data object exists in the context, the template simply treats the reference as text and renders it as-is into the output stream.

Here is a short template containing a simple reference mixed with non-VTL content:

 Hello $name! Welcome to Velocity! 

Here, the reference is $name. As in the Hello World example, Velocity replaces $name in the template with the toString() return value of what is placed in the context under the key name:

 Hello World! Welcome to Velocity! 

The Velocity reference allows access to any object's public method, and the template's syntax is the same as it would be in Java code. Here are a few examples:

 There are $myBean.getSize() elements. $myObject.anotherMethod( 1, "more data ") $foo.getBar().barMethod("hello", $moredata ) $foo.myMethod( $bar.callThis() ) 

You may recall from the Pet Store email example that we stored the name and price information in a java.util.Map, and accessed the data using two tokens name and price, which don't exist as methods in the java.util.Map class:

 $pet.name for only $pet.price 

This works because Velocity incorporates a JavaBean-like introspection mechanism that lets you express method accesses in references using a property notation. In the Pet Store example template, Velocity's introspection facility finds and invokes the Map's public Object get(String) method with the keys name and price. We could access the same data in a different way by invoking the get(String) method directly in the template:

 $pet.get('name') for only $pet.get('price') 

Ini akan menghasilkan keluaran yang sama, dan lebih baik mewakili apa yang sebenarnya terjadi. Namun, cara lain yang menggunakan notasi properti lebih mudah dibaca dan tidak mengikat template Anda ke implementasi spesifik kelas data. Misalnya, Anda dapat mengganti Mapin the Listdengan kelas yang memiliki metode publik getName()dan getPrice(), dan template contoh asli yang berisi berikut ini akan terus berfungsi:

 $ pet.name hanya dengan $ pet.price