#3198

Committed 27 Aug 2023 08:39PM UTC coverage: 86.703% (-0.9%) from 87.632%

Build # #3198

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #2944 from hazendaz/copyright

Update maven and github actions

Run Details

9305 of 10732 relevant lines covered (86.7%)

0.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.01

/src/main/java/org/apache/ibatis/type/TypeHandlerRegistry.java

/*
 *    Copyright 2009-2023 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.
 *    You may obtain a copy of the License at
 *
 *       https://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.type;

import java.io.InputStream;
import java.io.Reader;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.Year;
import java.time.YearMonth;
import java.time.ZonedDateTime;
import java.time.chrono.JapaneseDate;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.ibatis.binding.MapperMethod.ParamMap;
import org.apache.ibatis.io.ResolverUtil;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.Configuration;

/**
 * @author Clinton Begin
 * @author Kazuki Shimizu
 */
public final class TypeHandlerRegistry {

  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;
  private final Map<Class<?>, TypeHandler<?>> allTypeHandlersMap = new HashMap<>();

  private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();

  private Class<? extends TypeHandler> defaultEnumTypeHandler = EnumTypeHandler.class;

  /**
   * The default constructor.
   */
  public TypeHandlerRegistry() {
    this(new Configuration());
  }

  /**
   * The constructor that pass the MyBatis configuration.
   *
   * @param configuration
   *          a MyBatis configuration
   *
   * @since 3.5.4
   */
  public TypeHandlerRegistry(Configuration configuration) {
    this.unknownTypeHandler = new UnknownTypeHandler(configuration);

    register(Boolean.class, new BooleanTypeHandler());
    register(boolean.class, new BooleanTypeHandler());
    register(JdbcType.BOOLEAN, new BooleanTypeHandler());
    register(JdbcType.BIT, new BooleanTypeHandler());

    register(Byte.class, new ByteTypeHandler());
    register(byte.class, new ByteTypeHandler());
    register(JdbcType.TINYINT, new ByteTypeHandler());

    register(Short.class, new ShortTypeHandler());
    register(short.class, new ShortTypeHandler());
    register(JdbcType.SMALLINT, new ShortTypeHandler());

    register(Integer.class, new IntegerTypeHandler());
    register(int.class, new IntegerTypeHandler());
    register(JdbcType.INTEGER, new IntegerTypeHandler());

    register(Long.class, new LongTypeHandler());
    register(long.class, new LongTypeHandler());

    register(Float.class, new FloatTypeHandler());
    register(float.class, new FloatTypeHandler());
    register(JdbcType.FLOAT, new FloatTypeHandler());

    register(Double.class, new DoubleTypeHandler());
    register(double.class, new DoubleTypeHandler());
    register(JdbcType.DOUBLE, new DoubleTypeHandler());

    register(Reader.class, new ClobReaderTypeHandler());
    register(String.class, new StringTypeHandler());
    register(String.class, JdbcType.CHAR, new StringTypeHandler());
    register(String.class, JdbcType.CLOB, new ClobTypeHandler());
    register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.LONGVARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
    register(JdbcType.CHAR, new StringTypeHandler());
    register(JdbcType.VARCHAR, new StringTypeHandler());
    register(JdbcType.CLOB, new ClobTypeHandler());
    register(JdbcType.LONGVARCHAR, new StringTypeHandler());
    register(JdbcType.NVARCHAR, new NStringTypeHandler());
    register(JdbcType.NCHAR, new NStringTypeHandler());
    register(JdbcType.NCLOB, new NClobTypeHandler());

    register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
    register(JdbcType.ARRAY, new ArrayTypeHandler());

    register(BigInteger.class, new BigIntegerTypeHandler());
    register(JdbcType.BIGINT, new LongTypeHandler());

    register(BigDecimal.class, new BigDecimalTypeHandler());
    register(JdbcType.REAL, new BigDecimalTypeHandler());
    register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
    register(JdbcType.NUMERIC, new BigDecimalTypeHandler());

    register(InputStream.class, new BlobInputStreamTypeHandler());
    register(Byte[].class, new ByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
    register(byte[].class, new ByteArrayTypeHandler());
    register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
    register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.BLOB, new BlobTypeHandler());

    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());
    register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
    register(JdbcType.TIMESTAMP, new DateTypeHandler());
    register(JdbcType.DATE, new DateOnlyTypeHandler());
    register(JdbcType.TIME, new TimeOnlyTypeHandler());

