> Java > java지도 시간 > Mybatis 시리즈 심층 소개(5)---TypeHandler 소개 및 구성(mybatis 소스 코드)

Mybatis 시리즈 심층 소개(5)---TypeHandler 소개 및 구성(mybatis 소스 코드)

黄舟
풀어 주다: 2017-03-02 10:48:09
원래의
1864명이 탐색했습니다.

이전 기사 "Mybatis 시리즈 심층 소개(4)---typeAliases 별칭 세부 구성(mybatis 소스 코드)"에서는 mybatis 및 해당 소스 코드의 별칭 사용에 대해 소개했습니다. 이 기사에서는 TypeHandler를 소개하고 해당 소스 코드를 간략하게 분석합니다.

Mybatis의 TypeHandler란 무엇인가요?

 MyBatis가 준비된 명령문(PreparedStatement)에서 매개변수를 설정하거나 결과 세트에서 값을 검색하는 경우, 획득된 값을 적절한 방식으로 Java로 변환하기 위해 유형 프로세서가 사용됩니다. Mybatis는 기본적으로 많은 TypeHandler를 구현합니다. 지정된 TypeHandler를 구성하지 않으면 Mybatis는 기본적으로 매개 변수 또는 반환 결과에 따라 적절한 TypeHandler를 선택합니다.

그렇다면 Mybatis는 어떤 TypeHandler를 구현했습니까? TypeHandler를 어떻게 사용자 정의합니까? 이것들은 다음 mybatis의 소스 코드에서 볼 수 있습니다.

소스코드를 보기에 앞서, 아까와 같이 어떻게 구성하는지 살펴볼까요?

TypeHandler 구성:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

<configuration>

    <typeHandlers>

      <!--

          当配置package的时候,mybatis会去配置的package扫描TypeHandler

          <package name="com.dy.demo"/>       -->

       

      <!-- handler属性直接配置我们要指定的TypeHandler -->

      <typeHandler handler=""/>

       

      <!-- javaType 配置java类型,例如String, 如果配上javaType, 那么指定的typeHandler就只作用于指定的类型 -->

      <typeHandler javaType="" handler=""/>

       

      <!-- jdbcType 配置数据库基本数据类型,例如varchar, 如果配上jdbcType, 那么指定的typeHandler就只作用于指定的类型  -->

      <typeHandler jdbcType="" handler=""/>

       

      <!-- 也可两者都配置 -->

      <typeHandler javaType="" jdbcType="" handler=""/>

       

  </typeHandlers>

   

  ......  

</configuration>

로그인 후 복사

위에서는 TypeHandler를 간략하게 소개합니다. 이제 mybatis의 TypeHandler 소스 코드를 살펴보겠습니다.


================================== = =====================나는 소스 코드 구분선입니다===================== === ===================================

오래된 규칙으로 시작하세요. parsing of xml 대화 내용:


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

