mybatis源码学习——Configuration类及其初始化过程、TypeHandler、TypeAlias

最新推荐文章于 2024-08-08 23:20:59 发布
最新推荐文章于 2024-08-08 23:20:59 发布
阅读量1.7k 收藏 4
点赞数 1
分类专栏： mybatis源码 框架学习 文章标签： mybatis 源码 typehandle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccf547461296/article/details/54098044
版权

Configuration类是Mybatis中的特别核心的一个类，主要用来进行Mybatis执行过程中的各项参数的设置。第一次Debug源码时，会感觉到什么配置都需要在Configuration中设置，多次Debug之后，发现确实如此，这就是Mybatis中的核心配置类。。。2333

因为在Mybatis的整个生命周期中，只存在一个Configuration的实例。这里没有使用单例模式，所以在Configuration实例化之前，完成了对成员变量的实例化，所以可以访问其中的方法。并且这些成员变量是final的永远指向同一个对象实例。

Mybatis的所有配置参数都在Configuration中。

下面开始Configuration源码的分析~~

1.Configuration中的成员变量

可以看到Configuration中的所有成员变量的访问权限都是protected ，只允许org.apache.ibatis.session中的类访问。

  //主要用来配置事务工厂和数据源，以及environment的id。
  //可以使用多个环境，例如开发环境、测试环境，以id来区分。
  protected Environment environment;

  protected boolean safeRowBoundsEnabled = false;
  protected boolean safeResultHandlerEnabled = true;
  protected boolean mapUnderscoreToCamelCase = false;  //数据库表字段驼峰命令 
  protected boolean aggressiveLazyLoading = true;
  protected boolean multipleResultSetsEnabled = true;
  protected boolean useGeneratedKeys = false;        //自动生成主键
  protected boolean useColumnLabel = true;
  protected boolean cacheEnabled = true;            //默认缓存是开启的
  protected boolean callSettersOnNulls = false;
  protected boolean useActualParamName = true;

  protected String logPrefix;
  protected Class <? extends Log> logImpl;
  protected Class <? extends VFS> vfsImpl;

  //缓存的作用域。
  //SESSION表示会缓存一个会话中执行的所有查询。 
  //STATEMENT表示本地会话仅用在语句执行上，对相同SqlSession的不同调用将不会共享数据。 
  //具体缓存，后面分析
  protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;   
  protected JdbcType jdbcTypeForNull = JdbcType.OTHER;
  protected Set<String> lazyLoadTriggerMethods = new HashSet<String>(Arrays.asList(new String[] { "equals", "clone", "hashCode", "toString" }));
  protected Integer defaultStatementTimeout;
  protected Integer defaultFetchSize;

  /**
  * 默认ExecutorType为SIMPLE，但实际使用过程中因为cacheEnabled = true而使用了CachingExecutor。
  * ExecutorType有[SIMPLE, REUSE, BATCH]，
  *               REUSE使用PrepareStatement，
  *               BATCH表示可以批量执行(这种模式下可以使用sqlSession中的flushStatements())
  */
  protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;      
  protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;
  protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE;

  protected Properties variables = new Properties();
  protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
  protected ObjectFactory objectFactory = new DefaultObjectFactory();
  protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();

  protected boolean lazyLoadingEnabled = false;
  protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL

  protected String databaseId;

  protected Class<?> configurationFactory;

  //创建MapperRegistry并将Configuration传递给MapperRegistry
  //MapperRegistry主要用来管理Mapper接口
  protected final MapperRegistry mapperRegistry = new MapperRegistry(this);

  //拦截器链，赋值在Executor创建的时候

  //重点：类型转换的注册,在这里注册了常用的类型转换器。当不能满足开发需要时，可以自定义，例如0，1与false,true的类型转换器。
  //也就是Java中的类型与数据库中支持的类型的相互转换关系的定义。
  //TypeHandlerRegistry主要用来管理TypeHandler
  protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry();

  //重点：类别名的注册。方便我们在使用mapper.xml中的使用。例如在paramterType中我们可以直接写"int"，会被映射为java.lang.Integer
  //TypeAliasRegistry所有的对应关系被记录在变量TYPE_ALIASES引用的HashMap中。
  //并包含一个  public <T> Class<T> resolveAlias(String string) 的方法，用来根据String类型的key获取对应的类。

  protected final LanguageDriverRegistry languageRegistry = new LanguageDriverRegistry();