    register(java.sql.Date.class, new SqlDateTypeHandler());
    register(java.sql.Time.class, new SqlTimeTypeHandler());
    register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());

    register(String.class, JdbcType.SQLXML, new SqlxmlTypeHandler());

    register(Instant.class, new InstantTypeHandler());
    register(LocalDateTime.class, new LocalDateTimeTypeHandler());
    register(LocalDate.class, new LocalDateTypeHandler());
    register(LocalTime.class, new LocalTimeTypeHandler());
    register(OffsetDateTime.class, new OffsetDateTimeTypeHandler());
    register(OffsetTime.class, new OffsetTimeTypeHandler());
    register(ZonedDateTime.class, new ZonedDateTimeTypeHandler());
    register(Month.class, new MonthTypeHandler());
    register(Year.class, new YearTypeHandler());
    register(YearMonth.class, new YearMonthTypeHandler());
    register(JapaneseDate.class, new JapaneseDateTypeHandler());

    // issue #273
    register(Character.class, new CharacterTypeHandler());
    register(char.class, new CharacterTypeHandler());
  }

  /**
   * Set a default {@link TypeHandler} class for {@link Enum}. A default {@link TypeHandler} is
   * {@link org.apache.ibatis.type.EnumTypeHandler}.
   *
   * @param typeHandler
   *          a type handler class for {@link Enum}
   *
   * @since 3.4.5
   */
  public void setDefaultEnumTypeHandler(Class<? extends TypeHandler> typeHandler) {
    this.defaultEnumTypeHandler = typeHandler;
  }

  public boolean hasTypeHandler(Class<?> javaType) {
    return hasTypeHandler(javaType, null);
  }

  public boolean hasTypeHandler(TypeReference<?> javaTypeReference) {
    return hasTypeHandler(javaTypeReference, null);
  }

  public boolean hasTypeHandler(Class<?> javaType, JdbcType jdbcType) {
    return javaType != null && getTypeHandler((Type) javaType, jdbcType) != null;
  }

  public boolean hasTypeHandler(TypeReference<?> javaTypeReference, JdbcType jdbcType) {
    return javaTypeReference != null && getTypeHandler(javaTypeReference, jdbcType) != null;
  }

  public TypeHandler<?> getMappingTypeHandler(Class<? extends TypeHandler<?>> handlerType) {
    return allTypeHandlersMap.get(handlerType);
  }

  public <T> TypeHandler<T> getTypeHandler(Class<T> type) {
    return getTypeHandler((Type) type, null);
  }

  public <T> TypeHandler<T> getTypeHandler(TypeReference<T> javaTypeReference) {
    return getTypeHandler(javaTypeReference, null);
  }

  public TypeHandler<?> getTypeHandler(JdbcType jdbcType) {
    return jdbcTypeHandlerMap.get(jdbcType);
  }

  public <T> TypeHandler<T> getTypeHandler(Class<T> type, JdbcType jdbcType) {
    return getTypeHandler((Type) type, jdbcType);
  }

  public <T> TypeHandler<T> getTypeHandler(TypeReference<T> javaTypeReference, JdbcType jdbcType) {
    return getTypeHandler(javaTypeReference.getRawType(), jdbcType);
  }

  @SuppressWarnings("unchecked")
  private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
    if (ParamMap.class.equals(type)) {
      return null;
    }
    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);
    TypeHandler<?> handler = null;
    if (jdbcHandlerMap != null) {
      handler = jdbcHandlerMap.get(jdbcType);
      if (handler == null) {
        handler = jdbcHandlerMap.get(null);
      }
      if (handler == null) {
        // #591
        handler = pickSoleHandler(jdbcHandlerMap);
      }
    }
    // type drives generics here
    return (TypeHandler<T>) handler;
  }

  private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {
    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(type);
    if (jdbcHandlerMap != null) {
      return NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap) ? null : jdbcHandlerMap;
    }
    if (type instanceof Class) {
      Class<?> clazz = (Class<?>) type;
      if (Enum.class.isAssignableFrom(clazz)) {
        Class<?> enumClass = clazz.isAnonymousClass() ? clazz.getSuperclass() : clazz;
        jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(enumClass, enumClass);
        if (jdbcHandlerMap == null) {
          register(enumClass, getInstance(enumClass, defaultEnumTypeHandler));
          return typeHandlerMap.get(enumClass);
        }
      } else {
        jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);
      }
    }
    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 = typeHandlerMap.get(iface);
      if (jdbcHandlerMap == null) {
        jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(iface, enumClazz);
      }
      if (jdbcHandlerMap != null) {
        // Found a type handler registered to a super interface
        HashMap<JdbcType, TypeHandler<?>> newMap = new HashMap<>();
        for (Entry<JdbcType, TypeHandler<?>> entry : jdbcHandlerMap.entrySet()) {
          // Create a type handler instance with enum type as a constructor arg
          newMap.put(entry.getKey(), getInstance(enumClazz, entry.getValue().getClass()));
        }
        return newMap;
      }
    }
    return null;
  }

  private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForSuperclass(Class<?> clazz) {
    Class<?> superclass = clazz.getSuperclass();
    if (superclass == null || Object.class.equals(superclass)) {
      return null;
    }
    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(superclass);
    if (jdbcHandlerMap != null) {
      return jdbcHandlerMap;
    }
    return getJdbcHandlerMapForSuperclass(superclass);
  }

  private TypeHandler<?> pickSoleHandler(Map<JdbcType, TypeHandler<?>> jdbcHandlerMap) {
    TypeHandler<?> soleHandler = null;
    for (TypeHandler<?> handler : jdbcHandlerMap.values()) {
      if (soleHandler == null) {
        soleHandler = handler;
      } else if (!handler.getClass().equals(soleHandler.getClass())) {
        // More than one type handlers registered.
        return null;
      }
    }
    return soleHandler;
  }

  public TypeHandler<Object> getUnknownTypeHandler() {
    return unknownTypeHandler;
  }

  public void register(JdbcType jdbcType, TypeHandler<?> handler) {
    jdbcTypeHandlerMap.put(jdbcType, handler);
  }

  //
  // REGISTER INSTANCE
  //

  // Only handler

  @SuppressWarnings("unchecked")
  public <T> void register(TypeHandler<T> typeHandler) {
    boolean mappedTypeFound = false;
    MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);
    if (mappedTypes != null) {
      for (Class<?> handledType : mappedTypes.value()) {
        register(handledType, typeHandler);
        mappedTypeFound = true;
      }
    }
    // @since 3.1.0 - try to auto-discover the mapped type
    if (!mappedTypeFound && typeHandler instanceof TypeReference) {
      try {
        TypeReference<T> typeReference = (TypeReference<T>) typeHandler;
        register(typeReference.getRawType(), typeHandler);
        mappedTypeFound = true;
      } catch (Throwable t) {
        // maybe users define the TypeReference with a different type and are not assignable, so just ignore it
      }
    }
    if (!mappedTypeFound) {
      register((Class<T>) null, typeHandler);
    }
  }

  // java type + handler

  public <T> void register(Class<T> javaType, TypeHandler<? extends T> typeHandler) {
    register((Type) javaType, typeHandler);
  }

  private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {
    MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
    if (mappedJdbcTypes != null) {
      for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
        register(javaType, handledJdbcType, typeHandler);
      }
      if (mappedJdbcTypes.includeNullJdbcType()) {
        register(javaType, null, typeHandler);
      }
    } else {
      register(javaType, null, typeHandler);
    }
  }

  public <T> void register(TypeReference<T> javaTypeReference, TypeHandler<? extends T> handler) {
    register(javaTypeReference.getRawType(), handler);
  }

  // java type + jdbc type + handler

  // Cast is required here
  @SuppressWarnings("cast")
  public <T> void register(Class<T> type, JdbcType jdbcType, TypeHandler<? extends T> handler) {
    register((Type) type, jdbcType, handler);
  }

  private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
    if (javaType != null) {
      Map<JdbcType, TypeHandler<?>> map = typeHandlerMap.get(javaType);
      if (map == null || map == NULL_TYPE_HANDLER_MAP) {
        map = new HashMap<>();
      }
      map.put(jdbcType, handler);
      typeHandlerMap.put(javaType, map);
    }
    allTypeHandlersMap.put(handler.getClass(), handler);
  }

  //
  // REGISTER CLASS
  //

  // Only handler type

  public void register(Class<?> typeHandlerClass) {
    boolean mappedTypeFound = false;
    MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
    if (mappedTypes != null) {
      for (Class<?> javaTypeClass : mappedTypes.value()) {
        register(javaTypeClass, typeHandlerClass);
        mappedTypeFound = true;
      }
    }
    if (!mappedTypeFound) {
      register(getInstance(null, typeHandlerClass));
    }
  }

  // java type + handler type

  public void register(String javaTypeClassName, String typeHandlerClassName) throws ClassNotFoundException {
    register(Resources.classForName(javaTypeClassName), Resources.classForName(typeHandlerClassName));
  }

  public void register(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
    register(javaTypeClass, getInstance(javaTypeClass, typeHandlerClass));
  }

  // java type + jdbc type + handler type

  public void register(Class<?> javaTypeClass, JdbcType jdbcType, Class<?> typeHandlerClass) {
    register(javaTypeClass, jdbcType, getInstance(javaTypeClass, typeHandlerClass));
  }

  // Construct a handler (used also from Builders)

  @SuppressWarnings("unchecked")
  public <T> TypeHandler<T> getInstance(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
    if (javaTypeClass != null) {
      try {
        Constructor<?> c = typeHandlerClass.getConstructor(Class.class);
        return (TypeHandler<T>) c.newInstance(javaTypeClass);
      } catch (NoSuchMethodException ignored) {
        // ignored
      } catch (Exception e) {
        throw new TypeException("Failed invoking constructor for handler " + typeHandlerClass, e);
      }
    }
    try {
      Constructor<?> c = typeHandlerClass.getConstructor();
      return (TypeHandler<T>) c.newInstance();
    } catch (Exception e) {
      throw new TypeException("Unable to find a usable constructor for " + typeHandlerClass, e);
    }
  }

  // scan

  public void register(String packageName) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
    resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);
    Set<Class<? extends Class<?>>> handlerSet = resolverUtil.getClasses();
    for (Class<?> type : handlerSet) {
      // Ignore inner classes and interfaces (including package-info.java) and abstract classes
      if (!type.isAnonymousClass() && !type.isInterface() && !Modifier.isAbstract(type.getModifiers())) {
        register(type);
      }
    }
  }

  // get information

  /**
   * Gets the type handlers.
   *
   * @return the type handlers
   *
   * @since 3.2.2
   */
  public Collection<TypeHandler<?>> getTypeHandlers() {
    return Collections.unmodifiableCollection(allTypeHandlersMap.values());
  }

}

