Template Engines for Java WebApps (Velocity Vs FreeMarker Vs Thymeleaf Vs Rythm)

In many projects, developed using Java technologies Java Server Pages (JSPs) was the standard for the presentation layer for a long time. Among many other things JSPs has the features of a template processor. The biggest shortcoming of this technology is the possibility to insert business logic in the presentation code. Thus, we can insert into the JSP document scriptlets or even Java code blocks. Although this can help us in certain situations, the code becomes rapidly complex and hard to maintain. Because of shortcomings such as this one, JSP lost many followers in favor of other template engines, which are used in more and more projects, increasing the developers" productivity and the quality of the products.

In this article I will try to analyse four popular template engines available freely for commercial use. The four template engines are Apache Velocity, FreeMarker, Thymeleaf and Rythm.

Introduction

Velocity is a project distributed under the Apache Software License, which benefits from great popularity among the Java applications developers. Like other template engines, Velocity was designed to enable the webmasters and the Java developers to work in parallel.

FreeMarker is a product that has reached maturity, distributed under a BSD license. Similar to the Apache Velocity project, FreeMarker offers complex functionalities designed for assisting web developers. It was designed for efficiently generating HTML pages, and not only that. Furthermore as the creators of the project state, this is a generic software product that can be used for text generation, ranging from HTML to source code.

Thymeleaf is a Java library distributed under the ٢nd version of Apache License with the main goal to create templates in an elegant way. The most suitable use case for Thymeleaf is generation of XHTML / HTML٥ documents within a web context. However this tool can be used in offline environments as well, being able to process XML documents.

Rythm is a template engine for Java applications distributed under the Apache License version 2.0 and described by its author as being a general purpose product, easy to be used and super-fast. Similarly to other template processors, we can process with it HTML documents, XML documents, SQL scripts, source code, emails and any other kind of formatted text. Rythm was inspired by the .Net Razor project, due to its simple and elegant syntax.

Template Language

Apache Velocity enjoys its own scripting language called Velocity Template Language (VTL) which is powerful and flexible. The authors of Apache Velocity proudly advertise that their product"s flexibility is limited only by the user"s creativity. VTL was created to offer the simplest and cleanest way for inserting dynamic content into a web page.

FreeMarker provides us with a strong templating language, called FreeMarker Template Language. With FTL we can define expressions, functions and macros within the templates that we write. Furthermore, we also have the possibility to use a rich library with predefined directives that give us the possibility to iterate data collections, include other templates, and much more.

Thymeleaf relies on a set of features called a dialect. The standard distribution comes with the Standard dialect and the SpringStandard dialect which allow us to create so-called natural templates. These can be correctly displayed by the browser even when we access them as static files. Consequently these documents can be viewed as prototypes.

Rythm was inspired by the .Net Razor project, due to its simple and elegant syntax. Rythm uses the special character @ to introduce all syntax elements.

Performances

Using Apache HTTP server benchmarking tool on machine with following specs:

Mac OS X Version 10.11.1
2,3 GHz Intel Core i7 Quad core
ava(TM) SE Runtime Environment (build 1.8.0_51-b16)
Java HotSpot(TM) 64-Bit Server VM (build 25.51-b03, mixed mode)
Apache Tomcat 7.0.53 with 512M RAM

Total time taken for processing 25.000 requests with a concurrency level of 25. (lower is better)
We optain following results:

Thymeleaf               4.147 seconds
Freemarker              2.637 seconds
Velocity                2.491 seconds
Rythm                   1.991 seconds

Conclusions

Both Velocity and FreeMarker are established products, which proved their worth in many successful projects offering decent performance. On the other hand Thymeleaf and Rythm are young projects that come with a new philosophy adapted to the current trends in web development. For instance, Thymeleaf excels at natural templating, while Rythm offers a clean syntax, easy to understand both for programmers and webmasters. We can conclude that choosing a template engine depends first of all on the project we need it for.

Read More

EHCache : Implementation of Java in-memory object cache

The in-memory caching system is designed to increase application performance by holding frequently-requested data in memory, reducing the need for database queries to get that data. For One of application requirement, I need a Java in-memory object caching that can replace HashMap based caching system. I need to extend the cache to include basic features like max size and time to live but don't bother about caching server or persistence.

I have investigated following options:

• Guava CacheBuilder - active development. See this presentation.
• LRUMap - Config via API. No TTL. Not purpose built for caching.
• whirlycache - XML config. Mailing list. Last updated 2006.
• cache4j - XML config. Documentation in Russian. Last updated 2006.