//这几个都使用了StrictMap是HashMap的一个子类
//先打 TODO 后面再分析吧。。。
  protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");
  protected final Map<String, Cache> caches = new StrictMap<Cache>("Caches collection");
  protected final Map<String, ResultMap> resultMaps = new StrictMap<ResultMap>("Result Maps collection");
  protected final Map<String, ParameterMap> parameterMaps = new StrictMap<ParameterMap>("Parameter Maps collection");
  protected final Map<String, KeyGenerator> keyGenerators = new StrictMap<KeyGenerator>("Key Generators collection");



  protected final Set<String> loadedResources = new HashSet<String>();
  protected final Map<String, XNode> sqlFragments = new StrictMap<XNode>("XML fragments parsed from previous mappers");

  protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<XMLStatementBuilder>();
  protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<CacheRefResolver>();
  protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<ResultMapResolver>();
  protected final Collection<MethodResolver> incompleteMethods = new LinkedList<MethodResolver>();

  /*
   * A map holds cache-ref relationship. The key is the namespace that
   * references a cache bound to another namespace and the value is the
   * namespace which the actual cache is bound to.
   */
  protected final Map<String, String> cacheRefMap = new HashMap<String, String>();

2.Configuration的构造函数

  public Configuration(Environment environment) {
    this();
    this.environment = environment;
  }

  //然后是Configuration默认构造函数的
  public Configuration() {
  //为常用配置名注册别名
    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);   //JDBC注册了JdbcTransactionFactory工厂
    typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);

    typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
    typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
    typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);

    typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
    typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
    typeAliasRegistry.registerAlias("LRU", LruCache.class);
    typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
    typeAliasRegistry.registerAlias("WEAK", WeakCache.class);

    typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);

    typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
    typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);

    typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
    typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
    typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
    typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
    typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
    typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
    typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);

    typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
    typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);

    languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);   //默认为XML
    languageRegistry.register(RawLanguageDriver.class);
  }

3.Configuration中成员变量的初始化

这里主要分析MapperRegistry、InterceptorChain、TypeHandlerRegistry、TypeAliasRegistry、LanguageDriverRegistry的实例化。

3.1.MapperRegistry的实例化

MapperRegistry实例化：主要是将Configuration传递给MapperRegistry，而MapperRegistry中维护了一个HashMap， 提供对Mapper的添加、判断是否存在、获取操作。

 protected final MapperRegistry mapperRegistry = new MapperRegistry(this);

这里写图片描述

public class MapperRegistry {

  private final Configuration config;  //这里的变量还是final修饰的
  private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();

  public MapperRegistry(Configuration config) {
    this.config = config;
  }
  ...
}

当使用Configuration中的getMapper方法时，其实调用了MapperRegistry中的public <T> T getMapper(Class<T> type, SqlSession sqlSession) 。在knownMappers的HashMap中拿到MapperProxyFactory代理工厂。

Configuration.java

  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }
MapperRegistry.java

  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

3.2.InterceptorChain

拦截器链，ArrayList实现。

public class InterceptorChain {

  private final List<Interceptor> interceptors = new ArrayList<Interceptor>();

  public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
  }

  public void addInterceptor(Interceptor interceptor) {
    interceptors.add(interceptor);
  }

  public List<Interceptor> getInterceptors() {
    return Collections.unmodifiableList(interceptors);
  }

}

