#217 Improve TemplateParser performance

Author: Igor Polevoy

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

@@ -190,11 +190,6 @@ public boolean marchArgumentEnd(String template, int index) {
     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;
 
         //try map
@@ -238,6 +233,12 @@ protected final Object getValue(Object obj, String propertyName) throws Invocati
 
     private Object executeMethod(Object obj, String methodName, String propertyName) throws InvocationTargetException, IllegalAccessException {
 
+        //quick hack:
+        if (methodCache.get() == null) {
+            methodCache.set(new HashMap<String, Method>());
+        }
+
+
         String key = obj.getClass().getName() + "#" + methodName;
         Method m = null;
 

javalite-templator/src/main/java/org/javalite/templator/template_parser/ChainedIds.java

@@ -2,6 +2,10 @@
 
 import org.javalite.templator.TemplateException;
 
+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;
 import static org.javalite.common.Inflector.*;
@@ -18,40 +22,98 @@ class ChainedIds {
         this.ids = ids;
     }
 
-    private Object valueOf(Object obj, String id) {
-        try {
-            if (id.endsWith("()")) {
-                return obj.getClass().getMethod(id.substring(0, id.length() - 2)).invoke(obj);
+    private Object valueOf(Object obj, String propertyName) throws InvocationTargetException, IllegalAccessException {
+
+            if (propertyName.endsWith("()")) {
+                return executeMethod(obj, propertyName.substring(0, propertyName.length() - 2), null);
+
             }
-        } catch (Exception e) {
-            throw new TemplateException(e);
-        }
+
+        Object val = null;
+
+        //try map
         if (obj instanceof Map) {
-            return ((Map) obj).get(id);
+            Map objectMap = (Map) obj;
+            return objectMap.get(propertyName);
+        }
+
+        if (val == null) {
+            //try properties
+            val = executeMethod(obj, "get" + capitalize(propertyName), null);
+            if(val != null)
+                return val;
         }
-        try {
-            // try generic get method
-            return obj.getClass().getMethod("get", String.class).invoke(obj, id);
-        } catch (Exception e) {
+
+
+        //try generic get method
+        if (val == null) {
+            val = executeMethod(obj, "get", propertyName);
+            if(val != null)
+                return val;
+        }
+
+
+        if (val == null) {
+            // try public fields
             try {
-                // try javabean property
-                return obj.getClass().getMethod("get" + capitalize(id)).invoke(obj);
-            } catch (Exception e1) {
-                // try public field
-                try {
-                    return obj.getClass().getDeclaredField(id).get(obj);
-                } catch (Exception e2) {
-                }
+                //TODO: optimize the same as methods.
+                Field f = obj.getClass().getDeclaredField(propertyName);
+                val = f.get(obj);
+                if(val != null)
+                    return val;
+
+            } catch (NoSuchFieldException ignore) {
+            } catch (IllegalAccessException ignore) {
             }
         }
-        return null;
+
+        return val;
+    }
+
+    private ThreadLocal<Map<String, Method>> methodCache = new ThreadLocal<Map<String, Method>>();
+
+    private Object executeMethod(Object obj, String methodName, String propertyName) throws InvocationTargetException, IllegalAccessException {
+
+        //quick hack:
+        if (methodCache.get() == null) {
+            methodCache.set(new HashMap<String, Method>());
+        }
+
+
+        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;
+        }
     }
 
+
     Object valueFrom(Map values) {
-        Object obj = values.get(firstId);
-        for (String id : ids) {
-            obj = valueOf(obj, id);
+        try{
+            Object obj = values.get(firstId);
+            for (String id : ids) {
+                obj = valueOf(obj, id);
+            }
+            return obj;
+        }catch(Exception e){
+            throw new TemplateException(e);
         }
-        return obj;
+
     }
 }