#216 Improve templator performance

Author: Igor Polevoy

activeweb/src/main/java/org/javalite/activeweb/templator/TemplatorManager.java

@@ -26,7 +26,7 @@ public class TemplatorManager implements TemplateManager {
     public void merge(Map input, String template, String layout, String format, Writer writer) {
 
         String templateName = blank(format) ? template + ".html" : template + "." + format + ".html";
-        Template pageTemplate = new Template(TemplatorConfig.instance().getTemplateSource(templateName));
+        Template pageTemplate = TemplatorConfig.instance().getTemplate(templateName);
 
         if (layout == null) {//no layout
             pageTemplate.process(input, writer);
@@ -37,7 +37,7 @@ public void merge(Map input, String template, String layout, String format, Writ
             Map values = new HashMap(input);
             values.put("page_content", pageWriter.toString());
 
-            Template layoutTemplate = new Template(TemplatorConfig.instance().getTemplateSource(layout + ".html"));
+            Template layoutTemplate = TemplatorConfig.instance().getTemplate(layout + ".html");
             layoutTemplate.process(values, writer);
             logger.info("Rendered template: '" + template + "' with layout: '" + layout + "'");
         }

javalite-templator/pom.xml

@@ -35,10 +35,6 @@
             <artifactId>slf4j-simple</artifactId>
         </dependency>
 
-        <dependency>
-            <groupId>net.sf.ehcache</groupId>
-            <artifactId>ehcache-core</artifactId>
-        </dependency>
 
     </dependencies>
 </project>

javalite-templator/src/main/java/org/javalite/templator/AbstractTag.java

@@ -8,6 +8,7 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -117,30 +118,30 @@ public boolean matchEndTag(String template, int index) {
         List<String> ends = getEnds();
         for (String end : ends) {
             boolean haveEnoughSpaceForEndTag = end.length() < index;
-            boolean  endTagMatchesLeftOfIndex = template.substring(index - end.length(), index).equals(end);
+            boolean endTagMatchesLeftOfIndex = template.substring(index - end.length(), index).equals(end);
             boolean indexOnEnd = index == template.length() - 1;
             boolean endTagMatchesEndOfTemplate = template.substring(index - end.length() + 1).equals(end);
 
-            if (haveEnoughSpaceForEndTag && endTagMatchesLeftOfIndex){
+            if (haveEnoughSpaceForEndTag && endTagMatchesLeftOfIndex) {
                 matchingEnd = end;
                 tagEndIndex = index - end.length();
                 return true;
             }
 
-            if(indexOnEnd && endTagMatchesEndOfTemplate){
-               matchingEnd = end;
+            if (indexOnEnd && endTagMatchesEndOfTemplate) {
+                matchingEnd = end;
                 tagEndIndex = index - end.length() + 1;
             }
 
-            if(matchingEnd != null){
+            if (matchingEnd != null) {
                 return true;
             }
         }
         return false;
     }
 
     public boolean matchStartAtIndex(String template, int index) {
-      return index >= getTagStart().length()
+        return index >= getTagStart().length()
                 && template.substring(index - getTagStart().length(), index).equals(getTagStart());
     }
 
@@ -166,26 +167,35 @@ public String toString() {
                 '}';
     }
 
-    public boolean marchArgumentEnd(String template, int index){
+    public boolean marchArgumentEnd(String template, int index) {
         String argumentEnd = getArgumentEnd();
-        if( argumentEnd == null){
+        if (argumentEnd == null) {
             return false;
-        }else if((index + 1) >= argumentEnd.length()
-                && template.substring(index - argumentEnd.length(), index).equals(argumentEnd) ){
+        } else if ((index + 1) >= argumentEnd.length()
+                && template.substring(index - argumentEnd.length(), index).equals(argumentEnd)) {
             argumentsEndIndex = index - argumentEnd.length();
             return true;
         }
         return false;
     }
 
+
+    private ThreadLocal<Map<String, Method>> methodCache = new ThreadLocal<Map<String, Method>>();
+
     /**
      * Tries to get a property value from object.
      *
-     * @param obj object to get property value from
+     * @param obj          object to get property value from
      * @param propertyName name of property
      * @return value of property, or null if not found
      */
-    protected final Object getValue(Object obj, String propertyName) throws InvocationTargetException, IllegalAccessException {
+    protected final Object getValue(Object obj, String propertyName) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
+
+
+        //quick hack:
+        if (methodCache.get() == null) {
+            methodCache.set(new HashMap<String, Method>());
+        }
 
         Object val = null;
 
@@ -195,27 +205,22 @@ protected final Object getValue(Object obj, String propertyName) throws Invocati
             val = objectMap.get(propertyName);
         }
 
-        //try generic get method
         if (val == null) {
-            try {
-                Method m = obj.getClass().getMethod("get", String.class);
-                val = m.invoke(obj, propertyName);
-            } catch (NoSuchMethodException ignore) {
-            }
+            //try properties
+            val = executeMethod(obj, "get" + capitalize(propertyName), null);
         }
 
+
+        //try generic get method
         if (val == null) {
-            //try properties
-            try {
-                Method m = obj.getClass().getMethod("get" + capitalize(propertyName));
-                val = m.invoke(obj);
-            } catch (NoSuchMethodException ignore) {
-            }
+            val = executeMethod(obj, "get", propertyName);
         }
 
+
         if (val == null) {
             // try public fields
             try {
+                //TODO: optimize the same as methods.
                 Field f = obj.getClass().getDeclaredField(propertyName);
                 val = f.get(obj);
 
@@ -227,7 +232,32 @@ protected final Object getValue(Object obj, String propertyName) throws Invocati
         return val;
     }
 
-    public boolean matchMiddle(String template, int templateIndex){
+    private Object executeMethod(Object obj, String methodName, String propertyName) throws InvocationTargetException, IllegalAccessException {
+
+        String key = obj.getClass().getName() + "#" + methodName;
+        Method m = null;
+
+        if (!methodCache.get().containsKey(key)) {
+            try {
+                m = propertyName == null ? obj.getClass().getMethod(methodName) : obj.getClass().getMethod(methodName, String.class);
+            } catch (NoSuchMethodException e) {}
+
+            // if we find a method, we will cache it, if not we will cache null
+            methodCache.get().put(key, m);
+        } else if (methodCache.get().get(key) == null) { // we did not find this method last time!
+            return null;
+        } else {
+            m = methodCache.get().get(key); // method found!
+        }
+
+        if(m != null){
+            return propertyName == null ? m.invoke(obj) : m.invoke(obj, propertyName);
+        }else{
+            return null;
+        }
+    }
+
+    public boolean matchMiddle(String template, int templateIndex) {
         return false;
     }
 }

javalite-templator/src/main/java/org/javalite/templator/TemplatorConfig.java

@@ -1,8 +1,5 @@
 package org.javalite.templator;
 
-import net.sf.ehcache.Cache;
-import net.sf.ehcache.CacheManager;
-import net.sf.ehcache.Element;
 import org.javalite.common.Util;
 import org.javalite.templator.tags.IfTag;
 import org.javalite.templator.tags.ListTag;
@@ -30,8 +27,8 @@ private TemplatorConfig(){
         registerBuiltIn("esc", new Esc());
     }
 
-    private final static String CACHE_GROUP = "templates";
-    private final CacheManager cacheManager = CacheManager.create();
+
+    private Map<String, Template> cacheManager = new HashMap<String, Template>();
     private final Map<String, Class> tags = new HashMap<String, Class>();
     private final Map<String, BuiltIn> builtIns = new HashMap<String, BuiltIn>();
     private boolean cacheTemplates = !(blank(System.getenv("ACTIVE_ENV")) || "development".equals(System.getenv("ACTIVE_ENV")));
@@ -100,19 +97,19 @@ public AbstractTag getTag(String name)  {
         }
     }
 
-    public String getTemplateSource(String templateName) {
-        String templateSource;
+    public Template getTemplate(String templateName) {
+        Template template;
         if(cacheTemplates){
-            templateSource = getCache(templateName);
-            if(templateSource != null){
-                return templateSource;
+            template = getCache(templateName);
+            if(template != null){
+                return template;
             }else{
-                templateSource = loadTemplate(templateName);
-                addCache(templateName, templateSource);
-                return templateSource;
+                template =  new Template(loadTemplate(templateName));
+                addCache(templateName, template);
+                return template;
             }
         }else{
-            return loadTemplate(templateName);
+            return new Template(loadTemplate(templateName));
         }
     }
 
@@ -164,31 +161,15 @@ public void setServletContext(ServletContext ctx) {
         this.servletContext = ctx;
     }
 
-
-    public String getCache(String key) {
-        try {
-            createIfMissing();
-            Cache c = cacheManager.getCache(CACHE_GROUP);
-            return c.get(key) == null ? null : c.get(key).getObjectValue().toString();
-        } catch (Exception e) {return null;}
+    public Template getCache(String key) {
+        return cacheManager.get(key) == null ? null : cacheManager.get(key);
     }
 
-
-    public void addCache(String key, Object cache) {
-        createIfMissing();
-        cacheManager.getCache(CACHE_GROUP).put(new Element(key, cache));
+    public void addCache(String key, Template template) {
+        cacheManager.put(key, template);
     }
 
     public void flush() {
-        cacheManager.removalAll();
-    }
-
-    private void createIfMissing() {
-        //double-checked synchronization is broken in Java, but this should work just fine.
-        if (cacheManager.getCache(CACHE_GROUP) == null) {
-            try {
-                cacheManager.addCache(CACHE_GROUP);
-            } catch (net.sf.ehcache.ObjectExistsException ignore) {}
-        }
+        cacheManager = new HashMap<String, Template>();
     }
 }

javalite-templator/src/test/java/org/javalite/templator/CompareSpec.java

@@ -0,0 +1,94 @@
+package org.javalite.templator;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.javalite.common.Collections.map;
+
+/**
+ * This is not a real spec. This is a performance test to see which templating engine is faster,
+ * hand-written or generated from BNF. Looks like hand-written is 3 - 5 times faster.
+ *
+ * @author Igor Polevoy on 4/15/15.
+ */
+public class CompareSpec {
+
+    public static class Person {
+        private String firstName, lastName;
+
+        public Person(String firstName, String lastName) {
+            this.firstName = firstName;
+            this.lastName = lastName;
+        }
+
+        public String getFirstName() {
+            return firstName;
+        }
+
+        public String getLastName() {
+            return lastName;
+        }
+    }
+
+    private List<Person> people;
+    private long millis;
+
+
+    @Before
+    public void before() {
+        Runtime.getRuntime().gc();
+        people = new ArrayList<Person>();
+        for (int i = 0; i < 10000; i++) {
+            people.add(new Person("first-" + i, "last-" + i));
+        }
+    }
+
+
+    class NopeStringWriter extends StringWriter{
+        @Override
+        public void write(int c) {}
+        @Override
+        public void write(char[] cbuf, int off, int len) {}
+        @Override
+        public void write(String str) {}
+        @Override
+        public void write(String str, int off, int len) {}
+        @Override
+        public String toString() {return "";}
+        @Override
+        public StringWriter append(CharSequence csq) {return this;}
+        @Override
+        public StringWriter append(CharSequence csq, int start, int end) {return this;}
+        @Override
+        public StringWriter append(char c) {return this;}
+    }
+
+    @Test
+    public void shouldIterate1() {
+        String source = "<html><#list people as person > name: ${person.firstName} ${person.lastName} </#list></html>";
+        Template template = new Template(source);
+        StringWriter w = new NopeStringWriter();
+        millis = System.currentTimeMillis();
+        for (int i = 0; i < 100; i++) {
+            template.process(map("people", people), w);
+        }
+        System.out.println("Completed in " + (System.currentTimeMillis() - millis) + " milliseconds");
+    }
+
+
+    @Test
+    public void shouldIterate2() throws IOException {
+        TemplateTagNode node = (TemplateTagNode) new TemplateParser("<html><#for person:people> name: %{person.firstName} %{person.lastName}  </#for></html>").parse();
+        StringWriter sw = new NopeStringWriter();
+        millis = System.currentTimeMillis();
+        for (int i = 0; i < 100; i++) {
+            node.process(map("people", people), sw);
+        }
+        System.out.println("Completed in " + (System.currentTimeMillis() - millis) + " milliseconds");
+    }
+}