I found that  EHCache is very nice where I can create an in memory cache. I have checked out their code samples for an example of creating an in memory cache. I can specify a max size, and a time to live, it is really awesome. EHCache does offer some advanced features, but if your not interested in using them - don't. But it's nice to know they are there if your requirements ever change.

Ehcache is an open source, standards-based cache that boosts performance, offloads your database, and simplifies scalability. It's the most widely-used Java-based cache because it's robust, proven, full-featured, and integrates with other popular libraries and frameworks.

 So let discuss the implementation part of EHCache in your application. First, we need to download the ehcache-core-2.6.2.jar, slf4j-api-1.6.1.jar and slf4j-jdk14-1.6.1.jar in ehcache-core-2.6.2-distribution.tar.gz from http://ehcache.org/downloads. Then, add this jar in the librairies folder of your project \war\WEB-INF\ or in your pom.xml (MAVEN).

Configuration ehcache.xml
Create (this file could be copied from downloaded package) an ehcache.xml file in the classpath of your project. This file contains a default Cache configuration with an implicit name “default” which is a reserved cache name. This cache will be applied to caches created programmatically (using CacheManager.add(String cacheName)).

So, we will add a sample cache named “myCache1” wich will contain a maximum in memory of 10000 elements, and will expire an element if it is idle for more than 5 minutes (300 sec) and lives for more than 10 minutes (600 sec). If there are more than 10000 elements it will overflow to the disk cache, which in this configuration will go to wherever java.io.tmp is defined on your system. On a standard Linux system this will be ‘/tmp’, for Windows7 it could be ‘C:\Users\username\AppData\Local\Temp’.

Find the sample configuarion code:

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="ehcache.xsd"
         updateCheck="true" monitoring="autodetect"
         dynamicConfig="true">


    <diskStore path="java.io.tmpdir"/>

    <defaultCache
            maxEntriesLocalHeap="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskSpoolBufferSizeMB="30"
            maxEntriesLocalDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
            statistics="false">
        <persistence strategy="localTempSwap"/>
    </defaultCache>

    <cache name="myCache1"
           maxEntriesLocalHeap="10000"
           maxEntriesLocalDisk="1000"
           eternal="false"
           diskSpoolBufferSizeMB="20"
           timeToIdleSeconds="300"
           timeToLiveSeconds="600"
           memoryStoreEvictionPolicy="LFU"
           transactionalMode="off">
        <persistence strategy="localTempSwap"/>
    </cache>
    
</ehcache>

 How to Implement in Application?

•  First, we will create an utilitary class named CacheUtil in order to manipulate and sollicit the Ehcache

• Get the cache instance of Ehcache via the method getCache. This method could be synchronized.

public static CacheManager cacheMgr = null;

private static Ehcache getCache(String cacheName){
 if(cacheMgr == null){
  // We could use an environment or a VM variable
  cacheMgr = CacheManager.create("...\\config\\ehcache.xml");
 }
  
 Ehcache cache = null;
 if(cacheMgr!=null){
  //cache = cacheMgr.addCacheIfAbsent(name);
  cache = cacheMgr.getEhcache(cacheName);
 }
 
 return cache;
}

•  Get data from the cache via the method getListFromCache.

@SuppressWarnings("unchecked")
public static <T> List<T> getListFromCache(String threadName, String cacheName, String key, CacheCreation<T> cacheCreation){
 List<T> all = new ArrayList<T>();
  
 Ehcache cache = getCache(cacheName);
 Element element = null;
 if(cache!=null){
  element = cache.get(key);
 }
  
 if(element==null){
  System.out.println(threadName+" : CacheUtil.getListFromCache() : the element '"+key+"' has not been found in the cache ---> get the original data.");

  all = cacheCreation.getAll();
  cache.put(new Element(key, all));
  System.out.println(threadName+" : CacheUtil.getListFromCache() : the original data for the element '"+key+"' has been added in the cache.");


 }else{
  System.out.println(threadName+" : CacheUtil.getListFromCache() : the element '"+key+"' has been found in the cache.");

  //all = (List<T>) element.getValue();
  all = (List<T>) element.getObjectValue();
 }
 return all;

} 

•  We have also created an abstract class CacheCreation to in anticipation of the use of cache: 

public abstract class CacheCreation<T> { 
 public abstract List<T> getAll(); 
}

• Then, we will create an class UseCaseClass to use and check the Ehcache containing main method to create several threads soliciting the Ehcache: 