3.3.TypeHandlerRegistry

主要用来注册类型转换器。
TypeHandler也就是我们在Mapper.xml中常见的jdbcType与javaType之间的映射关系。
内部使用HashMap来记录类型对应关系。

这里写图片描述

这里写图片描述

1.TypeHandler接口定义了获取sql查询结果的3种方式，以及设置参数的方法。可以看到，传递参数使用了JDBC的PreparedStatement，预处理sql。3中重载getResult()提供了根据列名，列索引获取sql查询结果的方法。实际上是对ResultSet和CallableStatement的封装。

2.BaseTypeHandler是个抽象类，并实现了TypeHandler接口。

public abstract class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T> {

  protected Configuration configuration;

  public void setConfiguration(Configuration c) {
    this.configuration = c;
  }

3.在这里所有的TypeHandler都继承自BaseTypeHandler。
同时使用了模板方法设计模式，定义了执行过程，具体的获取结果的方式，交给子类去实现。这样设计有极大的灵活性，当不能满足开发需要时，我们可以定义自己的TypeHandler~~

自定义TypeHandler的加载见XMLConfigBuilder#parseConfiguration(XNode root)#typeHandlerElement(root.evalNode("typeHandlers"));

同时可以看到BaseTypeHandler中持有Configuration的引用，所以说Configuration真是贯穿于Mybatis的整个生命周期。。。2333

4.那我们怎知道什么时候调用String类型的TypeHandler什么时候调用Integer类型的TypeHandler呢？ 再看BaseTypeHandler的定义 class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T>这里使用了泛型，T继承自TypeReference。这里是关键，TypeReference里记录了rawType，所以可以准确的调用到对应的TypeHandler去getResult。

5.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 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.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, UNKNOWN_TYPE_HANDLER);
    register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
    register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);

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

    // mybatis-typehandlers-jsr310
    try {
      // since 1.0.0
      register("java.time.Instant", "org.apache.ibatis.type.InstantTypeHandler");
      register("java.time.LocalDateTime", "org.apache.ibatis.type.LocalDateTimeTypeHandler");
      register("java.time.LocalDate", "org.apache.ibatis.type.LocalDateTypeHandler");
      register("java.time.LocalTime", "org.apache.ibatis.type.LocalTimeTypeHandler");
      register("java.time.OffsetDateTime", "org.apache.ibatis.type.OffsetDateTimeTypeHandler");
      register("java.time.OffsetTime", "org.apache.ibatis.type.OffsetTimeTypeHandler");
      register("java.time.ZonedDateTime", "org.apache.ibatis.type.ZonedDateTimeTypeHandler");
      // since 1.0.1
      register("java.time.Month", "org.apache.ibatis.type.MonthTypeHandler");
      register("java.time.Year", "org.apache.ibatis.type.YearTypeHandler");

    } catch (ClassNotFoundException e) {
      // no JSR-310 handlers
    }

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

3.4.TypeAliasRegistry的实例化

主要为java类设置别名，我们在xml中配置的TypeAlias也会被注册进来（详细执行过程见XMLConfigBuilder中的typeAliasesElement()方法）。

内部还是HashMap实现。Map<String, Class<?>> TYPE_ALIASES

在Configuration的默认构造方法中，注册了”JDBC”等全局的别名。

public class TypeAliasRegistry {

  private final Map<String, Class<?>> TYPE_ALIASES = new HashMap<String, Class<?>>();

