Merge pull request #1149 from zhangweidavid/master

Avoid unnecessary object creation when parsing XML tags.

Author: harawata

src/main/java/org/apache/ibatis/reflection/factory/DefaultObjectFactory.java

@@ -55,7 +55,7 @@ public void setProperties(Properties properties) {
     // no props for default
   }
 
-  <T> T instantiateClass(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
+  private  <T> T instantiateClass(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
     try {
       Constructor<T> constructor;
       if (constructorArgTypes == null || constructorArgs == null) {

src/main/java/org/apache/ibatis/scripting/xmltags/XMLScriptBuilder.java

@@ -37,6 +37,7 @@ public class XMLScriptBuilder extends BaseBuilder {
   private final XNode context;
   private boolean isDynamic;
   private final Class<?> parameterType;
+  private final Map<String, NodeHandler> nodeHandlerMap = new HashMap<String, NodeHandler>();
 
   public XMLScriptBuilder(Configuration configuration, XNode context) {
     this(configuration, context, null);
@@ -46,6 +47,20 @@ public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> par
     super(configuration);
     this.context = context;
     this.parameterType = parameterType;
+    initNodeHandlerMap();
+  }
+
+
+  private void initNodeHandlerMap(){
+      nodeHandlerMap.put("trim", new TrimHandler());
+      nodeHandlerMap.put("where", new WhereHandler());
+      nodeHandlerMap.put("set", new SetHandler());
+      nodeHandlerMap.put("foreach", new ForEachHandler());
+      nodeHandlerMap.put("if", new IfHandler());
+      nodeHandlerMap.put("choose", new ChooseHandler());
+      nodeHandlerMap.put("when", new IfHandler());
+      nodeHandlerMap.put("otherwise", new OtherwiseHandler());
+      nodeHandlerMap.put("bind", new BindHandler());
   }
 
   public SqlSource parseScriptNode() {
@@ -88,17 +103,7 @@ List<SqlNode> parseDynamicTags(XNode node) {
   }
 
   NodeHandler nodeHandlers(String nodeName) {
-    Map<String, NodeHandler> map = new HashMap<String, NodeHandler>();
-    map.put("trim", new TrimHandler());
-    map.put("where", new WhereHandler());
-    map.put("set", new SetHandler());
-    map.put("foreach", new ForEachHandler());
-    map.put("if", new IfHandler());
-    map.put("choose", new ChooseHandler());
-    map.put("when", new IfHandler());
-    map.put("otherwise", new OtherwiseHandler());
-    map.put("bind", new BindHandler());
-    return map.get(nodeName);
+    return nodeHandlerMap.get(nodeName);
   }
 
   private interface NodeHandler {

src/test/java/org/apache/ibatis/reflection/factory/DefaultObjectFactoryTest.java

@@ -15,8 +15,17 @@
  */
 package org.apache.ibatis.reflection.factory;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
 
 import org.apache.ibatis.reflection.ReflectionException;
 import org.junit.Assert;
@@ -30,20 +39,20 @@
 public class DefaultObjectFactoryTest {
 
   @Test
-  public void instantiateClass() throws Exception {
+  public void createClass() throws Exception {
     DefaultObjectFactory defaultObjectFactory = new DefaultObjectFactory();
-    TestClass testClass = defaultObjectFactory.instantiateClass(TestClass.class,
+    TestClass testClass = defaultObjectFactory.create(TestClass.class,
         Arrays.<Class<?>>asList(String.class, Integer.class), Arrays.<Object>asList("foo", 0));
 
     Assert.assertEquals("myInteger didn't match expected", (Integer) 0, testClass.myInteger);
     Assert.assertEquals("myString didn't match expected", "foo", testClass.myString);
   }
 
   @Test
-  public void instantiateClassThrowsProperErrorMsg() {
+  public void createClassThrowsProperErrorMsg() {
     DefaultObjectFactory defaultObjectFactory = new DefaultObjectFactory();
     try {
-      defaultObjectFactory.instantiateClass(TestClass.class, Collections.<Class<?>>singletonList(String.class), Collections.<Object>singletonList("foo"));
+      defaultObjectFactory.create(TestClass.class, Collections.<Class<?>>singletonList(String.class), Collections.<Object>singletonList("foo"));
       Assert.fail("Should have thrown ReflectionException");
     } catch (Exception e) {
       Assert.assertTrue("Should be ReflectionException", e instanceof ReflectionException);
@@ -52,4 +61,39 @@ public void instantiateClassThrowsProperErrorMsg() {
     }
   }
 
+  @Test
+  public void creatHashMap() throws  Exception{
+     DefaultObjectFactory defaultObjectFactory=new DefaultObjectFactory();
+     Map  map= defaultObjectFactory.create(Map.class,null,null);
+     Assert.assertTrue("Should be HashMap",map instanceof HashMap);
+  }
+
+  @Test
+  public void createArrayList() throws Exception {
+    DefaultObjectFactory defaultObjectFactory = new DefaultObjectFactory();
+    List list = defaultObjectFactory.create(List.class);
+    Assert.assertTrue(" list should be ArrayList", list instanceof ArrayList);
+
+    Collection collection = defaultObjectFactory.create(Collection.class);
+    Assert.assertTrue(" collection should be ArrayList", collection instanceof ArrayList);
+
+    Iterable iterable = defaultObjectFactory.create(Iterable.class);
+    Assert.assertTrue(" iterable should be ArrayList", iterable instanceof ArrayList);
+  }
+
+
+  @Test
+  public void createTreeSet() throws Exception {
+    DefaultObjectFactory defaultObjectFactory = new DefaultObjectFactory();
+    SortedSet sortedSet = defaultObjectFactory.create(SortedSet.class);
+    Assert.assertTrue(" sortedSet should be TreeSet", sortedSet instanceof TreeSet);
+  }
+
+
+  @Test
+  public void createHashSet() throws Exception {
+    DefaultObjectFactory defaultObjectFactory = new DefaultObjectFactory();
+    Set set = defaultObjectFactory.create(Set.class);
+    Assert.assertTrue(" set should be HashSet", set instanceof HashSet);
+  }
 }