Merge pull request #506 from kazuki43zoo/polish-MapperBuilderAssistant

Polishing to use fluent style coding as possible in MapperBuilderAssistant

Author: emacarron

src/main/java/org/apache/ibatis/builder/MapperBuilderAssistant.java

@@ -128,11 +128,9 @@ public Cache useNewCache(Class<? extends Cache> typeClass,
       boolean readWrite,
       boolean blocking,
       Properties props) {
-    typeClass = valueOrDefault(typeClass, PerpetualCache.class);
-    evictionClass = valueOrDefault(evictionClass, LruCache.class);
     Cache cache = new CacheBuilder(currentNamespace)
-        .implementation(typeClass)
-        .addDecorator(evictionClass)
+        .implementation(valueOrDefault(typeClass, PerpetualCache.class))
+        .addDecorator(valueOrDefault(evictionClass, LruCache.class))
         .clearInterval(flushInterval)
         .size(size)
         .readWrite(readWrite)
@@ -146,8 +144,7 @@ public Cache useNewCache(Class<? extends Cache> typeClass,
 
   public ParameterMap addParameterMap(String id, Class<?> parameterClass, List<ParameterMapping> parameterMappings) {
     id = applyCurrentNamespace(id, false);
-    ParameterMap.Builder parameterMapBuilder = new ParameterMap.Builder(configuration, id, parameterClass, parameterMappings);
-    ParameterMap parameterMap = parameterMapBuilder.build();
+    ParameterMap parameterMap = new ParameterMap.Builder(configuration, id, parameterClass, parameterMappings).build();
     configuration.addParameterMap(parameterMap);
     return parameterMap;
   }
@@ -167,13 +164,13 @@ public ParameterMapping buildParameterMapping(
     Class<?> javaTypeClass = resolveParameterJavaType(parameterType, property, javaType, jdbcType);
     TypeHandler<?> typeHandlerInstance = resolveTypeHandler(javaTypeClass, typeHandler);
 
-    ParameterMapping.Builder builder = new ParameterMapping.Builder(configuration, property, javaTypeClass);
-    builder.jdbcType(jdbcType);
-    builder.resultMapId(resultMap);
-    builder.mode(parameterMode);
-    builder.numericScale(numericScale);
-    builder.typeHandler(typeHandlerInstance);
-    return builder.build();
+    return new ParameterMapping.Builder(configuration, property, javaTypeClass)
+        .jdbcType(jdbcType)
+        .resultMapId(resultMap)
+        .mode(parameterMode)
+        .numericScale(numericScale)
+        .typeHandler(typeHandlerInstance)
+        .build();
   }
 
   public ResultMap addResultMap(
@@ -186,7 +183,6 @@ public ResultMap addResultMap(
     id = applyCurrentNamespace(id, false);
     extend = applyCurrentNamespace(extend, true);
 
-    ResultMap.Builder resultMapBuilder = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping);
     if (extend != null) {
       if (!configuration.hasResultMap(extend)) {
         throw new IncompleteElementException("Could not find a parent resultmap with id '" + extend + "'");
@@ -212,8 +208,9 @@ public ResultMap addResultMap(
       }
       resultMappings.addAll(extendedResultMappings);
     }
-    resultMapBuilder.discriminator(discriminator);
-    ResultMap resultMap = resultMapBuilder.build();
+    ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping)
+        .discriminator(discriminator)
+        .build();
     configuration.addResultMap(resultMap);
     return resultMap;
   }
@@ -246,8 +243,7 @@ public Discriminator buildDiscriminator(
       resultMap = applyCurrentNamespace(resultMap, true);
       namespaceDiscriminatorMap.put(e.getKey(), resultMap);
     }
-    Discriminator.Builder discriminatorBuilder = new Discriminator.Builder(configuration, resultMapping, namespaceDiscriminatorMap);
-    return discriminatorBuilder.build();
+    return new Discriminator.Builder(configuration, resultMapping, namespaceDiscriminatorMap).build();
   }
 
   public MappedStatement addMappedStatement(
@@ -279,22 +275,28 @@ public MappedStatement addMappedStatement(
     id = applyCurrentNamespace(id, false);
     boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
 
-    MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType);
-    statementBuilder.resource(resource);
-    statementBuilder.fetchSize(fetchSize);
-    statementBuilder.timeout(timeout);
-    statementBuilder.statementType(statementType);
-    statementBuilder.keyGenerator(keyGenerator);
-    statementBuilder.keyProperty(keyProperty);
-    statementBuilder.keyColumn(keyColumn);
-    statementBuilder.databaseId(databaseId);
-    statementBuilder.lang(lang);
-    statementBuilder.resultOrdered(resultOrdered);
-    statementBuilder.resulSets(resultSets);
-
-    setStatementParameterMap(parameterMap, parameterType, statementBuilder);
-    setStatementResultMap(resultMap, resultType, resultSetType, statementBuilder);
-    setStatementCache(isSelect, flushCache, useCache, currentCache, statementBuilder);
+    MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
+        .resource(resource)
+        .fetchSize(fetchSize)
+        .timeout(timeout)
+        .statementType(statementType)
+        .keyGenerator(keyGenerator)
+        .keyProperty(keyProperty)
+        .keyColumn(keyColumn)
+        .databaseId(databaseId)
+        .lang(lang)
+        .resultOrdered(resultOrdered)
+        .resulSets(resultSets)
+        .resultMaps(getStatementResultMaps(resultMap, resultType, id))
+        .resultSetType(resultSetType)
+        .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
+        .useCache(valueOrDefault(useCache, isSelect))
+        .cache(currentCache);
+
+    ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
+    if (statementParameterMap != null) {
+      statementBuilder.parameterMap(statementParameterMap);
+    }
 
     MappedStatement statement = statementBuilder.build();
     configuration.addMappedStatement(statement);
@@ -305,47 +307,33 @@ private <T> T valueOrDefault(T value, T defaultValue) {
     return value == null ? defaultValue : value;
   }
 
-  private void setStatementCache(
-      boolean isSelect,
-      boolean flushCache,
-      boolean useCache,
-      Cache cache,
-      MappedStatement.Builder statementBuilder) {
-    flushCache = valueOrDefault(flushCache, !isSelect);
-    useCache = valueOrDefault(useCache, isSelect);
-    statementBuilder.flushCacheRequired(flushCache);
-    statementBuilder.useCache(useCache);
-    statementBuilder.cache(cache);
-  }
-
-  private void setStatementParameterMap(
-      String parameterMap,
+  private ParameterMap getStatementParameterMap(
+      String parameterMapName,
       Class<?> parameterTypeClass,
-      MappedStatement.Builder statementBuilder) {
-    parameterMap = applyCurrentNamespace(parameterMap, true);
-
-    if (parameterMap != null) {
+      String statementId) {
+    parameterMapName = applyCurrentNamespace(parameterMapName, true);
+    ParameterMap parameterMap = null;
+    if (parameterMapName != null) {
       try {
-        statementBuilder.parameterMap(configuration.getParameterMap(parameterMap));
+        parameterMap = configuration.getParameterMap(parameterMapName);
       } catch (IllegalArgumentException e) {
-        throw new IncompleteElementException("Could not find parameter map " + parameterMap, e);
+        throw new IncompleteElementException("Could not find parameter map " + parameterMapName, e);
       }
     } else if (parameterTypeClass != null) {
       List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
-      ParameterMap.Builder inlineParameterMapBuilder = new ParameterMap.Builder(
+      parameterMap = new ParameterMap.Builder(
           configuration,
-          statementBuilder.id() + "-Inline",
+          statementId + "-Inline",
           parameterTypeClass,
-          parameterMappings);
-      statementBuilder.parameterMap(inlineParameterMapBuilder.build());
+          parameterMappings).build();
     }
+    return parameterMap;
   }
 
-  private void setStatementResultMap(
+  private List<ResultMap> getStatementResultMaps(
       String resultMap,
       Class<?> resultType,
-      ResultSetType resultSetType,
-      MappedStatement.Builder statementBuilder) {
+      String statementId) {
     resultMap = applyCurrentNamespace(resultMap, true);
 
     List<ResultMap> resultMaps = new ArrayList<ResultMap>();
@@ -359,17 +347,15 @@ private void setStatementResultMap(
         }
       }
     } else if (resultType != null) {
-      ResultMap.Builder inlineResultMapBuilder = new ResultMap.Builder(
+      ResultMap inlineResultMap = new ResultMap.Builder(
           configuration,
-          statementBuilder.id() + "-Inline",
+          statementId + "-Inline",
           resultType,
           new ArrayList<ResultMapping>(),
-          null);
-      resultMaps.add(inlineResultMapBuilder.build());
+          null).build();
+      resultMaps.add(inlineResultMap);
     }
-    statementBuilder.resultMaps(resultMaps);
-
-    statementBuilder.resultSetType(resultSetType);
+    return resultMaps;
   }
 
   public ResultMapping buildResultMapping(
@@ -393,19 +379,19 @@ public ResultMapping buildResultMapping(
     if (composites.size() > 0) {
       column = null;
     }
-    ResultMapping.Builder builder = new ResultMapping.Builder(configuration, property, column, javaTypeClass);
-    builder.jdbcType(jdbcType);
-    builder.nestedQueryId(applyCurrentNamespace(nestedSelect, true));
-    builder.nestedResultMapId(applyCurrentNamespace(nestedResultMap, true));
-    builder.resultSet(resultSet);
-    builder.typeHandler(typeHandlerInstance);
-    builder.flags(flags == null ? new ArrayList<ResultFlag>() : flags);
-    builder.composites(composites);
-    builder.notNullColumns(parseMultipleColumnNames(notNullColumn));
-    builder.columnPrefix(columnPrefix);
-    builder.foreignColumn(foreignColumn);
-    builder.lazy(lazy);
-    return builder.build();
+    return new ResultMapping.Builder(configuration, property, column, javaTypeClass)
+        .jdbcType(jdbcType)
+        .nestedQueryId(applyCurrentNamespace(nestedSelect, true))
+        .nestedResultMapId(applyCurrentNamespace(nestedResultMap, true))
+        .resultSet(resultSet)
+        .typeHandler(typeHandlerInstance)
+        .flags(flags == null ? new ArrayList<ResultFlag>() : flags)
+        .composites(composites)
+        .notNullColumns(parseMultipleColumnNames(notNullColumn))
+        .columnPrefix(columnPrefix)
+        .foreignColumn(foreignColumn)
+        .lazy(lazy)
+        .build();
   }
 
   private Set<String> parseMultipleColumnNames(String columnName) {
@@ -431,8 +417,9 @@ private List<ResultMapping> parseCompositeColumnName(String columnName) {
       while (parser.hasMoreTokens()) {
         String property = parser.nextToken();
         String column = parser.nextToken();
-        ResultMapping.Builder complexBuilder = new ResultMapping.Builder(configuration, property, column, configuration.getTypeHandlerRegistry().getUnknownTypeHandler());
-        composites.add(complexBuilder.build());
+        ResultMapping complexResultMapping = new ResultMapping.Builder(
+            configuration, property, column, configuration.getTypeHandlerRegistry().getUnknownTypeHandler()).build();
+        composites.add(complexResultMapping);
       }
     }
     return composites;