/**

 * 解析typeHandlers节点 */private void typeHandlerElement(XNode parent) throws Exception {    if (parent != null) {      for (XNode child : parent.getChildren()) {        //子节点为package时,获取其name属性的值,然后自动扫描package下的自定义typeHandler

        if ("package".equals(child.getName())) {

          String typeHandlerPackage = child.getStringAttribute("name");

          typeHandlerRegistry.register(typeHandlerPackage);

        else {          //子节点为typeHandler时, 可以指定javaType属性, 也可以指定jdbcType, 也可两者都指定          //javaType 是指定java类型          //jdbcType 是指定jdbc类型(数据库类型: 如varchar)

          String javaTypeName = child.getStringAttribute("javaType");

          String jdbcTypeName = child.getStringAttribute("jdbcType");          //handler就是我们配置的typeHandler

          String handlerTypeName = child.getStringAttribute("handler");          //resolveClass方法就是我们上篇文章所讲的TypeAliasRegistry里面处理别名的方法

          Class<?> javaTypeClass = resolveClass(javaTypeName);          //JdbcType是一个枚举类型,resolveJdbcType方法是在获取枚举类型的值

          JdbcType jdbcType = resolveJdbcType(jdbcTypeName);

          Class<?> typeHandlerClass = resolveClass(handlerTypeName);          //注册typeHandler, typeHandler通过TypeHandlerRegistry这个类管理

          if (javaTypeClass != null) {            if (jdbcType == null) {

              typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);

            else {

              typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);

            }

          else {

            typeHandlerRegistry.register(typeHandlerClass);

          }

        }

      }

    }

}

로그인 후 복사


다음으로 TypeHandler의 관리 등록 클래스를 살펴보겠습니다.

TypeHandlerRegistry :

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

/**

 * typeHandler注册管理类 */public final class TypeHandlerRegistry {  

 //源码一上来,二话不说,几个大大的HashMap就出现,这不又跟上次讲的typeAliases的注册类似么  

 //基本数据类型与其包装类

  private static final Map<Class<?>, Class<?>> reversePrimitiveMap = new HashMap<Class<?>, Class<?>>() {    private static final long serialVersionUID = 1L;

    {

      put(Byte.classbyte.class);

      put(Short.classshort.class);

      put(Integer.classint.class);

      put(Long.classlong.class);

      put(Float.classfloat.class);

      put(Double.classdouble.class);

      put(Boolean.classboolean.class);

      put(Character.classchar.class);

    }

  };  //这几个MAP不用说就知道存的是什么东西吧,命名的好处

  private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap<JdbcType, TypeHandler<?>>(JdbcType.class);  private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new HashMap<Type, Map<JdbcType, TypeHandler<?>>>();  private final TypeHandler<Object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this);  private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = new HashMap<Class<?>, TypeHandler<?>>();  //就像上篇文章讲的typeAliases一样,mybatis也默认给我们注册了不少的typeHandler  //具体如下

  public TypeHandlerRegistry() {

    register(Boolean.classnew BooleanTypeHandler());

    register(boolean.classnew BooleanTypeHandler());

    register(JdbcType.BOOLEAN, new BooleanTypeHandler());

    register(JdbcType.BIT, new BooleanTypeHandler());

 

    register(Byte.classnew ByteTypeHandler());

    register(byte.classnew ByteTypeHandler());

    register(JdbcType.TINYINT, new ByteTypeHandler());

 

    register(Short.classnew ShortTypeHandler());

    register(short.classnew ShortTypeHandler());

    register(JdbcType.SMALLINT, new ShortTypeHandler());

 

    register(Integer.classnew IntegerTypeHandler());

    register(int.classnew IntegerTypeHandler());

    register(JdbcType.INTEGER, new IntegerTypeHandler());

 

    register(Long.classnew LongTypeHandler());

    register(long.classnew LongTypeHandler());

 

    register(Float.classnew FloatTypeHandler());

    register(float.classnew FloatTypeHandler());

    register(JdbcType.FLOAT, new FloatTypeHandler());

 

    register(Double.classnew DoubleTypeHandler());

    register(double.classnew DoubleTypeHandler());

    register(JdbcType.DOUBLE, new DoubleTypeHandler());

 

    register(String.classnew 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 ClobTypeHandler());

    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 ClobTypeHandler());

    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.classnew BigIntegerTypeHandler());

    register(JdbcType.BIGINT, new LongTypeHandler());

 

    register(BigDecimal.classnew BigDecimalTypeHandler());

    register(JdbcType.REAL, new BigDecimalTypeHandler());

    register(JdbcType.DECIMAL, new BigDecimalTypeHandler());

    register(JdbcType.NUMERIC, new BigDecimalTypeHandler());

 

    register(Byte[].classnew ByteObjectArrayTypeHandler());

    register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());

    register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());

    register(byte[].classnew 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, UNKNOWN_TYPE_HANDLER);

    register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);

    register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);

 

    register(Date.classnew 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.classnew SqlDateTypeHandler());

    register(java.sql.Time.classnew SqlTimeTypeHandler());

    register(java.sql.Timestamp.classnew SqlTimestampTypeHandler());    // issue #273

    register(Character.classnew CharacterTypeHandler());

    register(char.classnew CharacterTypeHandler());

  }  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 ALL_TYPE_HANDLERS_MAP.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 JDBC_TYPE_HANDLER_MAP.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);

  }  private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {

    Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);

    TypeHandler<?> handler = null;    if (jdbcHandlerMap != null) {

      handler = jdbcHandlerMap.get(jdbcType);      if (handler == null) {

        handler = jdbcHandlerMap.get(null);

      }

    }    if (handler == null && type != null && type instanceof Class && Enum.class.isAssignableFrom((Class<?>) type)) {

      handler = new EnumTypeHandler((Class<?>) type);

    }

    @SuppressWarnings("unchecked")    // type drives generics here

    TypeHandler<T> returned = (TypeHandler<T>) handler;    return returned;

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

  }  public void register(JdbcType jdbcType, TypeHandler<?> handler) {

    JDBC_TYPE_HANDLER_MAP.put(jdbcType, handler);

  }  //

  // REGISTER INSTANCE  

  //

  /**

   * 只配置了typeHandler, 没有配置jdbcType 或者javaType   

   */

  @SuppressWarnings("unchecked")  public <T> void register(TypeHandler<T> typeHandler) {    

  boolean mappedTypeFound = false;    

  //在自定义typeHandler的时候,可以加上注解MappedTypes 去指定关联的javaType    

  //因此,此处需要扫描MappedTypes注解

    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);

    }

  }  /**

   * 配置了typeHandlerhe和javaType   */

  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 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);

  }  /**

   * typeHandlerhe、javaType、jdbcType都配置了   */

  public <T> void register(Class<T> type, JdbcType jdbcType, TypeHandler<? extends T> handler) {

    register((Type) type, jdbcType, handler);

  }  /**

   * 注册typeHandler的核心方法

   * 就是向Map新增数据而已   */

  private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {    

  if (javaType != null) {

      Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);      

      if (map == null) {

        map = new HashMap<JdbcType, TypeHandler<?>>();

        TYPE_HANDLER_MAP.put(javaType, map);

      }

      map.put(jdbcType, handler);      

      if (reversePrimitiveMap.containsKey(javaType)) {

        register(reversePrimitiveMap.get(javaType), jdbcType, handler);

      }

    }

    ALL_TYPE_HANDLERS_MAP.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(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);

    }

  

  /**

   * 根据指定的pacakge去扫描自定义的typeHander,然后注册   */

  public void register(String packageName) {

    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();

    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

   

  /**

   * 通过configuration对象可以获取已注册的所有typeHandler   */

  public Collection<TypeHandler<?>> getTypeHandlers() {    

  return Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());

  }

   

}

