Mybatis源码分析（5）---配置节点typeAliases源码解析

最新推荐文章于 2023-04-24 22:49:40 发布

午托饭

最新推荐文章于 2023-04-24 22:49:40 发布

阅读量213

点赞数

分类专栏： Mybatis 文章标签： mybatis 源码

本文链接：https://blog.csdn.net/qq_40685915/article/details/90547935

版权

Mybatis 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

背景
在上篇Mybatis源码分析（4）—配置节点settings源码解析中，我们通过settings节点在于XMLConfigBuilder类中的settingsAsProperties(XNode context)、loadCustomVfs(Properties props)、loadCustomLogImpl(Properties props)以及settingsElement(Properties props)等方法源码分析，了解了mybatis的整个settings节点的源码解析过程。
今天接下来我们将对节点typeAliases进行源码分析，分析之前，依然先通过以下图来重温一下之前SqlSessionFactory对象创建的过程：

我们依然围绕着Demo工程mybatisCode对节点typeAliases进行深入的解析和测试
节点typeAliases介绍
顾名思义：typeAliases直译：类型别名，为Java 类型设置的一个短的名字，它只和 XML 配置有关，存在的意义仅在于用来减少类完全限定名的冗余（本介绍来源于mybatis官网）。
类型别名（typeAliases）在mybatis-config.xml中的配置的方式可以有两种，我们拿Demo工程mybatisCode中的配置来讲解：

以上截图中，我可以看到，节点typeAliases可以不配置，但是如果配置的话，可以直接配置元素节点：package和typeAlias。package配置属性name为包路径，typeAlias配置的type为类完全限定名，alias为别名，
那么问题来了！

问题1：如果我们的mybatis-config.xml中不配置节点typeAliases，mybatis在解析配置文件的时候会做什么？
问题2：如果配置了节点typeAliases信息，解析节点元素package和typeAlias顺序和方式是什么？
带着上面两个问题，我们接下来就开始对节点typeAliases源码进行深入的分析！

节点typeAliases源码分析

节点typeAliases源码解析的位置在XMLConfigBuilder类中typeAliasesElement(XNode parent)方法中

  private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      /**************解析节点typeAliases**************/
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }
  private void typeAliasesElement(XNode parent) {
    if (parent != null) {
      //遍历节点typeAliases的所有子元素
      for (XNode child : parent.getChildren()) {
        //如果配置的子元素为package
        if ("package".equals(child.getName())) {
          //获取package的属性name中的包路径名
          String typeAliasPackage = child.getStringAttribute("name");
          //注册到全局配置类Configuration中的TypeAliasRegistry类别名容器中
          configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
        } else {
          //如果配置的子元素是typeAlias，则获取alias别名和type类完全限定名
          String alias = child.getStringAttribute("alias");
          String type = child.getStringAttribute("type");
          try {
            //反射获取type的Class对象
            Class<?> clazz = Resources.classForName(type);
            //注册到全局配置类Configuration中的TypeAliasRegistry类别名容器中
            if (alias == null) {
              //如果alias没有配置
              typeAliasRegistry.registerAlias(clazz);
            } else {
              //如果alias配置了
              typeAliasRegistry.registerAlias(alias, clazz);
            }
          } catch (ClassNotFoundException e) {
            throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
          }
        }
      }
    }
  }

我们通过上面源码剖析总结：
1.解析节点：typeAliases的子元素解析顺序可以说是先package后typeAlias；
2.typeAlias中alias别名可以配置或者不配置，两者区别是什么，接下来我们将继续分析；
3.不管是package还是typeAlias元素节点配置，最终均注册到mybatis的全局配置类Configuration中的TypeAliasRegistry容器中；

package元素源码解析过程
通过源码解析分析上面我们知道typeAliases节点中元素package，最终获取到的属性name中的包路径，然后调用mybatis的全局配置类Configuration中的TypeAliasRegistry容器类的 registerAliases(String packageName)方法进行注册。接下来我们顺着源码的调用看看package元素中的包路径是怎么注册到TypeAliasRegistry容器中的；

public class TypeAliasRegistry {
  private final Map<String, Class<?>> typeAliases = new HashMap<>();
  public void registerAliases(String packageName) {
    //实际调用的是registerAliases(String packageName, Class<?> superType)
    registerAliases(packageName, Object.class);
  }
  public void registerAliases(String packageName, Class<?> superType) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
    for (Class<?> type : typeSet) {
      // Ignore inner classes and interfaces (including package-info.java)
      // Skip also inner classes. See issue #6
      if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
        registerAlias(type);
      }
    }
  }
  public void registerAlias(Class<?> type) {
    String alias = type.getSimpleName();
    Alias aliasAnnotation = type.getAnnotation(Alias.class);
    if (aliasAnnotation != null) {
      alias = aliasAnnotation.value();
    }
    registerAlias(alias, type);
  }
  public void registerAlias(String alias, Class<?> value) {
    if (alias == null) {
      throw new TypeException("The parameter alias cannot be null");
    }
    // 把解析完后的包路径下的bean的首字母进行小写
    String key = alias.toLowerCase(Locale.ENGLISH);
    if (typeAliases.containsKey(key) && typeAliases.get(key) != null && !typeAliases.get(key).equals(value)) {
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + typeAliases.get(key).getName() + "'.");
    }
    // 最终解析完之后包路径下的所有类的别名作为key，类的Class对象作为Value保存在TypeAliasRegistry容器中
    //注意：typeAliases为一个HashMap集合
    typeAliases.put(key, value);
  }
}