public static void main(String[] args) {
 int nbThreads = 3;
 ExecutorService execService = Executors.newFixedThreadPool(nbThreads);
  
 // Create several threads which solicit the Ehcache
 for (int i = 0; i < nbThreads; i++) {
  final int indexFinal = i;

  execService.submit(new Runnable(){
   String threadName= null;
   UseCaseClass useCaseClass = null;
    
   public void run(){
    try {
     useCaseClass = new UseCaseClass();
     threadName = "thread_"+indexFinal;
     useCaseClass.getAllData1(threadName);
     {
      int sleepTime = getRandomSleepTime(1000, 5000);
      System.out.println(threadName+" will sleep during "+sleepTime+"ms.");
      Thread.currentThread().sleep(sleepTime);
      System.out.println(threadName+" wakes up");
     }
     useCaseClass.getAllData2(threadName);
     {
      int sleepTime = getRandomSleepTime(1000, 5000);
      System.out.println(threadName+" will sleep during "+sleepTime+"ms.");
      Thread.currentThread().sleep(sleepTime);
      System.out.println(threadName+" wakes up");
     }
     useCaseClass.getAllData1(threadName);
     useCaseClass.getAllData2(threadName);
     useCaseClass.getAllData1(threadName);
     useCaseClass.getAllData2(threadName);
    } catch (Throwable e) {
     e.printStackTrace();
    }
     
   }//end-run
    
   private int getRandomSleepTime(int min, int max){
    return min + (int)(Math.random() * ((max - min) + 1));
   }

  }//end-runnable

  );//end-submit

 }//end-for
}

• The Ehcache will be sollicited by 2 methods getAllData1 and getAllData2:

          

 public static void main(String[] args) {
 int nbThreads = 3;
 ExecutorService execService = Executors.newFixedThreadPool(nbThreads);
  
 // Create several threads which solicit the Ehcache
 for (int i = 0; i < nbThreads; i++) {
  final int indexFinal = i;

  execService.submit(new Runnable(){
   String threadName= null;
   UseCaseClass useCaseClass = null;
    
   public void run(){
    try {
     useCaseClass = new UseCaseClass();
     threadName = "thread_"+indexFinal;
     useCaseClass.getAllData1(threadName);
     {
      int sleepTime = getRandomSleepTime(1000, 5000);
      System.out.println(threadName+" will sleep during "+sleepTime+"ms.");
      Thread.currentThread().sleep(sleepTime);
      System.out.println(threadName+" wakes up");
     }
     useCaseClass.getAllData2(threadName);
     {
      int sleepTime = getRandomSleepTime(1000, 5000);
      System.out.println(threadName+" will sleep during "+sleepTime+"ms.");
      Thread.currentThread().sleep(sleepTime);
      System.out.println(threadName+" wakes up");
     }
     useCaseClass.getAllData1(threadName);
     useCaseClass.getAllData2(threadName);
     useCaseClass.getAllData1(threadName);
     useCaseClass.getAllData2(threadName);
    } catch (Throwable e) {
     e.printStackTrace();
    }
     
   }//end-run
    
   private int getRandomSleepTime(int min, int max){
    return min + (int)(Math.random() * ((max - min) + 1));
   }

  }//end-runnable

  );//end-submit

 }//end-for
}

Read More

JqueryUI Autocomplete

Autocomplete is a technique used in modern websites to suggest a list beginning with few character that user typed in text box. The user can select an item from the list to complete the word or sentence.

jQueryUI provides the autocomplete() method to create a list of suggestions below the input field and adds new CSS classes to the elements concerned to give them the appropriate style.

Syntax

The autocomplete() method can be used in two forms:

• $(selector, context).autocomplete (options) Method
• $(selector, context).autocomplete ("action", params) Method

$(selector, context).autocomplete (options) Method

The autocomplete (options) method declares that an HTML <input> element must be managed as an input field that will be displayed above a list of suggestions. The options parameter is an object that specifies the behavior of the list of suggestions when the user is typing in the input field.

Syntax

$(selector, context).autocomplete (options);

You can provide one or more options at a time using Javascript object. If there are more than one options to be provided then you will separate them using a comma as follows:

$(selector, context).autocomplete({option1: value1, option2: value2..... }); 

$(selector, context).autocomplete ("action", params) Method

The autocomplete ("action", params) method can perform an action on the list of suggestions, such as show or hide. The action is specified as a String in the first argument (e.g., "close" to hide the list).

Syntax

$(selector, context).autocomplete ("action", params);

Example

   <script>
         $(function() {
            var dataSource = [
               "Java",
               "Boostrap",
               "C",
               "Bitspi",
            ];
            $( "#automplete" ).autocomplete({
               source: dataSource 
            });
         });
      </script>

     <div class="ui-widget">
         <input id="automplete">
     </div>

Read More