[Sonar] Fix variable name

kazuki43zoo · kazuki43zoo · commit 15683a212eeb · 2019-02-03T23:36:12.000+09:00
diff --git a/src/main/java/org/apache/ibatis/builder/SqlSourceBuilder.java b/src/main/java/org/apache/ibatis/builder/SqlSourceBuilder.java
@@ -1,5 +1,5 @@
 /**
- *    Copyright 2009-2018 the original author or authors.
+ *    Copyright 2009-2019 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -33,7 +33,7 @@
  */
 public class SqlSourceBuilder extends BaseBuilder {
 
-  private static final String parameterProperties = "javaType,jdbcType,mode,numericScale,resultMap,typeHandler,jdbcTypeName";
+  private static final String PARAMETER_PROPERTIES = "javaType,jdbcType,mode,numericScale,resultMap,typeHandler,jdbcTypeName";
 
   public SqlSourceBuilder(Configuration configuration) {
     super(configuration);
@@ -114,7 +114,7 @@ private ParameterMapping buildParameterMapping(String content) {
         } else if ("expression".equals(name)) {
           throw new BuilderException("Expression based parameters are not supported yet");
         } else {
-          throw new BuilderException("An invalid property '" + name + "' was found in mapping #{" + content + "}.  Valid properties are " + parameterProperties);
+          throw new BuilderException("An invalid property '" + name + "' was found in mapping #{" + content + "}.  Valid properties are " + PARAMETER_PROPERTIES);
         }
       }
       if (typeHandlerAlias != null) {
diff --git a/src/main/java/org/apache/ibatis/type/TypeAliasRegistry.java b/src/main/java/org/apache/ibatis/type/TypeAliasRegistry.java
@@ -37,7 +37,7 @@
  */
 public class TypeAliasRegistry {
 
-  private final Map<String, Class<?>> TYPE_ALIASES = new HashMap<>();
+  private final Map<String, Class<?>> typeAliases = new HashMap<>();
 
   public TypeAliasRegistry() {
     registerAlias("string", String.class);
@@ -110,8 +110,8 @@ public <T> Class<T> resolveAlias(String string) {
       // issue #748
       String key = string.toLowerCase(Locale.ENGLISH);
       Class<T> value;
-      if (TYPE_ALIASES.containsKey(key)) {
-        value = (Class<T>) TYPE_ALIASES.get(key);
+      if (typeAliases.containsKey(key)) {
+        value = (Class<T>) typeAliases.get(key);
       } else {
         value = (Class<T>) Resources.classForName(string);
       }
@@ -153,10 +153,10 @@ public void registerAlias(String alias, Class<?> value) {
     }
     // issue #748
     String key = alias.toLowerCase(Locale.ENGLISH);
-    if (TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null && !TYPE_ALIASES.get(key).equals(value)) {
-      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'.");
+    if (typeAliases.containsKey(key) && typeAliases.get(key) != null && !typeAliases.get(key).equals(value)) {
+      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + typeAliases.get(key).getName() + "'.");
     }
-    TYPE_ALIASES.put(key, value);
+    typeAliases.put(key, value);
   }
 
   public void registerAlias(String alias, String value) {
@@ -171,7 +171,7 @@ public void registerAlias(String alias, String value) {
    * @since 3.2.2
    */
   public Map<String, Class<?>> getTypeAliases() {
-    return Collections.unmodifiableMap(TYPE_ALIASES);
+    return Collections.unmodifiableMap(typeAliases);
   }
 
 }
diff --git a/src/main/java/org/apache/ibatis/type/TypeHandlerRegistry.java b/src/main/java/org/apache/ibatis/type/TypeHandlerRegistry.java
@@ -53,10 +53,10 @@
  */
 public final class TypeHandlerRegistry {
 
-  private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap<>(JdbcType.class);
-  private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new ConcurrentHashMap<>();
-  private final TypeHandler<Object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this);
-  private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = new HashMap<>();
+  private final Map<JdbcType, TypeHandler<?>>  jdbcTypeHandlerMap = new EnumMap<>(JdbcType.class);
+  private final Map<Type, Map<JdbcType, TypeHandler<?>>> typeHandlerMap = new ConcurrentHashMap<>();
+  private final TypeHandler<Object> unknownTypeHandler = new UnknownTypeHandler(this);
+  private final Map<Class<?>, TypeHandler<?>> allTypeHandlersMap = new HashMap<>();
 
   private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();
 
@@ -129,9 +129,9 @@ public TypeHandlerRegistry() {
     register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
     register(JdbcType.BLOB, new BlobTypeHandler());
 
-    register(Object.class, UNKNOWN_TYPE_HANDLER);
-    register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
-    register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
+    register(Object.class, unknownTypeHandler);
+    register(Object.class, JdbcType.OTHER, unknownTypeHandler);
+    register(JdbcType.OTHER, unknownTypeHandler);
 
     register(Date.class, new DateTypeHandler());
     register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
@@ -190,7 +190,7 @@ public boolean hasTypeHandler(TypeReference<?> javaTypeReference, JdbcType jdbcT
   }
 
   public TypeHandler<?> getMappingTypeHandler(Class<? extends TypeHandler<?>> handlerType) {
-    return ALL_TYPE_HANDLERS_MAP.get(handlerType);
+    return allTypeHandlersMap.get(handlerType);
   }
 
   public <T> TypeHandler<T> getTypeHandler(Class<T> type) {
@@ -202,7 +202,7 @@ public <T> TypeHandler<T> getTypeHandler(TypeReference<T> javaTypeReference) {
   }
 
   public TypeHandler<?> getTypeHandler(JdbcType jdbcType) {
-    return JDBC_TYPE_HANDLER_MAP.get(jdbcType);
+    return jdbcTypeHandlerMap.get(jdbcType);
   }
 
   public <T> TypeHandler<T> getTypeHandler(Class<T> type, JdbcType jdbcType) {
@@ -235,7 +235,7 @@ private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
   }
 
   private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {
-    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);
+    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(type);
     if (NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap)) {
       return null;
     }
@@ -245,19 +245,19 @@ private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {
         jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(clazz, clazz);
         if (jdbcHandlerMap == null) {
           register(clazz, getInstance(clazz, defaultEnumTypeHandler));
-          return TYPE_HANDLER_MAP.get(clazz);
+          return typeHandlerMap.get(clazz);
         }
       } else {
         jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);
       }
     }
-    TYPE_HANDLER_MAP.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);
+    typeHandlerMap.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);
     return jdbcHandlerMap;
   }
 
   private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForEnumInterfaces(Class<?> clazz, Class<?> enumClazz) {
     for (Class<?> iface : clazz.getInterfaces()) {
-      Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(iface);
+      Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(iface);
       if (jdbcHandlerMap == null) {
         jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(iface, enumClazz);
       }
@@ -279,7 +279,7 @@ private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForSuperclass(Class<?> cl
     if (superclass == null || Object.class.equals(superclass)) {
       return null;
     }
-    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(superclass);
+    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(superclass);
     if (jdbcHandlerMap != null) {
       return jdbcHandlerMap;
     } else {
@@ -301,11 +301,11 @@ private TypeHandler<?> pickSoleHandler(Map<JdbcType, TypeHandler<?>> jdbcHandler
   }
 
   public TypeHandler<Object> getUnknownTypeHandler() {
-    return UNKNOWN_TYPE_HANDLER;
+    return unknownTypeHandler;
   }
 
   public void register(JdbcType jdbcType, TypeHandler<?> handler) {
-    JDBC_TYPE_HANDLER_MAP.put(jdbcType, handler);
+    jdbcTypeHandlerMap.put(jdbcType, handler);
   }
 
   //
@@ -371,14 +371,14 @@ public <T> void register(Class<T> type, JdbcType jdbcType, TypeHandler<? extends
 
   private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
     if (javaType != null) {
-      Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);
+      Map<JdbcType, TypeHandler<?>> map = typeHandlerMap.get(javaType);
       if (map == null || map == NULL_TYPE_HANDLER_MAP) {
         map = new HashMap<>();
-        TYPE_HANDLER_MAP.put(javaType, map);
+        typeHandlerMap.put(javaType, map);
       }
       map.put(jdbcType, handler);
     }
-    ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
+    allTypeHandlersMap.put(handler.getClass(), handler);
   }
 
   //
@@ -459,7 +459,7 @@ public void register(String packageName) {
    * @since 3.2.2
    */
   public Collection<TypeHandler<?>> getTypeHandlers() {
-    return Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());
+    return Collections.unmodifiableCollection(allTypeHandlersMap.values());
   }
 
 }

Original file line number	Diff line number	Diff line change
`@@ -53,10 +53,10 @@`
`53`	`53`	`*/`
`54`	`54`	`public final class TypeHandlerRegistry {`
`55`	`55`
`56`		`- private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap<>(JdbcType.class);`
`57`		`- private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new ConcurrentHashMap<>();`
`58`		`- private final TypeHandler<Object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this);`
`59`		`- private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = new HashMap<>();`
	`56`	`+ private final Map<JdbcType, TypeHandler<?>> jdbcTypeHandlerMap = new EnumMap<>(JdbcType.class);`
	`57`	`+ private final Map<Type, Map<JdbcType, TypeHandler<?>>> typeHandlerMap = new ConcurrentHashMap<>();`
	`58`	`+ private final TypeHandler<Object> unknownTypeHandler = new UnknownTypeHandler(this);`
	`59`	`+ private final Map<Class<?>, TypeHandler<?>> allTypeHandlersMap = new HashMap<>();`
`60`	`60`
`61`	`61`	`private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();`
`62`	`62`
`@@ -129,9 +129,9 @@ public TypeHandlerRegistry() {`
`129`	`129`	`register(JdbcType.LONGVARBINARY, new BlobTypeHandler());`
`130`	`130`	`register(JdbcType.BLOB, new BlobTypeHandler());`
`131`	`131`
`132`		`- register(Object.class, UNKNOWN_TYPE_HANDLER);`
`133`		`- register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);`
`134`		`- register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);`
	`132`	`+ register(Object.class, unknownTypeHandler);`
	`133`	`+ register(Object.class, JdbcType.OTHER, unknownTypeHandler);`
	`134`	`+ register(JdbcType.OTHER, unknownTypeHandler);`
`135`	`135`
`136`	`136`	`register(Date.class, new DateTypeHandler());`
`137`	`137`	`register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());`
`@@ -190,7 +190,7 @@ public boolean hasTypeHandler(TypeReference<?> javaTypeReference, JdbcType jdbcT`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`public TypeHandler<?> getMappingTypeHandler(Class<? extends TypeHandler<?>> handlerType) {`
`193`		`- return ALL_TYPE_HANDLERS_MAP.get(handlerType);`
	`193`	`+ return allTypeHandlersMap.get(handlerType);`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`public <T> TypeHandler<T> getTypeHandler(Class<T> type) {`
`@@ -202,7 +202,7 @@ public <T> TypeHandler<T> getTypeHandler(TypeReference<T> javaTypeReference) {`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`public TypeHandler<?> getTypeHandler(JdbcType jdbcType) {`
`205`		`- return JDBC_TYPE_HANDLER_MAP.get(jdbcType);`
	`205`	`+ return jdbcTypeHandlerMap.get(jdbcType);`
`206`	`206`	`}`
`207`	`207`
`208`	`208`	`public <T> TypeHandler<T> getTypeHandler(Class<T> type, JdbcType jdbcType) {`
`@@ -235,7 +235,7 @@ private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {`
`235`	`235`	`}`
`236`	`236`
`237`	`237`	`private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {`
`238`		`- Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);`
	`238`	`+ Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(type);`
`239`	`239`	`if (NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap)) {`
`240`	`240`	`return null;`
`241`	`241`	`}`
`@@ -245,19 +245,19 @@ private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {`
`245`	`245`	`jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(clazz, clazz);`
`246`	`246`	`if (jdbcHandlerMap == null) {`
`247`	`247`	`register(clazz, getInstance(clazz, defaultEnumTypeHandler));`
`248`		`- return TYPE_HANDLER_MAP.get(clazz);`
	`248`	`+ return typeHandlerMap.get(clazz);`
`249`	`249`	`}`
`250`	`250`	`} else {`
`251`	`251`	`jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);`
`252`	`252`	`}`
`253`	`253`	`}`
`254`		`- TYPE_HANDLER_MAP.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);`
	`254`	`+ typeHandlerMap.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);`
`255`	`255`	`return jdbcHandlerMap;`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForEnumInterfaces(Class<?> clazz, Class<?> enumClazz) {`
`259`	`259`	`for (Class<?> iface : clazz.getInterfaces()) {`
`260`		`- Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(iface);`
	`260`	`+ Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(iface);`
`261`	`261`	`if (jdbcHandlerMap == null) {`
`262`	`262`	`jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(iface, enumClazz);`
`263`	`263`	`}`
`@@ -279,7 +279,7 @@ private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForSuperclass(Class<?> cl`
`279`	`279`	`if (superclass == null \|\| Object.class.equals(superclass)) {`
`280`	`280`	`return null;`
`281`	`281`	`}`
`282`		`- Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(superclass);`
	`282`	`+ Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(superclass);`
`283`	`283`	`if (jdbcHandlerMap != null) {`
`284`	`284`	`return jdbcHandlerMap;`
`285`	`285`	`} else {`
`@@ -301,11 +301,11 @@ private TypeHandler<?> pickSoleHandler(Map<JdbcType, TypeHandler<?>> jdbcHandler`
`301`	`301`	`}`
`302`	`302`
`303`	`303`	`public TypeHandler<Object> getUnknownTypeHandler() {`
`304`		`- return UNKNOWN_TYPE_HANDLER;`
	`304`	`+ return unknownTypeHandler;`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`public void register(JdbcType jdbcType, TypeHandler<?> handler) {`
`308`		`- JDBC_TYPE_HANDLER_MAP.put(jdbcType, handler);`
	`308`	`+ jdbcTypeHandlerMap.put(jdbcType, handler);`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`//`
`@@ -371,14 +371,14 @@ public <T> void register(Class<T> type, JdbcType jdbcType, TypeHandler<? extends`
`371`	`371`
`372`	`372`	`private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {`
`373`	`373`	`if (javaType != null) {`
`374`		`- Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);`
	`374`	`+ Map<JdbcType, TypeHandler<?>> map = typeHandlerMap.get(javaType);`
`375`	`375`	`if (map == null \|\| map == NULL_TYPE_HANDLER_MAP) {`
`376`	`376`	`map = new HashMap<>();`
`377`		`- TYPE_HANDLER_MAP.put(javaType, map);`
	`377`	`+ typeHandlerMap.put(javaType, map);`
`378`	`378`	`}`
`379`	`379`	`map.put(jdbcType, handler);`
`380`	`380`	`}`
`381`		`- ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);`
	`381`	`+ allTypeHandlersMap.put(handler.getClass(), handler);`
`382`	`382`	`}`
`383`	`383`
`384`	`384`	`//`
`@@ -459,7 +459,7 @@ public void register(String packageName) {`
`459`	`459`	`* @since 3.2.2`
`460`	`460`	`*/`
`461`	`461`	`public Collection<TypeHandler<?>> getTypeHandlers() {`
`462`		`- return Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());`
	`462`	`+ return Collections.unmodifiableCollection(allTypeHandlersMap.values());`
`463`	`463`	`}`
`464`	`464`
`465`	`465`	`}`