  public TypeAliasRegistry() {
    registerAlias("string", String.class);

    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    registerAlias("short", Short.class);
    registerAlias("int", Integer.class);
    registerAlias("integer", Integer.class);
    registerAlias("double", Double.class);
    registerAlias("float", Float.class);
    registerAlias("boolean", Boolean.class);

    registerAlias("byte[]", Byte[].class);
    registerAlias("long[]", Long[].class);
    registerAlias("short[]", Short[].class);
    registerAlias("int[]", Integer[].class);
    registerAlias("integer[]", Integer[].class);
    registerAlias("double[]", Double[].class);
    registerAlias("float[]", Float[].class);
    registerAlias("boolean[]", Boolean[].class);

    registerAlias("_byte", byte.class);
    registerAlias("_long", long.class);
    registerAlias("_short", short.class);
    registerAlias("_int", int.class);
    registerAlias("_integer", int.class);
    registerAlias("_double", double.class);
    registerAlias("_float", float.class);
    registerAlias("_boolean", boolean.class);

    registerAlias("_byte[]", byte[].class);
    registerAlias("_long[]", long[].class);
    registerAlias("_short[]", short[].class);
    registerAlias("_int[]", int[].class);
    registerAlias("_integer[]", int[].class);
    registerAlias("_double[]", double[].class);
    registerAlias("_float[]", float[].class);
    registerAlias("_boolean[]", boolean[].class);

    registerAlias("date", Date.class);
    registerAlias("decimal", BigDecimal.class);
    registerAlias("bigdecimal", BigDecimal.class);
    registerAlias("biginteger", BigInteger.class);
    registerAlias("object", Object.class);

    registerAlias("date[]", Date[].class);
    registerAlias("decimal[]", BigDecimal[].class);
    registerAlias("bigdecimal[]", BigDecimal[].class);
    registerAlias("biginteger[]", BigInteger[].class);
    registerAlias("object[]", Object[].class);

    registerAlias("map", Map.class);
    registerAlias("hashmap", HashMap.class);
    registerAlias("list", List.class);
    registerAlias("arraylist", ArrayList.class);
    registerAlias("collection", Collection.class);
    registerAlias("iterator", Iterator.class);

    registerAlias("ResultSet", ResultSet.class);
  }

4.再说Configuration

Configuration的这种设计虽然违背了单一职责的设计原则，但也带来了极大的好处，我们可以在sqlsession、sqlsessionFactory中拿到Configuration进而拿到所有设置。

例如：

//获取所有注册的别名
Configuration configuration = sqlSessionFactory.getConfiguration();
TypeAliasRegistry typeAliasRegistry = configuration.getTypeAliasRegistry();
Map<String, Class<?>> typeAliases = typeAliasRegistry.getTypeAliases();
for (Map.Entry<String, Class<?>> entry : typeAliases.entrySet()) {
    System.out.println(entry.getKey() + "  " + entry.getValue());
}

//获取所有已注册的类型转换器
TypeHandlerRegistry typeHandlerRegistry = session.getConfiguration().getTypeHandlerRegistry();
Collection<TypeHandler<?>> typeHandlers = typeHandlerRegistry.getTypeHandlers();
for (Map.Entry<String, Class<?>> entry : typeAliases.entrySet()) {
    System.out.println(entry.getKey() + "  " + entry.getValue());
}

5.总结

1.首先Configuration是在XMLConfigBuilder的private XMLConfigBuilder(XPathParser parser, String environment, Properties props)构造器中创建的，这里涉及到XML配置文件解析成Configuration参见 mybatis源码学习之执行过程分析（2）——Mapper接口和XML文件映射及解析中的分析。

2.Configuration中的MapperRegistry、InterceptorChain、TypeHandlerRegistry、TypeAliasRegistry、LanguageDriverRegistry在Configuration构造方法调用之前进行了实例化和基本的设置。最后由Configuration中的final修饰的成员变量引用，所以在Mybatis的生命周期中，可以通过Configuration实例获取到这些注册的信息。

cai_cf
关注
专栏目录
MyBatis——configuration
奔跑8蜗牛
03-10 656
1、MyBatis配置 &lt;? xml version="1.0" encoding="utf-8"?&gt; &lt;configuration&gt; &lt;!-- 配置 --&gt; &lt;properties /&gt; &lt;!-- 属性 --&gt; &lt;settings /&gt; &lt;!-- 设置 --&
MyBatis(三) mybatis-config.xml元素说明、类型处理器typeHandler的使用
z1340954953
07-04 1172
xml文件中元素的层次注意这些元素的层次的顺序是不能打乱，可以通过工具的提示来定义元素
Mybatis 核心配置
cfa3288的博客
09-27 641
在MyBatis中我们发现其实他最核心的应该是那两个配置文件，一个全局配置文件，一个映射文件。我们只要把这两个文件弄清楚，其实对于MyBatis的使用就掌握了大部分。接下来我们详细的给大家来 介绍下这两个配置文件。
Mybatis TypeHandler 介绍及使用
最新发布
weixin_38687619的博客
08-08 359
TypeHandler类型转换器是负责Java类和jdbc类型之间的转换。主要涉及到下面这几个类：TypeHandler 类型转换器的顶层接口BaseTypeHandler 抽象类继承自TypeHandler，Mybatis中所有的类型转换器实现均继承他。TypeHandlerRegistry 类型转换器注册器，负责存储类型转换器。TypeAliasRegistry 类型别名转换器，用来存储类型与别名的对应关系。
mybatis-configuration容器(2)--类型处理注册表--TypeHandlerRegistry
weixin_44053668的博客
07-18 496
        这个handler的主要功能就是完成mysql的列值与java字段相互转换的处理器。那么这里就会出现两个种不同的的类型。 mysql的列类型叫做jdbcType(由jdbc提供); java的字段类型叫做javaType(由jdk提供); 首先我们先看一段熟悉的代码 public static void main(String[] args) { Connection conn = DriverMan
Mybatis技术内幕：初始化之<typeHandlers>标签
weixin_34049948的博客
02-27 202
&lt;typeAliases&gt;标签初始化 typeHandlerElement(XNode parent)方法解析&lt;typeAliases&gt;。 标签示例： &lt;typeHandlers&gt; &lt;typeHandler javaType="String" handler="org.apache.ibatis.builder.CustomStringTypeHa...
Mybatis源码解读——初始化过程详解
Java_supermanNO1的博客
09-22 212
在使用Mybatis时，我们通常将其配置在Spring容器中，当Spring启动的时候会自动加载Mybatis的所有配置文件然后生成注入到Spring中的Bean，本文从实用的角度进行Mybatis源码解读，会关注以下一些方面： Mybatis都有哪些配置文件和配置项 Mybatis初始化的源码流程； Mybatis初始化后，产生了哪些对象； Mybatis初始化环境并且执行SQL语句的JAV...
Mybatis源码分析.pdf
08-30
1. 加载配置并初始化：MyBatis读取全局配置文件、Mapper XML文件等，将SQL配置信息转化为MappedStatement对象存储在内存中。 2. 接收调用请求：当调用MyBatis API时，传入SQL的ID和参数对象。 3. 处理操作请求：这一...
Mybatis源码分析——mapper.xml解析
有米oooooooo
06-27 842
本系列的文章都是基于这个demo来分析的Mybatis入门，一个简单的demo 在源码分析过程中，会使用到一些额外的知识点，比如Mybatis中使用的spring接口Mybatis中使用的设计模式 Mybatis初始化配置文件分为两个阶段，如下 mybatis-config.xml解析 mapper.xml文件解析 本篇分析的是第二阶段。 上一篇讲到解析mapper.xml是在X...
五、Mybatis 核心对象之 Configuration 对象初始化详解
戴泽王的博客
05-13 1006
源码地址：https://github.com/RononoaZoro/mybatis-book/tree/master 的 mybatis-book ( mybatis-chapter04 ) 文章内容出自《Mybatis 3 源码深度解析》第四章 自己实现代码地址：https://github.com/RononoaZoro/mybatis-book/tree/master 的 archer-mybatis 1、说明 本文以 XML 格式配置文件为例子，详解 Configuration 的初始化过.
Mybatis源码解析——入门级
MinaandWanwan的博客
04-13 550
框架如何初始化？ 一、解析mybatis-config.xml核心配置，赋值给configuration对象 mybatis-config.xml这个文件主要是用于配置数据源、配置别名、加载mapper.xml。 mapper标签所指向的路径就是另外一个xml文件：xxxMapper.xml，而这个文件中写了我们查询数据库所用的SQL。 MyBatis实际上就是将这两个xml文件，解析成配置对象 二、执行，执行SQL语句，完成与JDBC的交互 ...
Mybatis-Configuration-详解
Franco的博客
11-25 840
Configuration MyBatis的初始化会执行SqlSessionFactoryBuilder的中build()方法,build方法又会调用XMLConfigBuilder()的内部parse()方法进行加载配置,所以我们先看一下parse()的源码: public Configuration parse() { if (parsed) { throw new Build...
mybatis启动过程分析 typehandler
zhenghuangyu的博客
12-23 455
本节介绍typehandler的解析，在mybatis中typehandler主要是用于类型转换的比如数据库中是varchar2而Java bean中是string 或者 integer等，需要使用typehandler，typehander的解析使用如下的方法 配置typehander可以使用package包扫描的方式也可以挨个配置 &amp;lt;configuration&amp;gt; &amp;lt;...
Mybatis 基础篇（四）-- 深入了解 XML 配置（typeAliases、typeHandlers）
IBIT程序猿
06-23 456
类型别名（typeAliases） 还记得 Mybatis 基础篇（二）-- 深入了解 XML 配置（environments） <datasource type="UNPOOLED"> ... </datasource> 其中 UNPOOLED 是类 UnpooledDataSourceFactory 的别名。 类型别名介绍 类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。例如： <typeAliases>
MyBatis之BaseTypeHandler
thebigdipperbdx的博客
10-10 6320
MyBatis官方文档 MyBatis官方文档 ORM框架 源码 package org.apache.ibatis.type; import java.sql.CallableStatement; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; imp...
Mybatis源码学习(11)-类型处理器之TypeHandlerRegistry、TypeAliasRegistry、Alias、MappedJdbcTypes、MappedTypes
向心行者
09-17 7140
一、概述   Mybatis类型转换模块，除了定义了一些列的类型处理器（类型转换器）外，还提供了一些其他类，比如：类型处理器注册器类、别名注解类等。主要包含了以下类： Alias 注解类 别名注解 JdbcType 枚举类 JdbcType枚举类，对应数据库表中字段的类型 MappedJdbcTypes 注解类 用于指明类型处理器可以处理的JdbcType中的类型集合 MappedTypes 注...
typehandler的使用
realizeamg的专栏
02-18 353
在iBatis中（现在已经更名为mybatis),当要实现在某个数据表字段和POJO的 property之间做特殊类型的转换时，如果两个类型转换不是iBatis默认支持的，需 要自己实现一个TypeHandler来满足要求。TypeHandler是iBatis中定义的接口 public interface TypeHandler { public void setParameter(P...
Spring中Bean的作用域有哪些？
qq_42855346的博客
12-29 1180
singleton：单例模式，在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例 prototype：原型模式，每次通过容器的getBean方法获取prototype定义的Bean时，都将产生一个新的Bean实例 request：对于每次HTTP请求，使用request定义的Bean都将产生一个新实例，即每次HTTP请求将会产生不同的Bean实例。只有在Web应用...
第五篇：Configuration-3之TypeHandler
zxc_user的博客
07-11 265
源码之TypeHandler
MyBatis 初始化原理详解：Configuration 对象的创建过程
MyBatis 的初始化过程是指加载框架所需的配置信息，并将其组装成一个完整的 Configuration 对象。下面将详细介绍 MyBatis 的初始化原理。 一、MyBatis 的初始化做了什么 MyBatis 的初始化过程主要是加载框架所需的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值