1	/*
2	* Copyright 2009-2023 the original author or authors.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package org.apache.ibatis.type;
17
18	import java.io.InputStream;
19	import java.io.Reader;
20	import java.lang.reflect.Constructor;
21	import java.lang.reflect.Modifier;
22	import java.lang.reflect.Type;
23	import java.math.BigDecimal;
24	import java.math.BigInteger;
25	import java.time.Instant;
26	import java.time.LocalDate;
27	import java.time.LocalDateTime;
28	import java.time.LocalTime;
29	import java.time.Month;
30	import java.time.OffsetDateTime;
31	import java.time.OffsetTime;
32	import java.time.Year;
33	import java.time.YearMonth;
34	import java.time.ZonedDateTime;
35	import java.time.chrono.JapaneseDate;
36	import java.util.Collection;
37	import java.util.Collections;
38	import java.util.Date;
39	import java.util.EnumMap;
40	import java.util.HashMap;
41	import java.util.Map;
42	import java.util.Map.Entry;
43	import java.util.Set;
44	import java.util.concurrent.ConcurrentHashMap;
45
46	import org.apache.ibatis.binding.MapperMethod.ParamMap;
47	import org.apache.ibatis.io.ResolverUtil;
48	import org.apache.ibatis.io.Resources;
49	import org.apache.ibatis.session.Configuration;
50
51	/**
52	* @author Clinton Begin
53	* @author Kazuki Shimizu
54	*/
55	public final class TypeHandlerRegistry {
56
57	private final Map<JdbcType, TypeHandler<?>> jdbcTypeHandlerMap = new EnumMap<>(JdbcType.class);	1✔
58	private final Map<Type, Map<JdbcType, TypeHandler<?>>> typeHandlerMap = new ConcurrentHashMap<>();	1✔
59	private final TypeHandler<Object> unknownTypeHandler;
60	private final Map<Class<?>, TypeHandler<?>> allTypeHandlersMap = new HashMap<>();	1✔
61
62	private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();	1✔
63
64	private Class<? extends TypeHandler> defaultEnumTypeHandler = EnumTypeHandler.class;	1✔
65
66	/**
67	* The default constructor.
68	*/
69	public TypeHandlerRegistry() {
70	this(new Configuration());	1✔
71	}	1✔
72
73	/**
74	* The constructor that pass the MyBatis configuration.
75	*
76	* @param configuration
77	* a MyBatis configuration
78	*
79	* @since 3.5.4
80	*/
81	public TypeHandlerRegistry(Configuration configuration) {	1✔
82	this.unknownTypeHandler = new UnknownTypeHandler(configuration);	1✔
83
84	register(Boolean.class, new BooleanTypeHandler());	1✔
85	register(boolean.class, new BooleanTypeHandler());	1✔
86	register(JdbcType.BOOLEAN, new BooleanTypeHandler());	1✔
87	register(JdbcType.BIT, new BooleanTypeHandler());	1✔
88
89	register(Byte.class, new ByteTypeHandler());	1✔
90	register(byte.class, new ByteTypeHandler());	1✔
91	register(JdbcType.TINYINT, new ByteTypeHandler());	1✔
92
93	register(Short.class, new ShortTypeHandler());	1✔
94	register(short.class, new ShortTypeHandler());	1✔
95	register(JdbcType.SMALLINT, new ShortTypeHandler());	1✔
96
97	register(Integer.class, new IntegerTypeHandler());	1✔
98	register(int.class, new IntegerTypeHandler());	1✔
99	register(JdbcType.INTEGER, new IntegerTypeHandler());	1✔
100
101	register(Long.class, new LongTypeHandler());	1✔
102	register(long.class, new LongTypeHandler());	1✔
103
104	register(Float.class, new FloatTypeHandler());	1✔
105	register(float.class, new FloatTypeHandler());	1✔
106	register(JdbcType.FLOAT, new FloatTypeHandler());	1✔
107
108	register(Double.class, new DoubleTypeHandler());	1✔
109	register(double.class, new DoubleTypeHandler());	1✔
110	register(JdbcType.DOUBLE, new DoubleTypeHandler());	1✔
111
112	register(Reader.class, new ClobReaderTypeHandler());	1✔
113	register(String.class, new StringTypeHandler());	1✔
114	register(String.class, JdbcType.CHAR, new StringTypeHandler());	1✔
115	register(String.class, JdbcType.CLOB, new ClobTypeHandler());	1✔
116	register(String.class, JdbcType.VARCHAR, new StringTypeHandler());	1✔
117	register(String.class, JdbcType.LONGVARCHAR, new StringTypeHandler());	1✔
118	register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());	1✔
119	register(String.class, JdbcType.NCHAR, new NStringTypeHandler());	1✔
120	register(String.class, JdbcType.NCLOB, new NClobTypeHandler());	1✔
121	register(JdbcType.CHAR, new StringTypeHandler());	1✔
122	register(JdbcType.VARCHAR, new StringTypeHandler());	1✔
123	register(JdbcType.CLOB, new ClobTypeHandler());	1✔
124	register(JdbcType.LONGVARCHAR, new StringTypeHandler());	1✔
125	register(JdbcType.NVARCHAR, new NStringTypeHandler());	1✔
126	register(JdbcType.NCHAR, new NStringTypeHandler());	1✔
127	register(JdbcType.NCLOB, new NClobTypeHandler());	1✔
128
129	register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());	1✔
130	register(JdbcType.ARRAY, new ArrayTypeHandler());	1✔
131
132	register(BigInteger.class, new BigIntegerTypeHandler());	1✔
133	register(JdbcType.BIGINT, new LongTypeHandler());	1✔
134
135	register(BigDecimal.class, new BigDecimalTypeHandler());	1✔
136	register(JdbcType.REAL, new BigDecimalTypeHandler());	1✔
137	register(JdbcType.DECIMAL, new BigDecimalTypeHandler());	1✔
138	register(JdbcType.NUMERIC, new BigDecimalTypeHandler());	1✔
139
140	register(InputStream.class, new BlobInputStreamTypeHandler());	1✔
141	register(Byte[].class, new ByteObjectArrayTypeHandler());	1✔
142	register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());	1✔
143	register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());	1✔
144	register(byte[].class, new ByteArrayTypeHandler());	1✔
145	register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());	1✔
146	register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());	1✔
147	register(JdbcType.LONGVARBINARY, new BlobTypeHandler());	1✔
148	register(JdbcType.BLOB, new BlobTypeHandler());	1✔
149
150	register(Object.class, unknownTypeHandler);	1✔
151	register(Object.class, JdbcType.OTHER, unknownTypeHandler);	1✔
152	register(JdbcType.OTHER, unknownTypeHandler);	1✔
153
154	register(Date.class, new DateTypeHandler());	1✔
155	register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());	1✔
156	register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());	1✔
157	register(JdbcType.TIMESTAMP, new DateTypeHandler());	1✔
158	register(JdbcType.DATE, new DateOnlyTypeHandler());	1✔
159	register(JdbcType.TIME, new TimeOnlyTypeHandler());	1✔
160
161	register(java.sql.Date.class, new SqlDateTypeHandler());	1✔
162	register(java.sql.Time.class, new SqlTimeTypeHandler());	1✔
163	register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());	1✔
164
165	register(String.class, JdbcType.SQLXML, new SqlxmlTypeHandler());	1✔
166
167	register(Instant.class, new InstantTypeHandler());	1✔
168	register(LocalDateTime.class, new LocalDateTimeTypeHandler());	1✔
169	register(LocalDate.class, new LocalDateTypeHandler());	1✔
170	register(LocalTime.class, new LocalTimeTypeHandler());	1✔
171	register(OffsetDateTime.class, new OffsetDateTimeTypeHandler());	1✔
172	register(OffsetTime.class, new OffsetTimeTypeHandler());	1✔
173	register(ZonedDateTime.class, new ZonedDateTimeTypeHandler());	1✔
174	register(Month.class, new MonthTypeHandler());	1✔
175	register(Year.class, new YearTypeHandler());	1✔
176	register(YearMonth.class, new YearMonthTypeHandler());	1✔
177	register(JapaneseDate.class, new JapaneseDateTypeHandler());	1✔
178
179	// issue #273
180	register(Character.class, new CharacterTypeHandler());	1✔
181	register(char.class, new CharacterTypeHandler());	1✔
182	}	1✔
183
184	/**
185	* Set a default {@link TypeHandler} class for {@link Enum}. A default {@link TypeHandler} is
186	* {@link org.apache.ibatis.type.EnumTypeHandler}.
187	*
188	* @param typeHandler
189	* a type handler class for {@link Enum}
190	*
191	* @since 3.4.5
192	*/
193	public void setDefaultEnumTypeHandler(Class<? extends TypeHandler> typeHandler) {
194	this.defaultEnumTypeHandler = typeHandler;	×
195	}	×
196
197	public boolean hasTypeHandler(Class<?> javaType) {
198	return hasTypeHandler(javaType, null);	1✔
199	}
200
201	public boolean hasTypeHandler(TypeReference<?> javaTypeReference) {
202	return hasTypeHandler(javaTypeReference, null);	×
203	}
204
205	public boolean hasTypeHandler(Class<?> javaType, JdbcType jdbcType) {
206	return javaType != null && getTypeHandler((Type) javaType, jdbcType) != null;	1✔
207	}
208
209	public boolean hasTypeHandler(TypeReference<?> javaTypeReference, JdbcType jdbcType) {
210	return javaTypeReference != null && getTypeHandler(javaTypeReference, jdbcType) != null;	×
211	}
212
213	public TypeHandler<?> getMappingTypeHandler(Class<? extends TypeHandler<?>> handlerType) {
214	return allTypeHandlersMap.get(handlerType);	1✔
215	}
216
217	public <T> TypeHandler<T> getTypeHandler(Class<T> type) {
218	return getTypeHandler((Type) type, null);	1✔
219	}
220
221	public <T> TypeHandler<T> getTypeHandler(TypeReference<T> javaTypeReference) {
222	return getTypeHandler(javaTypeReference, null);	1✔
223	}
224
225	public TypeHandler<?> getTypeHandler(JdbcType jdbcType) {
226	return jdbcTypeHandlerMap.get(jdbcType);	×
227	}
228
229	public <T> TypeHandler<T> getTypeHandler(Class<T> type, JdbcType jdbcType) {
230	return getTypeHandler((Type) type, jdbcType);	1✔
231	}
232
233	public <T> TypeHandler<T> getTypeHandler(TypeReference<T> javaTypeReference, JdbcType jdbcType) {
234	return getTypeHandler(javaTypeReference.getRawType(), jdbcType);	1✔
235	}
236
237	@SuppressWarnings("unchecked")
238	private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
239	if (ParamMap.class.equals(type)) {	1✔
240	return null;	1✔
241	}
242	Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);	1✔
243	TypeHandler<?> handler = null;	1✔
244	if (jdbcHandlerMap != null) {	1✔
245	handler = jdbcHandlerMap.get(jdbcType);	1✔
246	if (handler == null) {	1✔
247	handler = jdbcHandlerMap.get(null);	1✔
248	}
249	if (handler == null) {	1✔
250	// #591
251	handler = pickSoleHandler(jdbcHandlerMap);	1✔
252	}
253	}
254	// type drives generics here
255	return (TypeHandler<T>) handler;	1✔
256	}
257
258	private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {
259	Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(type);	1✔
260	if (jdbcHandlerMap != null) {	1✔
261	return NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap) ? null : jdbcHandlerMap;	1✔
262	}
263	if (type instanceof Class) {	1✔
264	Class<?> clazz = (Class<?>) type;	1✔
265	if (Enum.class.isAssignableFrom(clazz)) {	1✔
266	Class<?> enumClass = clazz.isAnonymousClass() ? clazz.getSuperclass() : clazz;	1✔
267	jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(enumClass, enumClass);	1✔
268	if (jdbcHandlerMap == null) {	1✔
269	register(enumClass, getInstance(enumClass, defaultEnumTypeHandler));	1✔
270	return typeHandlerMap.get(enumClass);	1✔
271	}
272	} else {	1✔
273	jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);	1✔
274	}
275	}
276	typeHandlerMap.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);	1✔
277	return jdbcHandlerMap;	1✔
278	}
279
280	private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForEnumInterfaces(Class<?> clazz, Class<?> enumClazz) {
281	for (Class<?> iface : clazz.getInterfaces()) {	1✔
282	Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(iface);	1✔
283	if (jdbcHandlerMap == null) {	1✔
284	jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(iface, enumClazz);	1✔
285	}
286	if (jdbcHandlerMap != null) {	1✔
287	// Found a type handler registered to a super interface
288	HashMap<JdbcType, TypeHandler<?>> newMap = new HashMap<>();	1✔
289	for (Entry<JdbcType, TypeHandler<?>> entry : jdbcHandlerMap.entrySet()) {	1✔
290	// Create a type handler instance with enum type as a constructor arg
291	newMap.put(entry.getKey(), getInstance(enumClazz, entry.getValue().getClass()));	1✔
292	}	1✔
293	return newMap;	1✔
294	}
295	}
296	return null;	1✔
297	}
298
299	private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMapForSuperclass(Class<?> clazz) {
300	Class<?> superclass = clazz.getSuperclass();	1✔
301	if (superclass == null \|\| Object.class.equals(superclass)) {	1✔
302	return null;	1✔
303	}
304	Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = typeHandlerMap.get(superclass);	1✔
305	if (jdbcHandlerMap != null) {	1✔
306	return jdbcHandlerMap;	1✔
307	}
308	return getJdbcHandlerMapForSuperclass(superclass);	1✔
309	}
310
311	private TypeHandler<?> pickSoleHandler(Map<JdbcType, TypeHandler<?>> jdbcHandlerMap) {
312	TypeHandler<?> soleHandler = null;	1✔
313	for (TypeHandler<?> handler : jdbcHandlerMap.values()) {	1✔
314	if (soleHandler == null) {	1✔
315	soleHandler = handler;	1✔
316	} else if (!handler.getClass().equals(soleHandler.getClass())) {	1✔
317	// More than one type handlers registered.
318	return null;	1✔
319	}
320	}	1✔
321	return soleHandler;	1✔
322	}
323
324	public TypeHandler<Object> getUnknownTypeHandler() {
325	return unknownTypeHandler;	1✔
326	}
327
328	public void register(JdbcType jdbcType, TypeHandler<?> handler) {
329	jdbcTypeHandlerMap.put(jdbcType, handler);	1✔
330	}	1✔
331
332	//
333	// REGISTER INSTANCE
334	//
335
336	// Only handler
337
338	@SuppressWarnings("unchecked")
339	public <T> void register(TypeHandler<T> typeHandler) {
340	boolean mappedTypeFound = false;	1✔
341	MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);	1✔
342	if (mappedTypes != null) {	1✔
343	for (Class<?> handledType : mappedTypes.value()) {	×
344	register(handledType, typeHandler);	×
345	mappedTypeFound = true;	×
346	}
347	}
348	// @since 3.1.0 - try to auto-discover the mapped type
349	if (!mappedTypeFound && typeHandler instanceof TypeReference) {	1✔
350	try {
351	TypeReference<T> typeReference = (TypeReference<T>) typeHandler;	1✔
352	register(typeReference.getRawType(), typeHandler);	1✔
353	mappedTypeFound = true;	1✔
354	} catch (Throwable t) {	×
355	// maybe users define the TypeReference with a different type and are not assignable, so just ignore it
356	}	1✔
357	}
358	if (!mappedTypeFound) {	1✔
359	register((Class<T>) null, typeHandler);	1✔
360	}
361	}	1✔
362
363	// java type + handler
364
365	public <T> void register(Class<T> javaType, TypeHandler<? extends T> typeHandler) {
366	register((Type) javaType, typeHandler);	1✔
367	}	1✔
368
369	private <T> void register(Type javaType, TypeHandler<? extends T> typeHandler) {
370	MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);	1✔
371	if (mappedJdbcTypes != null) {	1✔
372	for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {	1✔
373	register(javaType, handledJdbcType, typeHandler);	1✔
374	}
375	if (mappedJdbcTypes.includeNullJdbcType()) {	1✔
376	register(javaType, null, typeHandler);	1✔
377	}
378	} else {
379	register(javaType, null, typeHandler);	1✔
380	}
381	}	1✔
382
383	public <T> void register(TypeReference<T> javaTypeReference, TypeHandler<? extends T> handler) {
384	register(javaTypeReference.getRawType(), handler);	1✔
385	}	1✔
386
387	// java type + jdbc type + handler
388
389	// Cast is required here
390	@SuppressWarnings("cast")
391	public <T> void register(Class<T> type, JdbcType jdbcType, TypeHandler<? extends T> handler) {
392	register((Type) type, jdbcType, handler);	1✔
393	}	1✔
394
395	private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
396	if (javaType != null) {	1✔
397	Map<JdbcType, TypeHandler<?>> map = typeHandlerMap.get(javaType);	1✔
398	if (map == null \|\| map == NULL_TYPE_HANDLER_MAP) {	1✔
399	map = new HashMap<>();	1✔
400	}
401	map.put(jdbcType, handler);	1✔
402	typeHandlerMap.put(javaType, map);	1✔
403	}
404	allTypeHandlersMap.put(handler.getClass(), handler);	1✔
405	}	1✔
406
407	//
408	// REGISTER CLASS
409	//
410
411	// Only handler type
412
413	public void register(Class<?> typeHandlerClass) {
414	boolean mappedTypeFound = false;	1✔
415	MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);	1✔
416	if (mappedTypes != null) {	1✔
417	for (Class<?> javaTypeClass : mappedTypes.value()) {	1✔
418	register(javaTypeClass, typeHandlerClass);	1✔
419	mappedTypeFound = true;	1✔
420	}
421	}
422	if (!mappedTypeFound) {	1✔
423	register(getInstance(null, typeHandlerClass));	1✔
424	}
425	}	1✔
426
427	// java type + handler type
428
429	public void register(String javaTypeClassName, String typeHandlerClassName) throws ClassNotFoundException {
430	register(Resources.classForName(javaTypeClassName), Resources.classForName(typeHandlerClassName));	×
431	}	×
432
433	public void register(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
434	register(javaTypeClass, getInstance(javaTypeClass, typeHandlerClass));	1✔
435	}	1✔
436
437	// java type + jdbc type + handler type
438
439	public void register(Class<?> javaTypeClass, JdbcType jdbcType, Class<?> typeHandlerClass) {
440	register(javaTypeClass, jdbcType, getInstance(javaTypeClass, typeHandlerClass));	1✔
441	}	1✔
442
443	// Construct a handler (used also from Builders)
444
445	@SuppressWarnings("unchecked")
446	public <T> TypeHandler<T> getInstance(Class<?> javaTypeClass, Class<?> typeHandlerClass) {
447	if (javaTypeClass != null) {	1✔
448	try {
449	Constructor<?> c = typeHandlerClass.getConstructor(Class.class);	1✔
450	return (TypeHandler<T>) c.newInstance(javaTypeClass);	1✔
451	} catch (NoSuchMethodException ignored) {	1✔
452	// ignored
453	} catch (Exception e) {	×
454	throw new TypeException("Failed invoking constructor for handler " + typeHandlerClass, e);	×
455	}	1✔
456	}
457	try {
458	Constructor<?> c = typeHandlerClass.getConstructor();	1✔
459	return (TypeHandler<T>) c.newInstance();	1✔
460	} catch (Exception e) {	×
461	throw new TypeException("Unable to find a usable constructor for " + typeHandlerClass, e);	×
462	}
463	}
464
465	// scan
466
467	public void register(String packageName) {
468	ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();	1✔
469	resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);	1✔
470	Set<Class<? extends Class<?>>> handlerSet = resolverUtil.getClasses();	1✔
471	for (Class<?> type : handlerSet) {	1✔
472	// Ignore inner classes and interfaces (including package-info.java) and abstract classes
473	if (!type.isAnonymousClass() && !type.isInterface() && !Modifier.isAbstract(type.getModifiers())) {	1✔
474	register(type);	1✔
475	}
476	}	1✔
477	}	1✔
478
479	// get information
480
481	/**
482	* Gets the type handlers.
483	*
484	* @return the type handlers
485	*
486	* @since 3.2.2
487	*/
488	public Collection<TypeHandler<?>> getTypeHandlers() {
489	return Collections.unmodifiableCollection(allTypeHandlersMap.values());	×
490	}
491
492	}

mybatis / mybatis-3 / #3198

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous