彬_708c
彬_708c

Mybatis-TypeHandler源码解析

Mybatis3.5.1源码分析

  1. Mybatis-SqlSessionFactoryBuilder，XMLConfigBuilder，XPathParser源码解析
  2. Mybatis-Configuration源码解析
  3. Mybatis-事务对象源码解析
  4. Mybatis-数据源源码解析
  5. Mybatis缓存策略源码解析
  6. Mybatis-DatabaseIdProvider源码解析
  7. Mybatis-TypeHandler源码解析
  8. Mybatis-Reflector源码解析
  9. Mybatis-ObjectFactory，ObjectWrapperFactory源码分析
  10. Mybatis-Mapper各类标签封装类源码解析
  11. Mybatis-XMLMapperBuilder,XMLStatmentBuilder源码分析
  12. Mybatis-MapperAnnotationBuilder源码分析
  13. [Mybatis-MetaObject,MetaClass源码解析]https://www.jianshu.com/p/f51fa552f30a)
  14. Mybatis-LanguageDriver源码解析
  15. Mybatis-SqlSource源码解析
  16. Mybatis-SqlNode源码解析
  17. Mybatis-KeyGenerator源码解析
  18. Mybatis-Executor源码解析
  19. Mybatis-ParameterHandler源码解析
  20. Mybatis-StatementHandler源码解析
  21. Mybatis-DefaultResultSetHandler(一)源码解析
  22. Mybatis-DefaultResultSetHandler(二)源码解析
  23. Mybatis-ResultHandler,Cursor,RowBounds 源码分析
  24. Mybatis-MapperProxy源码解析
  25. Mybatis-SqlSession源码解析
  26. Mybatis-Interceptor源码解析

TypeHandler

/**
 *    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.
 *    You may obtain a copy of the License at
 *
 *       http://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.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 类型处理器
 * 

 *     无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，
 *     都会用类型处理器将获取的值以合适的方式转换成 Java 类型
 * 

 *
 * @author Clinton Begin
 */
public interface TypeHandler {

  /**
   * 把 java 对象设置到 PreparedStatement 的参数中
   * @param i 从1开始
   */
  void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  /**
   * 从 ResultSet 中取出columnName对应数据，然后转换为 java 对象
   * @param columnName Colunm name, when configuration useColumnLabel is false
   */
  T getResult(ResultSet rs, String columnName) throws SQLException;

  /**
   * 用于从 ResultSet 或 CallableStatement 中取出数据转换为 java 对象
   */
  T getResult(ResultSet rs, int columnIndex) throws SQLException;

  /**
   * 用于从 ResultSet 或 CallableStatement 中取出数据转换为 java 对象
   */
  T getResult(CallableStatement cs, int columnIndex) throws SQLException;

}

BaseTypeHandler

/**
 *    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.
 *    You may obtain a copy of the License at
 *
 *       http://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.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.apache.ibatis.executor.result.ResultMapException;
import org.apache.ibatis.session.Configuration;

/**
 * The base {@link TypeHandler} for references a generic type.
 * 一个基本的{@link TypeHandler}引用了一个泛型类型
 * 

 * Important: Since 3.5.0, This class never call the {@link ResultSet#wasNull()} and
 * {@link CallableStatement#wasNull()} method for handling the SQL {@code NULL} value.
 * In other words, {@code null} value handling should be performed on subclass.
 * 

 * 

 *     重点声明：自从3.5.0后，这个类不会再调用{@link ResultSet#wasNull()}和{@link CallableStatement#wasNull()}
 *     方法去处理null值的,换句话说，null值应该交给子类处理。
 * 

 * @author Clinton Begin
 * @author Simone Tripodi
 * @author Kzuki Shimizu
 */
public abstract class BaseTypeHandler extends TypeReference implements TypeHandler {

  /**
   * @deprecated Since 3.5.0 - See https://github.com/mybatis/mybatis-3/issues/1203. This field will remove future.
   */
  @Deprecated
  protected Configuration configuration;

  /**
   * @deprecated Since 3.5.0 - See https://github.com/mybatis/mybatis-3/issues/1203. This property will remove future.
   */
  @Deprecated
  public void setConfiguration(Configuration c) {
    this.configuration = c;
  }

  /**
   *  把 java 对象设置到 PreparedStatement 的参数中
   *  

   *      解决 {@link @paramter} ,{@link @jdbcType} 的情况。
   *  

   *  
    
   *      
  1. {@link @jdbcType}为null,抛出 {@link TypeException}，也就是说{@link @jdbcType}调用这个方法的时候就已经确定了
    2. 
   *      
  2. {@link @parameter}为null时，对第{@link @i}个'?'设置null值;否则，
   *      调用抽象方法{@link BaseTypeHandler#setNonNullParameter(PreparedStatement, int, Object, JdbcType)}
    3. 
   *  

   */
  @Override
  public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
    if (parameter == null) {
      //一般情况下，jdbcType到这个方法时就已经确定了jdbcType.TYPE_CODE，
      if (jdbcType == null) {
        throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");
      }
      try {
        //设置null值。
        ps.setNull(i, jdbcType.TYPE_CODE);
      } catch (SQLException e) {
        throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . "
              + "Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. "
              + "Cause: " + e, e);
      }
    } else {
      try {
        setNonNullParameter(ps, i, parameter, jdbcType);
      } catch (Exception e) {
        throw new TypeException("Error setting non null for parameter #" + i + " with JdbcType " + jdbcType + " . "
              + "Try setting a different JdbcType for this parameter or a different configuration property. "
              + "Cause: " + e, e);
      }
    }
  }

  /**
   * 用于从 ResultSet 或 CallableStatement 中取出数据转换为 java 对象
   * 

   *     直接调用{@link BaseTypeHandler#getNullableResult(ResultSet, String)}
   * 

   */
  @Override
  public T getResult(ResultSet rs, String columnName) throws SQLException {
    try {
      return getNullableResult(rs, columnName);
    } catch (Exception e) {
      throw new ResultMapException("Error attempting to get column '" + columnName + "' from result set.  Cause: " + e, e);
    }
  }

  /**
   * 用于从 ResultSet 或 CallableStatement 中取出数据转换为 java 对象
   * 

   *     直接调用{@link BaseTypeHandler#getNullableResult(ResultSet, int)}
   * 

   */
  @Override
  public T getResult(ResultSet rs, int columnIndex) throws SQLException {
    try {
      return getNullableResult(rs, columnIndex);
    } catch (Exception e) {
      throw new ResultMapException("Error attempting to get column #" + columnIndex + " from result set.  Cause: " + e, e);
    }
  }

  /**
   * 用于从 ResultSet 或 CallableStatement 中取出数据转换为 java 对象
   * 

   *     直接调用{@link BaseTypeHandler#getNullableResult(CallableStatement, int)}
   * 

   */
  @Override
  public T getResult(CallableStatement cs, int columnIndex) throws SQLException {
    try {
      return getNullableResult(cs, columnIndex);
    } catch (Exception e) {
      throw new ResultMapException("Error attempting to get column #" + columnIndex + " from callable statement.  Cause: " + e, e);
    }
  }

  /**
   * 设置不为空的参数
   */
  public abstract void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  /**
   * 获取可空的结果
   * @param columnName Colunm name, when configuration useColumnLabel is false
   */
  public abstract T getNullableResult(ResultSet rs, String columnName) throws SQLException;

  /**
   * 获取可空的结果
   */
  public abstract T getNullableResult(ResultSet rs, int columnIndex) throws SQLException;

  /**
   * 获取可空的结果
   */
  public abstract T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException;

}

ObjectTypeHandler

/**
 *    Copyright 2009-2015 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
 *
 *       http://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.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * Object 类型处理器
 * @author Clinton Begin
 */
public class ObjectTypeHandler extends BaseTypeHandler {

  /**
   * 直接调用 {@link PreparedStatement#setObject(int, Object)}
   */
  @Override
  public void setNonNullParameter(PreparedStatement ps, int i, Object parameter, JdbcType jdbcType)
      throws SQLException {
    ps.setObject(i, parameter);
  }

  /**
   * 直接调用 {@link ResultSet#getObject(String)}
   */
  @Override
  public Object getNullableResult(ResultSet rs, String columnName)
      throws SQLException {
    return rs.getObject(columnName);
  }

  /**
   * 直接调用 {@link ResultSet#getObject(int)}
   */
  @Override
  public Object getNullableResult(ResultSet rs, int columnIndex)
      throws SQLException {
    return rs.getObject(columnIndex);
  }

  /**
   * 直接调用 {@link CallableStatement#getObject(int)}
   */
  @Override
  public Object getNullableResult(CallableStatement cs, int columnIndex)
      throws SQLException {
    return cs.getObject(columnIndex);
  }
}

 
 
UnknowTypeHandler
 
 
/**
 *    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.
 *    You may obtain a copy of the License at
 *
 *       http://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.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

import org.apache.ibatis.io.Resources;

/**
 * 未知类型处理器
 * 
在{@link BaseTypeHandler}的抽象方法中根据返回的结果集提供的列去获取对应的TypeHandler时候，
 *    在获取不到的情况下，就会使用{@link ObjectTypeHandler}处理

 * @author Clinton Begin
 */
public class UnknownTypeHandler extends BaseTypeHandler {

  private static final ObjectTypeHandler OBJECT_TYPE_HANDLER = new ObjectTypeHandler();

  private TypeHandlerRegistry typeHandlerRegistry;

  public UnknownTypeHandler(TypeHandlerRegistry typeHandlerRegistry) {
    this.typeHandlerRegistry = typeHandlerRegistry;
  }

  @Override
  public void setNonNullParameter(PreparedStatement ps, int i, Object parameter, JdbcType jdbcType)
      throws SQLException {
    TypeHandler handler = resolveTypeHandler(parameter, jdbcType);
    handler.setParameter(ps, i, parameter, jdbcType);
  }

  @Override
  public Object getNullableResult(ResultSet rs, String columnName)
      throws SQLException {
    TypeHandler handler = resolveTypeHandler(rs, columnName);
    return handler.getResult(rs, columnName);
  }

  @Override
  public Object getNullableResult(ResultSet rs, int columnIndex)
      throws SQLException {
    TypeHandler handler = resolveTypeHandler(rs.getMetaData(), columnIndex);
    if (handler == null || handler instanceof UnknownTypeHandler) {
      handler = OBJECT_TYPE_HANDLER;
    }
    return handler.getResult(rs, columnIndex);
  }

  @Override
  public Object getNullableResult(CallableStatement cs, int columnIndex)
      throws SQLException {
    return cs.getObject(columnIndex);
  }

  /**
   * 解析获取类型处理器
   * 
根据 {@code parameter} 和 {@code jdbcType} 获取typeHandler实例

   * @return {@code parameter} 为null 或者
   *    获取不了对应{@code parameter} 和 {@code jdbcType} 的typeHanlder实例
   *    或者为typeHandler实例都为{@link UnknownTypeHandler}的实例的话，都会返回{@link #OBJECT_TYPE_HANDLER}
   */
  private TypeHandler resolveTypeHandler(Object parameter, JdbcType jdbcType) {
    TypeHandler handler;
    if (parameter == null) {
      handler = OBJECT_TYPE_HANDLER;
    } else {
      //获取typeHandler实例
      handler = typeHandlerRegistry.getTypeHandler(parameter.getClass(), jdbcType);
      // check if handler is null (issue #270)
      if (handler == null || handler instanceof UnknownTypeHandler) {
        handler = OBJECT_TYPE_HANDLER;
      }
    }
    return handler;
  }

  /**
   * 解析获取TypeHandler实例
   * 

   *     通过{@code rs}拿到结果集的描述信息{@link ResultSetMetaData}，根据描述信息去拿到列名对应的
   *     位置，再调用{@link #resolveTypeHandler(ResultSetMetaData, Integer)}获取对应的TypeHandler实例。
   * 

   * @param rs 结果集
   * @param column 列名
   * @return {@link TypeHandler} 实例；
   *    当 {@code handler} 为null或者 {@code handler} 为 {@link UnknownTypeHandler} 就会返回 {@link #OBJECT_TYPE_HANDLER}
   */
  private TypeHandler resolveTypeHandler(ResultSet rs, String column) {
    try {
      //将所有列的列名，对应的位置都拿出来放到columnIndexLookup中
      Map columnIndexLookup;
      columnIndexLookup = new HashMap<>();
      ResultSetMetaData rsmd = rs.getMetaData();
      int count = rsmd.getColumnCount();
      for (int i = 1; i <= count; i++) {
        String name = rsmd.getColumnName(i);
        columnIndexLookup.put(name,i);
      }
      //拿到column对应的位置
      Integer columnIndex = columnIndexLookup.get(column);
      TypeHandler handler = null;
      if (columnIndex != null) {
        handler = resolveTypeHandler(rsmd, columnIndex);
      }
      if (handler == null || handler instanceof UnknownTypeHandler) {
        handler = OBJECT_TYPE_HANDLER;
      }
      return handler;
    } catch (SQLException e) {
      throw new TypeException("Error determining JDBC type for column " + column + ".  Cause: " + e, e);
    }
  }

  /**
   * 解析获取TypeHandler实例
   * @param rsmd 结果集描述信息
   * @param columnIndex 指定的列位置
   * @return TypeHandler实例
   */
  private TypeHandler resolveTypeHandler(ResultSetMetaData rsmd, Integer columnIndex) {
    TypeHandler handler = null;
    //从columnIndex中获取jdbcType，不会抛出异常，但是会返回null
    JdbcType jdbcType = safeGetJdbcTypeForColumn(rsmd, columnIndex);
    //从columnIndex中获取javaType，不会抛出异常，但是会返回null
    Class javaType = safeGetClassForColumn(rsmd, columnIndex);
    //根据现有的条件，尽可能的找到对应的typeHandler实例
    if (javaType != null && jdbcType != null) {
      handler = typeHandlerRegistry.getTypeHandler(javaType, jdbcType);
    } else if (javaType != null) {
      handler = typeHandlerRegistry.getTypeHandler(javaType);
    } else if (jdbcType != null) {
      handler = typeHandlerRegistry.getTypeHandler(jdbcType);
    }
    return handler;
  }

  /**
   * 安全的从列中拿到jdbcType,这里的安全应该是指捕捉的所有获取过程中抛出的异常。
   * @param rsmd 结果集的描述信息
   * @param columnIndex 指定的列位置
   * @return {@link JdbcType}，在获取过程中抛出异常会返回 {@code null}
   */
  private JdbcType safeGetJdbcTypeForColumn(ResultSetMetaData rsmd, Integer columnIndex) {
    try {
      return JdbcType.forCode(rsmd.getColumnType(columnIndex));
    } catch (Exception e) {
      return null;
    }
  }

  /**
   * 安全的从列中拿到javaType，这里的安全应该是指捕捉的所有获取过程中抛出的异常。
   * @param rsmd 结果集的描述信息
   * @param columnIndex 指定的列位置
   * @return {@link Class}，在获取过程中抛出异常会返回 {@code null}
   */
  private Class safeGetClassForColumn(ResultSetMetaData rsmd, Integer columnIndex) {
    try {
      return Resources.classForName(rsmd.getColumnClassName(columnIndex));
    } catch (Exception e) {
      return null;
    }
  }
}

 
 
TypeHandlerRegistry
 
 
/**
 *    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.
 *    You may obtain a copy of the License at
 *
 *       http://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;

/**
 * 类型处理注册器
 *
 * 

 * 参考博客:
 * 
    
 *     
  1. https://www.jianshu.com/p/93f6205fb0ba
    2. 
 *     
  2. https://www.jianshu.com/p/44d01981d698
    3. 
 * 

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

  /**
   * 枚举类JdbcType作为键，完成数据库类型与类型处理器的对应注册
   */
  private final Map>  jdbcTypeHandlerMap = new EnumMap<>(JdbcType.class);

  /**
   * Java类型作为键，JdbcType与TypeHandler的映射关系作为value，完成Java类型、数据库类型和类型处理器三者的对应注册
   */
  private final Map>> typeHandlerMap = new ConcurrentHashMap<>();

  /**
   * 对未知类型的注册，如Object
   * 其实还是在{@link BaseTypeHandler}的抽象方法中根据返回的结果集提供的列去获取对应的TypeHandler时候，
   * 在获取不到的情况下，就会使用{@link ObjectTypeHandler}处理
   */
  private final TypeHandler unknownTypeHandler = new UnknownTypeHandler(this);

  /**
   * 保存着所有的类型处理器实例，是以类型处理器的类类型为键值保存的，它可以统筹所有的类型处理器实例
   */
  private final Map, TypeHandler> allTypeHandlersMap = new HashMap<>();

  /**
   * 空TypeHandler集合的标识
   */
  private static final Map> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();

  /**
   * 默认的枚举类型
   */
  private Class defaultEnumTypeHandler = EnumTypeHandler.class;

  /**
   * 注册一些基本的，常用的TypeHandler
   */
  public TypeHandlerRegistry() {
    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}.
   * 

   *     为枚举类{@link Enum}设置默认的{@link TypeHandler}.默认是{@link EnumTypeHandler}
   * 

   * @param typeHandler a type handler class for {@link Enum}
   * @since 3.4.5
   */
  public void setDefaultEnumTypeHandler(Class typeHandler) {
    this.defaultEnumTypeHandler = typeHandler;
  }

  /**
   * 是否存在对应 {@link @javaType} 的 {@link TypeHandler},直接调用{@link #hasTypeHandler(Class, JdbcType)}
   */
  public boolean hasTypeHandler(Class javaType) {
    return hasTypeHandler(javaType, null);
  }

  /**
   * 是否存在对应{@link @javaTypeReference}的{@link TypeHandler},直接调用{@link #hasTypeHandler(TypeReference, JdbcType)},
   * 第二个参数{@link @jdbcType}为null
   */
  public boolean hasTypeHandler(TypeReference javaTypeReference) {
    return hasTypeHandler(javaTypeReference, null);
  }

  /**
   * 是否存在对应 {@link @javaType} 和 {@link @jdbcType} 的 {@link TypeHandler}
   * 

   *     先判断{@link @javaType} 是否为null，若为null，直接返回false。
   *      再尝试调用{@link #getTypeHandler(Type, JdbcType)}获取TypeHandler不为null返回true
   * 

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

  /**
   * 是否存在对应 {@link @javaTypeReference} 和 {@link @jdbcType} 的 {@link TypeHandler}
   * 

   *     先判断{@link @javaTypeReference} 是否为null，若为null，直接返回false。
   *      再尝试调用{@link #getTypeHandler(TypeReference, JdbcType)}获取TypeHandler不为null返回true
   * 

   */
  public boolean hasTypeHandler(TypeReference javaTypeReference, JdbcType jdbcType) {
    return javaTypeReference != null && getTypeHandler(javaTypeReference, jdbcType) != null;
  }

  /**
   * 获取TypeHandler实例
   * 

   *     从{@link #allTypeHandlersMap} 中获取对应{@link @handlerType}的{@link @handlerType}实例
   * 

   */
  public TypeHandler getMappingTypeHandler(Class> handlerType) {
    return allTypeHandlersMap.get(handlerType);
  }

  /**
   * 获取TypeHandler实例
   * 

   *     将{@link @type}强转为{@link Type},然后调用{@link #getTypeHandler(Type, JdbcType)},第二个参数{@link @jdbcType}设置成null
   * 

   */
  public  TypeHandler getTypeHandler(Class type) {
    return getTypeHandler((Type) type, null);
  }

  /**
   * 获取TypeHandler实例
   * 

   *     直接调用{@link #getTypeHandler(TypeReference, JdbcType)},第二个参数{@link @jdbcType}设置成null
   * 

   */
  public  TypeHandler getTypeHandler(TypeReference javaTypeReference) {
    return getTypeHandler(javaTypeReference, null);
  }

  /**
   * 获取TypeHandler实例
   * 

   *     从{@link #jdbcTypeHandlerMap}中获取对应{@link @jdbcType}
   * 

   */
  public TypeHandler getTypeHandler(JdbcType jdbcType) {
    return jdbcTypeHandlerMap.get(jdbcType);
  }

  /**
   * 获取 TypeHandler
   * 

   *     将 {@link @type} 转换 {@link Type} 类型，然后调用 {@link TypeHandlerRegistry#getTypeHandler(Class, JdbcType)}
   * 

   */
  public  TypeHandler getTypeHandler(Class type, JdbcType jdbcType) {
    return getTypeHandler((Type) type, jdbcType);
  }

  /**
   * 获取 TypeHandler
   * 

   *     调用{@link @javaTypeReference}的{@link TypeReference#getRawType()}得到子类声明的对 T 泛型的声明的类型，
   *     然后传给{@link #getTypeHandler(Type, JdbcType)}得到对应的TypeHandler
   * 

   */
  public  TypeHandler getTypeHandler(TypeReference javaTypeReference, JdbcType jdbcType) {
    return getTypeHandler(javaTypeReference.getRawType(), jdbcType);
  }

  /**
   * 根据 {@link @type} 和 {@link @jdbcType} 获取对应的 {@link TypeHandler}
   * 
    
   *     
  1. 如果{@link @type}是{@link ParamMap}会直接返回null
    2. 
   *     
  2. 通过{@link #getJdbcHandlerMap(Type)}获取dbcType、TypeHandler映射关系的map并赋值给{@link @jdbcHandlerMap}
    3. 
   *     
  3. 传入{@link @jdbcType}到{@link @jdbcHandlerMap}中获取对应的TypeHandler并赋值给{@link @handler}
    4. 
   *     
  4. 如果{@link @handler}为null,就是没有拿到对应的TypeHandler,就会从{@link @jdbcHandlerMap}取出对应'null'的TypeHandler
    5. 
   *     
  5. 如果{@link @handler}还为null，将{@link @jdbcHandlerMap}传入{@link #pickSoleHandler(Map)}，由Mybatis自己选择一个TypeHandler
    6. 
   *     
  6. 如果{@link @handler}还为null，就等于没救了，返回null
    7. 
   * 

   */
  @SuppressWarnings("unchecked")
  private  TypeHandler getTypeHandler(Type type, JdbcType jdbcType) {
    //{@link ParamMap)是一个HashMap的子类,它重写了get方法，使得如果尝试获取它没有的key，将会抛出{@link BindingException}
    if (ParamMap.class.equals(type)) {
      return null;
    }
    //获取JdbcType、TypeHandler映射关系的map
    Map> jdbcHandlerMap = getJdbcHandlerMap(type);
    TypeHandler handler = null;
    if (jdbcHandlerMap != null) {
      handler = jdbcHandlerMap.get(jdbcType);//获取对应jdbcType的TypeHandler
      //如果没有拿到，调用获取jdbcType为null值情况的TypeHandler
      if (handler == null) {
        handler = jdbcHandlerMap.get(null);
      }
      /**
       * 还是没有拿到，就由Mybatis自己选择一个TypeHandler：
       *     如果有多个不同类型的TypeHandler就无法选择TypeHandler,只能返回null;
       *     但是如果只有一个类型的TypeHandler,但有多个同类型的TypeHandler实例，就取最后一个实例
       */
      if (handler == null) {
        // #591
        handler = pickSoleHandler(jdbcHandlerMap);
      }
    }
    // type drives generics here
    //就算handler=null，也不会抛出空指针或者转换异常
    return (TypeHandler) handler;
  }

  /**
   * 获取JdbcType、TypeHandler映射关系的map
   * 

   *     先将{@link @type}传入从{@link #typeHandlerMap}中获取JdbcType、TypeHandler映射关系的map。如果找到就返回出去。
   *     如果没有获取到，判断是不是枚举类，还是普通java类。
   *
   * 

   * 

   *     枚举类：
   *     
    
   *         
  1. 调用{@link #getJdbcHandlerMapForEnumInterfaces(Class, Class)} 遍历枚举类的接口获取第一个对应
   *            {@link @type}的JdbcType、TypeHandler映射关系的map
    2. 
   *         
  2. 若还是找不到，就构建{@link #defaultEnumTypeHandler}的实例，作为{@link @clazz}
   *              对应的JdbcType、TypeHandler映射关系的map设置到{@link #typeHandlerMap}，
   *              然后重新到{@link #typeHandlerMap}返回出去，其实返回出去的按理来说就是{@link #defaultEnumTypeHandler}的实例
    3. 
   *         
  3. 找到就设置到{@link #typeHandlerMap}中，并返回对应的JdbcType、TypeHandler映射关系的map
    4. 
   *     

   * 

   * 

   *     普通java类：
   *     
    
   *        
  1. 将{@link @type}传入{@link #getJdbcHandlerMapForSuperclass}方法，遍历父类获取第一个对应
   *              {@link @type}的JdbcType、TypeHandler映射关系的map
    2. 
   *        
  2. 若还是没有找到，就直接将{@link #NULL_TYPE_HANDLER_MAP}作为对应{@link @type}的JdbcType、TypeHandler映射关系的map。
   *              然后返回null
    3. 
   *        
  3. 找到就设置到{@link #typeHandlerMap}中，并返回对应的JdbcType、TypeHandler映射关系的map
    4. 
   *     

   * 

   */
  private Map> getJdbcHandlerMap(Type type) {
    Map> jdbcHandlerMap = typeHandlerMap.get(type);
    if (NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap)) {//空TypeHandler标识返回null也是符合场景的。
      return null;
    }
    //没有找到该类的JdbcType、TypeHandler映射关系Map 而且 {@link @type} 是 Class类，
    if (jdbcHandlerMap == null && type instanceof Class) {
      Class clazz = (Class) type;
      if (Enum.class.isAssignableFrom(clazz)) {//属于枚举类型
        //clazz若是枚举类型,clazz.getSuperclass()就得到java.lang.Enum，因为枚举类型不能extends,但是可以implement
        //下面代码如果属于内部类，就会得到java.lang.Enum
        Class enumClass = clazz.isAnonymousClass() ? clazz.getSuperclass() : clazz;
        //从枚举类的接口获取JdbcType、TypeHandler映射关系的map
        jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(enumClass, enumClass);
        //还是没有找到的话，就用defaultEnumTypeHandler的实例对象作为对应enumClass的TypeHandler
        if (jdbcHandlerMap == null) {
          register(enumClass, getInstance(enumClass, defaultEnumTypeHandler));
          return typeHandlerMap.get(enumClass);
        }
      } else {
        //尝试通过获取父类去获取JdbcType、TypeHandler映射关系Map
        jdbcHandlerMap = getJdbcHandlerMapForSuperclass(clazz);
      }
    }
    //没有JdbcType、TypeHandler映射关系Map时，就用NULL_TYPE_HANDLER_MAP作为对应type的JdbcType、TypeHandler映射关系Map
    typeHandlerMap.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);
    return jdbcHandlerMap;
  }

  /**
   * 从枚举类的接口获取JdbcType、TypeHandler映射关系的map
   * 

   *     通过递归该方法深入{@link @clazz}的所有接口，若找到{@link @clazz}接口对应的JdbcType、TypeHandler映射关系map【{@link @jdbcHandlerMap}】,
   *     就会根据{@link @jdbcHandlerMap}构建出{@link @enumClazz}对应的JdbcType、TypeHandler映射关系map。注意一下，
   *     只会找出第一个匹配的JdbcType、TypeHandler映射关系map赋值给{@link @jdbcHandlerMap}。若还是没有找到JdbcType、TypeHandler映射关系map，
   *     就会返回null
   * 

   */
  private Map> getJdbcHandlerMapForEnumInterfaces(Class clazz, Class enumClazz) {
    for (Class iface : clazz.getInterfaces()) {//获取该枚举类所实现的所有接口
      //尝试通过接口类获取JdbcType、TypeHandler映射关系的map
      Map> jdbcHandlerMap = typeHandlerMap.get(iface);
      //如果还是没有找到，通过递归的方式，深入这个接口中看看还有没有继承接口，从那些接口里尝试获取JdbcType、TypeHandler映射关系的map
      if (jdbcHandlerMap == null) {
        jdbcHandlerMap = getJdbcHandlerMapForEnumInterfaces(iface, enumClazz);
      }
      //找到了与接口对应的JdbcType、TypeHandler映射关系map后
      if (jdbcHandlerMap != null) {
        // Found a type handler regsiterd to a super interface
        //构建一个新的JdbcType、TypeHandler映射关系map
        HashMap> newMap = new HashMap<>();
        /**
         * 将jdbcHandlerMap的元素添加给newMap:
         * 将jdbcHandlerMap的key作为newMap的key,
         *  传入enumClazz以及通过jdbcHandlerMap的value获取value的Class来构建一个对应该枚举类的TypeHandler对象作为value
         */
        for (Entry> entry : jdbcHandlerMap.entrySet()) {
          // Create a type handler instance with enum type as a constructor arg
          newMap.put(entry.getKey(), getInstance(enumClazz, entry.getValue().getClass()));
        }
        /**
         * 在这里进行方法返回，就说明该方法只会找出第一个匹配的JdbcType、TypeHandler映射关系map，
         * 就算真的有两个匹配的JdbcType、TypeHandler映射关系map，也不会合并且其JdbcType、TypeHandler映射关系map
         */
        return newMap;
      }
    }
    return null;//实在没有找到的话，返回null，也是很合理的。
  }

  /**
   * 通过获取父类去获取JdbcType、TypeHandler映射关系Map
   * 

   *     通过递归{@link @clazz}的父类，获取第一个对应父类的JdbcType、TypeHandler映射关系Map
   * 

   */
  private Map> getJdbcHandlerMapForSuperclass(Class clazz) {
    Class superclass =  clazz.getSuperclass();
    /**
     * 没有获取到父类 或者 递归父类去获取JdbcType、TypeHandler映射关系Map，都到了Object，返回null也是理所当然啦
     */
    if (superclass == null || Object.class.equals(superclass)) {
      return null;
    }
    Map> jdbcHandlerMap = typeHandlerMap.get(superclass);
    if (jdbcHandlerMap != null) {
      /**
       * 只会找出第一个匹配的JdbcType、TypeHandler映射关系map，
       * 就算真的有两个匹配的JdbcType、TypeHandler映射关系map，也不会合并且其JdbcType、TypeHandler映射关系map
       */
      return jdbcHandlerMap;
    } else {
      //递归父类
      return getJdbcHandlerMapForSuperclass(superclass);
    }
  }

  /**
   * 取唯一的TypeHandler
   * 

   *     如果有多个不同类型的TypeHandler就无法选择TypeHandler,只能返回null;
   *     但是如果只有一个类型的TypeHandler,但有多个同类型的TypeHandler实例，就取最后一个实例
   * 

   * @param jdbcHandlerMap
   * @return
   */
  private TypeHandler pickSoleHandler(Map> 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.
        //不只一个TypeHandler类型得情况下
        return null;
      }
    }
    return soleHandler;
  }

  /**
   * 获取未知类型TypeHandler实例
   * @return  {@link #unknownTypeHandler}
   */
  public TypeHandler getUnknownTypeHandler() {
    return unknownTypeHandler;
  }

  /**
   * 注册 jdbcType 对应的 TypeHandler
   * 

   *     直接调用以{@link @jdbcType}作为key 和 {@link @handler}作为value加入到{@link #jdbcTypeHandlerMap}中
   * 

   * @param jdbcType
   * @param handler
   */
  public void register(JdbcType jdbcType, TypeHandler handler) {
    jdbcTypeHandlerMap.put(jdbcType, handler);
  }

  //
  // REGISTER INSTANCE
  //

  // Only handler


  /**
   * 注册TypeHandler
   * 
    
   *     
  1. 先尝试获取注解{@link MappedTypes}声明的类来调用{@link #register(Class, TypeHandler)}进行注册
    2. 
   *     
  2. 再尝试将{@link @typeHandler}转换成{@link TypeReference},从而获取到声明的泛型类型
   *              来调用{@link #register(Class, TypeHandler)}进行注册
    3. 
   *     
  3. 都没有找到对应的java类型，就把javaType设置为null，调用{@link #register(Class, TypeHandler)}进行注册
    4. 
   * 

   */
  @SuppressWarnings("unchecked")
  public  void register(TypeHandler typeHandler) {
    //一个标记，当注册了handledType就会变成true
    boolean mappedTypeFound = false;
    //根据注解MappedType注册TypeHandler
    MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);
    if (mappedTypes != null) {
      for (Class handledType : mappedTypes.value()) {
        register(handledType, typeHandler);
        mappedTypeFound = true;
      }
    }
    //根据TypeReference声明的泛型类型注册TypeHandler
    // @since 3.1.0 - try to auto-discover the mapped type
    if (!mappedTypeFound && typeHandler instanceof TypeReference) {
      try {
        TypeReference typeReference = (TypeReference) 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
        //可能用户定义的类型引用具有不同的类型，并且不可赋值，所以忽略它
      }
    }
    //都没有找到对应的java类型，就当作null进行注册。
    if (!mappedTypeFound) {
      register((Class) null, typeHandler);
    }
  }

  // java type + handler

  /**
   * 注册 javaType -- TypeHandle
   * 将{@link @javaType} 强转为 {@link Type}后，调用 {@link TypeHandlerRegistry#register(Type, TypeHandler)}
   */
  public  void register(Class javaType, TypeHandler typeHandler) {
    register((Type) javaType, typeHandler);
  }


  /**
   * 注册 javaType -- TypeHandle
   * 

   *    获取{@link @typeHandler}的{@link MappedJdbcTypes}注解信息赋值给{@link @mappedJdbcTypes}，
   *    在{@link @mappedJdbcTypes}不为null的情况下，遍历@mappedJdbcType所支持的jdbcType，
   *    对其调用 {@link TypeHandlerRegistry#register(Class, JdbcType, Class)} 注册，再判断是否支持null的jdbcType，
   *    支持的将null作为{@link TypeHandlerRegistry#register(Class, JdbcType, Class)}的第二参数进行调用；
   *    否则,直接将null作为{@link TypeHandlerRegistry#register(Class, JdbcType, Class)}的第二参数进行调用
   * 

   */
  private  void register(Type javaType, TypeHandler typeHandler) {
    MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
    if (mappedJdbcTypes != null) {
      for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
        register(javaType, handledJdbcType, typeHandler);
      }
      if (mappedJdbcTypes.includeNullJdbcType()) {//支持NULL的JdbcType
        register(javaType, null, typeHandler);
      }
    } else {
      register(javaType, null, typeHandler);
    }
  }

  /**
   * 注册 TypeHandler
   * 

   *     获取{@link @javaTypeReference}所声明的泛型类型，调用{@link #register(Class, TypeHandler)}进行注册
   * 

   */
  public  void register(TypeReference javaTypeReference, TypeHandler handler) {
    register(javaTypeReference.getRawType(), handler);
  }

  // java type + jdbc type + handler

  /**
   * 注册TypeHandler
   * 

   *     将{@link @type}强转成{@link Type},调用{@link #register(Type, JdbcType, TypeHandler)}进行注册
   * 

   */
  public  void register(Class type, JdbcType jdbcType, TypeHandler handler) {
    register((Type) type, jdbcType, handler);
  }

  /**
   * 注册 javaType -- jdbcType -- TypeHandler
   * 

   *     先从 {@link TypeHandlerRegistry#typeHandlerMap} 中获取{@link @javaType}对应的 JdbcType、TypeHandler映射关系的map
   *     并赋值给{@link @map},然后将{@link @jdbcType}作为key和{@link @handler}作为value设置到{@link @map}。
   *     简单来说就是合并原有的，新建没有的。
   *     最后还会获取{@link @handler}的Class类作为key，{@link @handler}作为value设置到{@link #allTypeHandlersMap}中
   * 

   * 

   *     只要{@link @map} 是 null,或者是一个{@link TypeHandlerRegistry#NULL_TYPE_HANDLER_MAP}都会对{@link @map}重新实例化
   *     一个新的{@link HashMap}并调用加入到 {@link #typeHandlerMap} 中。
   * 

   */
  private void register(Type javaType, JdbcType jdbcType, TypeHandler handler) {
    if (javaType != null) {
      Map> map = typeHandlerMap.get(javaType);
      if (map == null || map == NULL_TYPE_HANDLER_MAP) {//就算 null类型TypeHandler Map都会重新赋值
        map = new HashMap<>();
        typeHandlerMap.put(javaType, map);
      }
      map.put(jdbcType, handler);
    }
    allTypeHandlersMap.put(handler.getClass(), handler);
  }

  //
  // REGISTER CLASS
  //

  // Only handler type

  /**
   * 注册TypeHandler
   * 

   *     通过注解{@link MappedTypes}获取{@link @typeHandlerClass}能处理的java类型，逐一调用{@link #register(Class, Class)}进行注册，
   *     没有注册到指定类型+TypeHandler映射关系时，用null当作javaTypeClass参数，调用{@link #getInstance(Class, Class)}得到TypeHandler的实例，
   *     然后调用{@link #register(TypeHandler)}进行注册。
   * 

   */
  public void register(Class typeHandlerClass) {
    //已注册标记，当注册了指定类型+TypeHandler映射关系后会设置为tue
    boolean mappedTypeFound = false;
    MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
    if (mappedTypes != null) {
      for (Class javaTypeClass : mappedTypes.value()) {
        register(javaTypeClass, typeHandlerClass);
        mappedTypeFound = true;
      }
    }
    //没有注册到指定类型+TypeHandler映射关系，用null当作javaTypeClass进行注册
    if (!mappedTypeFound) {
      register(getInstance(null, typeHandlerClass));//为啥不用register(Class, Class)方法呢，因为null没有Class
    }
  }

  // java type + handler type

  /**
   * 注册TypeHandler
   * 

   *     调用{@link Resources#classForName(String)}获取{@link @javaTypeClassName}和{@link @typeHandlerClassName}的Class,
   *     再调用{@link #register(Class, Class)}
   * 

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

  /**
   * 注册TypeHandler
   * 

   *     传入{@link @javaTypeClass}和{@link @typeHandlerClass}到{@link #getInstance(Class, Class)}中得到TypeHandler的实例对象，
   *     再调用{@link #register(TypeHandler)}进行注册
   * 

   */
  public void register(Class javaTypeClass, Class typeHandlerClass) {
    register(javaTypeClass, getInstance(javaTypeClass, typeHandlerClass));
  }

  // java type + jdbc type + handler type

  /**
   * 注册TypeHandler
   * 

   *     传入{@link @javaTypeClass}和{@link @typeHandlerClass}到{@link #getInstance(Class, Class)}中得到TypeHandler的实例对象,
   *     再调用{@link #register(Type, JdbcType, TypeHandler)}进行注册
   * 

   */
  public void register(Class javaTypeClass, JdbcType jdbcType, Class typeHandlerClass) {
    register(javaTypeClass, jdbcType, getInstance(javaTypeClass, typeHandlerClass));
  }

  // Construct a handler (used also from Builders)

  /**
   * 创建TypeHandler实例对象
   * 

   *   当{@link @javaTypeClass}不为null，会尝试通过带 Class 参数的构造方法进行实例化TypeHandler对象。
   *   如果没有该构造方法，就通过无参构造方法实例化TypeHandler对象。
   * 

   */
  @SuppressWarnings("unchecked")
  public  TypeHandler getInstance(Class javaTypeClass, Class typeHandlerClass) {
    if (javaTypeClass != null) {
      /**
       * 尝试通过带 Class 参数的构造方法进行实例化TypeHandler对象。因为没有检查是否存在某个构造函数的方法，所以
       * 使用捕捉异常的方式解决.
       */
      try {
        Constructor c = typeHandlerClass.getConstructor(Class.class);
        return (TypeHandler) c.newInstance(javaTypeClass);
      } catch (NoSuchMethodException ignored) {
        // ignored 忽略没有该方法异常，使得执行下面代码。
      } catch (Exception e) {
        throw new TypeException("Failed invoking constructor for handler " + typeHandlerClass, e);
      }
    }
    //通过无参构造方法实例化TypeHandler
    try {
      Constructor c = typeHandlerClass.getConstructor();
      return (TypeHandler) c.newInstance();
    } catch (Exception e) {
      throw new TypeException("Unable to find a usable constructor for " + typeHandlerClass, e);
    }
  }

  // scan

  /**
   * 扫描包中的 {@link TypeHandler} 的子类，并 调用 {@link TypeHandlerRegistry#register(TypeHandler)}
   * @param packageName
   */
  public void register(String packageName) {
    ResolverUtil> resolverUtil = new ResolverUtil<>();
    //扫描 packageName 里的 {@link TypeHandler} 子类
    resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);
    //获取符合条件的类
    Set>> 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

  /**
   * 获取所有已注册的TypeHandler
   * @since 3.2.2
   */
  public Collection> getTypeHandlers() {
    return Collections.unmodifiableCollection(allTypeHandlersMap.values());
  }

}

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Mybatis-TypeHandler源码解析)

        

            

                
    
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Istio pilot-discovery服务发现源码解析（1.13版本）
                        xidianjiapei001
#Istioistio云原生服务发现
                        
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • VITS 源码解析2-模型概述
                        迪三
#NN_Audio音频人工智能
                        
    VITs是文本到语音(Text-to-Speech,TTS)任务中最流行的技术之一，其实现思路是将文本语音信息融合到了HiFiGAN潜空间内,通过文本控制HiFiGAN的生成器，输出含文本语义的声音。VITs主要以GAN的方式训练,其生成器G是SynthesizerTrn，判别器D是MPD。VITS的判别器几乎和HiFiGAN一样，生成器则融合了文本、时序、声音三大类模型1.文件概述模型部分包含三
    
                    
    • 
                    
  • RBtree
                        努力的小带土
侯捷老师STLc++蓝桥杯
                        
    终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！-【码炫课堂收费课节选之-红黑树源码解析及手写红黑树】_哔哩哔哩_bilibiliB站的听课记录，并写下如下红黑树c++版本代码，该课程真的史诗级推荐！/*RBtreeNode.h*****/#pragmaonceenum{RED=false,BLACK=true};templateclassRBtreeNode{public://红黑树的左右节点
    
                    
    • 
                    
  • 深入理解Kubernetes：kube-scheduler源码解析
                        mujingluo
kubernetes容器云原生
                        
    Kubernetes的调度器（kube-scheduler）是整个系统中至关重要的组件，它负责将待调度的Pods分配到合适的节点上。本文将深入分析kube-scheduler的源码，揭示其内部工作机制。kube-scheduler的核心功能kube-scheduler的核心功能包括：监听Pod变化：通过KubernetesAPI监听所有未调度的Pods。过滤（Filtering）：根据一系列规则（
    
                    
    • 
                    
  • 【Vesta发号器源码】PropertyMachineIdsProvider
                        DeanChangDM

                        
    Vesta发号器源码解析——PropertyMachineIdsProvider属性配置文件持有Id的模式,没啥东西，比单个的多了一个获取下一个的方法封装实现上略有一点点区别privatelong[]machineIds;privateintcurrentIndex;publiclonggetNextMachineId(){returngetMachineId();}publiclonggetMa
    
                    
    • 
                    
  • StarRocks分布式元数据源码解析
                        不甚了然
Iceberg知识集StarRocksIceberg数据湖湖仓一体大数据
                        
    1.支持元数据表https://github.com/StarRocks/starrocks/pull/44276/files核心类：LogicalIcebergMetadataTable，Iceberg元数据表，将元数据的各个字段做成表的列，后期可以通过sql操作从元数据获取字段，这个表的组成字段是DataFile相关的字段public static LogicalIcebergMetadata
    
                    
    • 
                    
  • 【Starrocks】建表篇Fe源码解析
                        数算七弦
Starrocks大数据
                        
    Starrocks系统架构简述现在市面上主流的OLAP存算一体架构主要有两类进程：Frontend（FE）和Backend（BE）Frontend一般是用Java写的。主要职责有：接收用户连接请求（MySQL协议层）元数据存储与管理查询语句的解析与查询计划的生成集群管控Backend一般是用C++写的，主要职责有：数据存储与管理查询计划的执行建表语句的执行过程与Mysql协议层交互词法解析语法解析
    
                    
    • 
                    
  • 智能农业设备软件工程师如何集成和管理农业物联网（IoT）平台
                        openwin_top
智能农业设备软件工程师物联网python开发语言深度学习大数据智能农业
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业物联网（IoT）平台涉及多个步骤，包括设备连接、数据收集、数据传输、数据存储、数据分析和展示。以下是详细分析和示例代码展示。1.设备连接和数据收集首先，智能农业设备需要能够与传感器和执
    
                    
    • 
                    
  • 智能农业设备软件工程师如何集成和管理农业设备的远程更新系统
                        openwin_top
智能农业设备软件工程师深度学习大数据物联网人工智能网络智能农业
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业设备的远程更新系统涉及多个技术层面，包括设备固件的安全更新、版本控制、网络通信，以及设备管理平台的开发。下面我们详细分析这些步骤，并提供一个基本的示例代码来展示如何实现这个系统。1.系
    
                    
    • 
                    
  • 智能农业设备软件工程师如何处理设备的远程诊断和修复
                        openwin_top
智能农业设备软件工程师网络智能农业物联网人工智能大数据深度学习
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位处理智能农业设备的远程诊断和修复涉及几个关键步骤，包括设备的数据采集、数据传输、远程诊断、远程控制和修复。以下是详细分析和示例代码：1.数据采集智能农业设备通常配备传感器和控制器，这些设备不断采集环
    
                    
    • 
                    
  • android10 按键音量调节源码解析
                        @OuYang
android
                        
    /frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.javastaticIAudioServicegetAudioService(){IAudioServiceaudioService=IAudioService.Stub.asInterface(ServiceManager.checkS
    
                    
    • 
                    
  • android10 Settings源码解析
                        @OuYang
android
                        
    /packages/apps/Settings/AndroidManifest.xml.................................................................................activity-alias是Android里为了重复使用Activity而设计的。对于activity-alias标签，它有一个属性叫android:
    
                    
    • 
                    
  • MyBatis 源码解析：XMLScriptBuilder 工作机制
                        捕风捉你
MyBatis源码解读mybatisjava
                        
    摘要MyBatis提供了强大的动态SQL功能，它通过解析XML配置文件中的动态SQL标签（如、、等），来实现灵活的SQL生成。而XMLScriptBuilder类则负责解析这些XML配置并生成最终的SQL语句。本文将详细解析XMLScriptBuilder的工作机制，并通过自定义实现来帮助您深入理解该类的功能。前言MyBatis中的动态SQL功能是通过解析XML配置文件实现的。XML文件中包含了动
    
                    
    • 
                    
  • c#视觉应用开发中如何使用Emgu CV在C#中进行图像处理？
                        openwin_top
C#视觉应用开发问题系列c#图像处理开发语言
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位EmguCV是OpenCV的.NET包装器，可以让开发者在.NET语言（如C#）中使用OpenCV的功能进行图像处理。在进行图像处理时，EmguCV提供了丰富的API可以使用。以下是使用EmguCV
    
                    
    • 
                    
  • Elasticsearch——配置详解
                        smart哥
elasticsearch专题elasticsearch搜索引擎
                        
    作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程阶段2、深入多线程设计模式阶段3、深入juc源码解析阶段4、深入jdk其余源码解析阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场
    
                    
    • 
                    
  • Eventbus3.0源码解析
                        超威蓝猫l

                        
    根据官方demo首先你需要先在activity中注册EventBus.getDefault().register(this);register所以我们先从getDefault方法开始看起/**Conveniencesingletonforappsusingaprocess-wideEventBusinstance.*/publicstaticEventBusgetDefault(){EventBu
    
                    
    • 
                    
  • 前端宝典之三：React源码解析之Fiber架构
                        桃子叔叔
大厂进阶前端深度解析系列react.js架构javascript
                        
    本文主要内容：1、ReactConcurrent2、React15架构3、React16架构4、Fiber架构5、任务调度循环和fiber构造循环区别一、ReactConcurrentReact在解决CPU卡顿是会用到ReactConcurrent的概念，它是React中的一个重要特性和模块，主要的特点和原理如下一、主要特点和优势1、时间切片（TimeSlicing）允许将长时间运行的任务分割成小
    
                    
    • 
                    
  • Java集合之HashSet源码解析
                        气宇轩昂固执狂
JAVA面试笔试通关指南java开发语言HashSetHashSet源码
                        
    一、HashSet概述：1、HashSet底层实现实际上就是利用HashMap的键（Key）来存储对象，原HashMap的键key的位置存放对象，值value的位置存放空的Object对象作为虚拟值；2、增加和删除都是直接调用HashMap的方法来实现的，没有修改和具体的查询方法，获取值只能通过iterator方法来迭代，迭代方法也是建立在HashMap的键的迭代方法上的。相关HashSet的操作
    
                    
    • 
                    
  • Spring之AOP底层源码解析（上）
                        阿立聊代码
spring代理模式
                        
    动态代理代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。比如，现在存在一个UserService类：public class UserService  { public void test() {  System.out.println("test..."); }}此时，我们new一个UserService对象，然后执行test()方法，结果是
    
                    
    • 
                    
  • Spring Boot自动配置源码解析
                        一休哥助手
springbootjava数据库
                        
    一、自动配置概述1.1什么是自动配置SpringBoot的自动配置是一种能够根据类路径中的依赖、配置文件中的属性以及其他条件，自动配置Spring应用上下文的功能。它通过扫描项目中的类和配置文件，判断哪些组件需要自动装配，从而减少了手动编写配置代码的繁琐过程。1.2自动配置的优点减少配置工作量：自动配置能够帮助开发者快速启动一个Spring应用，而不必担心各种复杂的XML或Java配置。智能化配置
    
                    
    • 
                    
  • Spring扩展点系列-InstantiationAwareBeanPostProcessor
                        码至终章
Spring生命周期扩展接口springsqljava扩展接口mavenspringboot
                        
    文章目录简介测试一1、配置文件Bean注册2、单元测试方法3、测试类4、输出结果结论测试二1、测试类2、输出结果结论源码解析postProcessPropertiesCommonAnnotationBeanPostProcessorAnnotationInjectedBeanPostProcessor总结简介spring容器中Bean的生命周期内所有可扩展的点的调用顺序扩展接口实现接口Applic
    
                    
    • 
                    
  • MyBatis 源码解析：DefaultSqlSessionFactory 的创建与管理
                        捕风捉你
MyBatis源码解读mybatis
                        
    摘要在MyBatis中，SqlSessionFactory是执行数据库操作的核心对象，它负责创建和管理SqlSession的生命周期。你是否想了解SqlSessionFactory的创建和管理过程？本文将通过自定义实现一个简化版的DefaultSqlSessionFactory，带你深入探讨MyBatis中DefaultSqlSessionFactory的创建与管理机制，并帮助你更好地掌握SqlS
    
                    
    • 
                    
  • FFmpeg源码解析系列（一）目录和编译
                        头快撑不住了
FFmpeg源码解析ffmpeg音视频视频编解码实时音视频图像处理
                        
    引言当我们欣赏一部电影、观看一段视频或者享受一首音乐时，很少有人会停下来思考这一切是如何呈现在我们眼前的。然而，在每一帧的画面、每一秒的声音背后，有着一个不可思议的技术世界这个充满音视频的世界的核心之一，就是FFmpeg。FFmpeg是一个强大而复杂的多媒体处理工具，它为视频和音频编解码、流媒体传输、格式转换等提供了优秀的解决方案。在这个系列博客中，我们将深入探讨FFmpeg源码，解析它的工作原理
    
                    
    • 
                    
  • Spark MLlib LinearRegression线性回归算法源码解析
                        SmileySure
Spark人工智能算法SparkMLlib
                        
    线性回归一元线性回归hθ(x)=θ0+θ1xhθ(x)=θ0+θ1x——————–1多元线性回归hθ(x)=∑mi=1θixi=θTXhθ(x)=∑i=1mθixi=θTX—————–2损失函数J(θ)=1/2∑mi=1(hθ(xi)−yi)2J(θ)=1/2∑i=1m(hθ(xi)−yi)2—————31/2是为了求导时系数为1，平方里是真实值减去估计值我们的目的就是求其最小值最小二乘法要求较为
    
                    
    • 
                    
  • HashMap源码解析
                        dlwlrma ⥳
兴趣类哈希算法散列表算法
                        
    目录一:put方法流程二：get方法三：扩容机制一：put方法流程publicVput(Kkey,Vvalue){returnputVal(hash(key),key,value,false,true);}finalVputVal(inthash,Kkey,Vvalue,booleanonlyIfAbsent,booleanevict){Node[]tab;Nodep;intn,i;//判断数组是
    
                    
    • 
                    
  • Spring之启动过程源码解析
                        阿立聊代码
springspring数据库oracle
                        
    前言分析通常，我们说的Spring启动，就是构造ApplicationContext对象以及调用refresh()方法的过程。首先，Spring启动过程主要做了这么几件事情：构造一个BeanFactory对象解析配置类，得到BeanDefinition，并注册到BeanFactory中解析@ComponentScan，此时就会完成扫描解析@Import解析@Bean...因为Application
    
                    
    • 
                    
  • 【HuggingFace Transformers】BertIntermediate 和 BertPooler源码解析
                        CS_木成河
HuggingFace深度学习人工智能bertpython大模型Transformer
                        
    BertIntermediate和BertPooler源码解析1.介绍1.1位置与功能1.2相似点与不同点2.源码解析2.1BertIntermediate源码解析2.2BertPooler源码解析1.介绍1.1位置与功能(1)BertIntermediate位置：位于BertLayer的注意力层（BertSelfAttention）和输出层（BertOutput）之间。功能：它执行一个线性变换（
    
                    
    • 
                    
  • vue.js项目实战案例详细源码讲解
                        程序员小羊！
Javavue.js前端javascript
                        
    大家好，我是程序员小羊！前言：为帮助大家更好地掌握Vue.js项目的开发流程，我将为你讲解一个完整的Vue.js实战案例，并提供详细的源码解析。这个案例将涵盖从项目创建到实现各种功能模块的全过程，适合用于构建一个具有基本CRUD功能的简单任务管理应用。案例介绍我们将开发一个任务管理应用（TaskManager），它允许用户添加、查看、编辑和删除任务。这个应用将包括以下主要功能模块：任务列表显示：展
    
                    
    • 
                                
  • JAVA中的Enum
                                    周凡杨
javaenum枚举
                                    
    Enum是计算机编程语言中的一种数据类型---枚举类型。 在实际问题中，有些变量的取值被限定在一个有限的范围内。       例如，一个星期内只有七天 我们通常这样实现上面的定义： 
public String monday;
public String tuesday;
public String wensday;
public String thursday
    
                                
    • 
                                
  • 赶集网mysql开发36条军规
                                    Bill_chen
mysql业务架构设计mysql调优mysql性能优化
                                    
    (一)核心军规   (1)不在数据库做运算      cpu计算务必移至业务层；   (2)控制单表数据量      int型不超过1000w，含char则不超过500w；      合理分表；      限制单库表数量在300以内；   (3)控制列数量      字段少而精，字段数建议在20以内
    
                                
    • 
                                
  • Shell test命令
                                    daizj
shell字符串test数字文件比较
                                    
    Shell test命令 
Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。  数值测试    参数 说明   -eq 等于则为真   -ne 不等于则为真   -gt 大于则为真   -ge 大于等于则为真   -lt 小于则为真   -le 小于等于则为真    
实例演示： 
num1=100
num2=100if test $[num1]
    
                                
    • 
                                
  • XFire框架实现WebService(二)
                                    周凡杨
javawebservice
                                    
       有了XFire框架实现WebService(一)，就可以继续开发WebService的简单应用。 
Webservice的服务端(WEB工程)： 
两个java bean类： 
Course.java 
   package cn.com.bean; 
public class Course { 
    private 
    
                                
    • 
                                
  • 重绘之画图板
                                    朱辉辉33
画图板
                                    
           上次博客讲的五子棋重绘比较简单，因为只要在重写系统重绘方法paint（）时加入棋盘和棋子的绘制。这次我想说说画图板的重绘。 
       画图板重绘难在需要重绘的类型很多，比如说里面有矩形，园，直线之类的，所以我们要想办法将里面的图形加入一个队列中，这样在重绘时就
    
                                
    • 
                                
  • Java的IO流
                                    西蜀石兰
java
                                    
    刚学Java的IO流时，被各种inputStream流弄的很迷糊，看老罗视频时说想象成插在文件上的一根管道，当初听时觉得自己很明白，可到自己用时，有不知道怎么代码了。。。 
每当遇到这种问题时，我习惯性的从头开始理逻辑，会问自己一些很简单的问题，把这些简单的问题想明白了，再看代码时才不会迷糊。 
 
IO流作用是什么？ 
答：实现对文件的读写，这里的文件是广义的； 
 
Java如何实现程序到文件
    
                                
    • 
                                
  • No matching PlatformTransactionManager bean found for qualifier 'add' - neither
                                    林鹤霄

                                    
    java.lang.IllegalStateException: No matching PlatformTransactionManager bean found for qualifier 'add' - neither qualifier match nor bean name match! 
  
网上找了好多的资料没能解决，后来发现：项目中使用的是xml配置的方式配置事务，但是
    
                                
    • 
                                
  • Row size too large (> 8126). Changing some columns to TEXT or BLOB
                                    aigo
column
                                    
    原文：http://stackoverflow.com/questions/15585602/change-limit-for-mysql-row-size-too-large 
  
异常信息： 
Row size too large (> 8126). Changing some columns to TEXT or BLOB or using ROW_FORMAT=DYNAM
    
                                
    • 
                                
  • JS 格式化时间
                                    alxw4616
JavaScript
                                    
    /**
 * 格式化时间 2013/6/13 by 半仙 [email protected]
 * 需要 pad 函数
 * 接收可用的时间值.
 * 返回替换时间占位符后的字符串
 *
 * 时间占位符:年 Y 月 M 日 D 小时 h 分 m 秒 s 重复次数表示占位数
 * 如 YYYY 4占4位 YY 占2位<p></p>
 * MM DD hh mm
    
                                
    • 
                                
  • 队列中数据的移除问题
                                    百合不是茶
队列移除
                                    
      
   队列的移除一般都是使用的remov();都可以移除的,但是在昨天做线程移除的时候出现了点问题,没有将遍历出来的全部移除,  代码如下; 
  
   // 
package com.Thread0715.com;

import java.util.ArrayList;

public class Threa
    
                                
    • 
                                
  • Runnable接口使用实例
                                    bijian1013
javathreadRunnablejava多线程
                                    
    Runnable接口 
a.       该接口只有一个方法：public void run(); 
b.       实现该接口的类必须覆盖该run方法 
c.       实现了Runnable接口的类并不具有任何天
    
                                
    • 
                                
  • oracle里的extend详解
                                    bijian1013
oracle数据库extend
                                    
    扩展已知的数组空间，例： 
DECLARE
  TYPE CourseList IS TABLE OF VARCHAR2(10);
  courses CourseList;
BEGIN
  --   初始化数组元素，大小为3
  courses := CourseList('Biol   4412 ', 'Psyc   3112 ', 'Anth   3001 ');
  --   
    
                                
    • 
                                
  • 【httpclient】httpclient发送表单POST请求
                                    bit1129
httpclient
                                    
    浏览器Form Post请求 
浏览器可以通过提交表单的方式向服务器发起POST请求，这种形式的POST请求不同于一般的POST请求 
1. 一般的POST请求，将请求数据放置于请求体中，服务器端以二进制流的方式读取数据，HttpServletRequest.getInputStream()。这种方式的请求可以处理任意数据形式的POST请求，比如请求数据是字符串或者是二进制数据 
2. Form 
    
                                
    • 
                                
  • 【Hive十三】Hive读写Avro格式的数据
                                    bit1129
hive
                                    
     1. 原始数据 
hive> select * from word; 
OK
1	MSN  
10	QQ  
100	Gtalk  
1000	Skype  
  
  
 2. 创建avro格式的数据表 
  
hive> CREATE TABLE avro_table(age INT, name STRING)STORE
    
                                
    • 
                                
  • nginx+lua+redis自动识别封解禁频繁访问IP
                                    ronin47

                                    
    在站点遇到攻击且无明显攻击特征，造成站点访问慢，nginx不断返回502等错误时，可利用nginx+lua+redis实现在指定的时间段 内，若单IP的请求量达到指定的数量后对该IP进行封禁，nginx返回403禁止访问。利用redis的expire命令设置封禁IP的过期时间达到在 指定的封禁时间后实行自动解封的目的。 
一、安装环境： 
 
 CentOS x64 release 6.4(Fin
    
                                
    • 
                                
  • java-二叉树的遍历-先序、中序、后序（递归和非递归）、层次遍历
                                    bylijinnan
java
                                    
    
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;


public class BinTreeTraverse {
	//private int[] array={ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	private int[] array={ 10,6,
    
                                
    • 
                                
  • Spring源码学习-XML 配置方式的IoC容器启动过程分析
                                    bylijinnan
javaspringIOC
                                    
    以FileSystemXmlApplicationContext为例，把Spring IoC容器的初始化流程走一遍： 
 

ApplicationContext context = new FileSystemXmlApplicationContext
            ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml&q
    
                                
    • 
                                
  • [科研与项目]民营企业请慎重参与军事科技工程
                                    comsci
企业
                                    
     
 
     军事科研工程和项目 并非要用最先进，最时髦的技术，而是要做到“万无一失” 
 
   而民营科技企业在搞科技创新工程的时候，往往考虑的是技术的先进性，而对先进技术带来的风险考虑得不够，在今天提倡军民融合发展的大环境下，这种“万无一失”和“时髦性”的矛盾会日益凸显。。。。。。所以请大家在参与任何重大的军事和政府项目之前，对
    
                                
    • 
                                
  • spring 定时器-两种方式
                                    cuityang
springquartz定时器
                                    
    方式一： 
间隔一定时间 运行 
 
<bean id="updateSessionIdTask" class="com.yang.iprms.common.UpdateSessionTask" autowire="byName" /> 
 
 <bean id="updateSessionIdSchedule
    
                                
    • 
                                
  • 简述一下关于BroadView站点的相关设计
                                    damoqiongqiu
view
                                    
    终于弄上线了，累趴，戳这里http://www.broadview.com.cn 
  
简述一下相关的技术点 
  
前端：jQuery+BootStrap3.2+HandleBars，全站Ajax（貌似对SEO的影响很大啊！怎么破？），用Grunt对全部JS做了压缩处理，对部分JS和CSS做了合并（模块间存在很多依赖，全部合并比较繁琐，待完善）。 
  
后端：U
    
                                
    • 
                                
  • 运维 PHP问题汇总
                                    dcj3sjt126com
windows2003
                                    
    1、Dede(织梦)发表文章时,内容自动添加关键字显示空白页 
解决方法： 
后台>系统>系统基本参数>核心设置>关键字替换（是/否），这里选择“是”。 
后台>系统>系统基本参数>其他选项>自动提取关键字，这里选择“是”。 
  
2、解决PHP168超级管理员上传图片提示你的空间不足 
网站是用PHP168做的，反映使用管理员在后台无法
    
                                
    • 
                                
  • mac 下 安装php扩展 - mcrypt
                                    dcj3sjt126com
PHP
                                    
    MCrypt是一个功能强大的加密算法扩展库，它包括有22种算法，phpMyAdmin依赖这个PHP扩展，具体如下： 
 
  
  下载并解压libmcrypt-2.5.8.tar.gz。 
  在终端执行如下命令：  tar zxvf libmcrypt-2.5.8.tar.gz cd libmcrypt-2.5.8/ ./configure --disable-posix-threads --
    
                                
    • 
                                
  • MongoDB更新文档 [四]
                                    eksliang
mongodbMongodb更新文档
                                    
    MongoDB更新文档 
转载请出自出处：http://eksliang.iteye.com/blog/2174104 
MongoDB对文档的CURD，前面的博客简单介绍了，但是对文档更新篇幅比较大，所以这里单独拿出来。 
语法结构如下： 
db.collection.update( criteria, objNew, upsert, multi) 
参数含义    参数   
    
                                
    • 
                                
  • Linux下的解压，移除，复制，查看tomcat命令
                                    y806839048
tomcat
                                    
    重复myeclipse生成webservice有问题删除以前的，干净 
 
 1、先切换到：cd usr/local/tomcat5/logs 
 
2、tail -f catalina.out 
 
3、这样运行时就可以实时查看运行日志了 
 
 
 
 
Ctrl+c 是退出tail命令。 
 有问题不明的先注掉 
   cp /opt/tomcat-6.0.44/webapps/g
    
                                
    • 
                                
  • Spring之使用事务缘由(3-XML实现)
                                    ihuning
spring
                                    
      
用事务通知声明式地管理事务 
  
事务管理是一种横切关注点。为了在 Spring 2.x 中启用声明式事务管理，可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知，为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去。声明了事务通知后，就需要将它与切入点关联起来。由于事务通知是在 <aop:
    
                                
    • 
                                
  • GCD使用经验与技巧浅谈
                                    啸笑天
GC
                                    
    前言 
GCD(Grand Central Dispatch)可以说是Mac、iOS开发中的一大“利器”，本文就总结一些有关使用GCD的经验与技巧。 
dispatch_once_t必须是全局或static变量 
这一条算是“老生常谈”了，但我认为还是有必要强调一次，毕竟非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug，正确的如下：        1  
    
                                
    • 
                                
  • linux（Ubuntu）下常用命令备忘录1
                                    macroli
linux工作ubuntu
                                    
    在使用下面的命令是可以通过--help来获取更多的信息1,查询当前目录文件列表：ls 
 
 ls命令默认状态下将按首字母升序列出你当前文件夹下面的所有内容，但这样直接运行所得到的信息也是比较少的，通常它可以结合以下这些参数运行以查询更多的信息：  
 ls / 显示/.下的所有文件和目录  
 ls -l 给出文件或者文件夹的详细信息 
 ls -a 显示所有文件，包括隐藏文
    
                                
    • 
                                
  • nodejs同步操作mysql
                                    qiaolevip
学习永无止境每天进步一点点mysqlnodejs
                                    
    // db-util.js
var mysql = require('mysql');
var pool = mysql.createPool({
  connectionLimit : 10,
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test',
  port: 3306
});


    
                                
    • 
                                
  • 一起学Hive系列文章
                                    superlxw1234
hiveHive入门
                                    
      
[一起学Hive]系列文章 目录贴，入门Hive，持续更新中。 
  
[一起学Hive]之一—Hive概述，Hive是什么 
[一起学Hive]之二—Hive函数大全-完整版 
[一起学Hive]之三—Hive中的数据库(Database)和表(Table) 
[一起学Hive]之四-Hive的安装配置 
[一起学Hive]之五-Hive的视图和分区 
[一起学Hive
    
                                
    • 
                                
  • Spring开发利器：Spring Tool Suite 3.7.0 发布
                                    wiselyman
spring
                                    
    Spring Tool Suite(简称STS)是基于Eclipse，专门针对Spring开发者提供大量的便捷功能的优秀开发工具。 
  
在3.7.0版本主要做了如下的更新： 
  
 
 将eclipse版本更新至Eclipse Mars 4.5 GA 
 Spring Boot(JavaEE开发的颠覆者集大成者，推荐大家学习)的配置语言YAML编辑器的支持(包含自动提示，
    
                                
    •