로그인 후 복사


소스 코드에서 볼 수 있듯이 mybatis는 우리를 위해 수많은 TypeHandler를 구현했습니다. TypeHandler를 열고 해당 소스 코드를 보면 알 수 있습니다. 그러면 BaseTypeHandler를 상속하여 사용자 정의 TypeHandler를 구현할 수도 있습니까? 대답은 '예'입니다. 이제 사용자 정의 TypeHandler를 보여드리겠습니다.

= === ============================================== =TypeHandler 정의 이후 구분선 ============================================ ==== ==============

ExampleTypeHandler:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

@MappedJdbcTypes(JdbcType.VARCHAR)  

//此处如果不用注解指定jdbcType, 那么,就可以在配置文件中通过"jdbcType"属性指定, 同理, javaType 也可通过 @MappedTypes指定public class ExampleTypeHandler extends BaseTypeHandler<String> {

 

  @Override  public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {

    ps.setString(i, parameter);

  }

 

  @Override  public String getNullableResult(ResultSet rs, String columnName) throws SQLException {    return rs.getString(columnName);

  }

 

  @Override  public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {    return rs.getString(columnIndex);

  }

 

  @Override  public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {    return cs.getString(columnIndex);

  }

}

로그인 후 복사


그런 다음 사용자 정의를 구성할 시간입니다. TypeHandler:


1

2

3

4

5

6

7

8

<configuration>

  <typeHandlers>

      <!-- 由于自定义的TypeHandler在定义时已经通过注解指定了jdbcType, 所以此处不用再配置jdbcType -->

      <typeHandler handler="ExampleTypeHandler"/>

  </typeHandlers>

   

  ......  

</configuration>

로그인 후 복사


즉, TypeHandler를 맞춤설정할 때 는 TypeHandler의 @MappedJdbcTypes를 통해 @로 jdbcType을 지정할 수 있습니다. MappedTypes는 javaType을 지정합니다. 주석을 사용하여 지정하지 않은 경우 구성 파일에서 이를 구성해야 합니다.

자, 이번 글은 여기서 마치겠습니다.

위는 Mybatis 시리즈에 대한 심층적인 소개입니다(5)---TypeHandler 소개 및 구성(mybatis 소스코드). 더 많은 관련 내용은 PHP 중국어 홈페이지(www. php.cn)!


본 웹사이트의 성명
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
인기 튜토리얼
더>
최신 다운로드
더>
웹 효과
웹사이트 소스 코드
웹사이트 자료
프론트엔드 템플릿