上面的源码调用链路比较长，这里就不具体的一一解释，我们重点落在两个地方：
1.解析完后的包路径下的bean的首字母进行小写；
2.包路径下的所有类的别名作为key，类的Class对象作为Value保存在typeAliases中
总结：package元素解析，就是扫描包下的所有bean，然后默认别名为类名的首字母小写，最终注册到全局配置类Configuration中的TypeAliasRegistry容器类中，容器中实际使用的是HashMap来存储：bean的首字母小写为作为key,bean的Class对象为Value。

typeAlias元素源码解析过程

public class TypeAliasRegistry {
  public void registerAlias(Class<?> type) {
    //获取类的简写名称(不包含包路径)
    String alias = type.getSimpleName();
    //如果类上面有注解@Alias则注解中的值作为类别名，否则类名默认为类的简写名称
    Alias aliasAnnotation = type.getAnnotation(Alias.class);
    if (aliasAnnotation != null) {
      alias = aliasAnnotation.value();
    }
    registerAlias(alias, type);
  }

  public void registerAlias(String alias, Class<?> value) {
    if (alias == null) {
      throw new TypeException("The parameter alias cannot be null");
    }
    // 最终别名的命名规则都进行首字母小写
    String key = alias.toLowerCase(Locale.ENGLISH);
    if (typeAliases.containsKey(key) && typeAliases.get(key) != null && !typeAliases.get(key).equals(value)) {
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + typeAliases.get(key).getName() + "'.");
    }
    // 最终解析完之后typeAlias中配置的类别名作为key，类的Class对象作为Value保存在TypeAliasRegistry容器中
    typeAliases.put(key, value);
  }
}

总结：
1.typeAlias中的属性type进行对bean反射获取它的Class对象
2.属性alias没配置，就使用bean本身的类的简写名称(不包含包路径)，如果bean的类上面有注解@Alias("")，则以注解中的值作为类别名，别名都默认进行首字母小写。
3.最终注册到全局配置类Configuration中的TypeAliasRegistry容器类中，bean的别名首字母小写为作为key,bean的Class对象为Value；
4.源码分析到这里，我们解决了一开始提出的问题2：解析节点元素package和typeAlias顺序和方式是什么？那么问题1：如果不配置节点typeAliases的时候，mybatis自己会做些什么呢？接下来我们就开始寻找问题的答案；

无节点typeAliases配置源码分析

首先我们来回顾XMLConfigBuilder实例化时父类BaseBuilder中的全局配置类Configuration初始化的地方

public class XMLConfigBuilder extends BaseBuilder {
  private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
    //初始化mybatis的全局配置类，调用的是无参构造方法
    super(new Configuration());
    ErrorContext.instance().resource("SQL Mapper Configuration");
    this.configuration.setVariables(props);
    this.parsed = false;
    this.environment = environment;
    this.parser = parser;
  }
}

Configuration的无参构造方法

public class Configuration  {
  protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
  public Configuration() {
    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
    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);
    languageRegistry.register(RawLanguageDriver.class);
  }
}

看到这里我们知道了，mybatis在初始化全局配置类Configuration的时候在其无参构造方法，自动注册了一堆bean别名和他们的Class对象到typeAliasRegistry容器类中，而节点typeAliases配置的别名最终也是注册到typeAliasRegistry容器类中，为了方便后面直接获取调用；
当然事情还没结束，我们接着来窥探typeAliasRegistry类别名注册容器的内部。

public class TypeAliasRegistry {
  private final Map<String, Class<?>> typeAliases = new HashMap<>();

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

看到没有，TypeAliasRegistry 本身在初始化的时候，也会自动注册一些bean的别名和Class对象到自身最终存储HashMap中去，而这些大多是我们常常用到的基本类型的包装类和数组，字符串，集合等等，所以就算我们做相关的节点typeAliases配置，mybatis通过全局配置类Configuration，以其属性中的类别名注册容器TypeAliasRegistry为我们提前准备好了很多实用和常用的类别名，方便我们后期的调用。

节点typeAliases配置的好处
上面对mybatis-config.xml配置文件节点typeAliases在源码中的解析分析了半天，我们接下来就来讲讲节点typeAliases配置的好处是什么？
好处就是，让我们mapper等映射文件中写sql的时候，不需要把类的完全路径全部写出来，直接写别名，mybatis通过类别名注册容器TypeAliasRegistry可以自动帮我们找到Class对象，通过反射进行一系列的操作，使用上更方便；
还有就是提前注册好了mybatis常常需要使用的一些类别名和他们的Class对象，不需要等用的时候在进行加载

午托饭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis源码分析（5）---配置节点typeAliases源码解析

背景在上篇Mybatis源码分析（4）—配置节点settings源码解析中，我们通过settings节点在于XMLConfigBuilder类中的settingsAsProperties(XNode context)、loadCustomVfs(Properties props)、loadCustomLogImpl(Properties props)以及settingsElement(Prop...
复制链接

扫一扫

专栏目录