mybatis源码分析(一) 配置文件的解析过程

mybatis的源码有人已经做过一个中文的注释,代码github上有mybatis中文注释源码

mybatis框架有两个非常重要的xml文件,一个是mybatis的config文件,一个就是mapper文件,mybatis会根据config的xml文件去生成一个Configuration类,在这个过程中也会根据配置的mapper文件生成MappedStatement,这篇博客探究的就是这样一个过程,往下看

如果单单使用mybatis,我们的做法是导包,配置,然后如下

String resource = "org/mybatis/example/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
try (SqlSession session = sqlSessionFactory.openSession()) {
  BlogMapper mapper = session.getMapper(BlogMapper.class);
  Blog blog = mapper.selectBlog(101);
}

所以从SqlSessionFactoryBuilder().build说起,点击进入build方法,新建了一个XMLConfigBuilder,然后build(parser.parse()),

XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
return build(parser.parse());

先看parser.parse()方法,这方法中将之前的mybatis的xml文件进行解析,生成了Configration类返回,

//解析配置
  private void parseConfiguration(XNode root) {
    try {
      //分步骤解析
      //issue #117 read properties first
      //1.properties
      propertiesElement(root.evalNode("properties"));
      //2.类型别名
      typeAliasesElement(root.evalNode("typeAliases"));
      //3.插件
      pluginElement(root.evalNode("plugins"));
      //4.对象工厂
      objectFactoryElement(root.evalNode("objectFactory"));
      //5.对象包装工厂
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      //6.设置
      settingsElement(root.evalNode("settings"));
      // read it after objectFactory and objectWrapperFactory issue #631
      //7.环境
      environmentsElement(root.evalNode("environments"));
      //8.databaseIdProvider
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      //9.类型处理器
      typeHandlerElement(root.evalNode("typeHandlers"));
      //10.映射器
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

仔细分析这几行代码,首先看第一个properties解析

//1.properties
  //
  //    
  //    
  //
  private void propertiesElement(XNode context) throws Exception {
    if (context != null) {
      //如果在这些地方,属性多于一个的话,MyBatis 按照如下的顺序加载它们:

      //1.在 properties 元素体内指定的属性首先被读取。
      //2.从类路径下资源或 properties 元素的 url 属性中加载的属性第二被读取,它会覆盖已经存在的完全一样的属性。
      //3.作为方法参数传递的属性最后被读取, 它也会覆盖任一已经存在的完全一样的属性,这些属性可能是从 properties 元素体内和资源/url 属性中加载的。
      //传入方式是调用构造函数时传入,public XMLConfigBuilder(Reader reader, String environment, Properties props)

      //1.XNode.getChildrenAsProperties函数方便得到孩子所有Properties
      Properties defaults = context.getChildrenAsProperties();
      //2.然后查找resource或者url,加入前面的Properties
      String resource = context.getStringAttribute("resource");
      String url = context.getStringAttribute("url");
      if (resource != null && url != null) {
        throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
      }
      if (resource != null) {
        defaults.putAll(Resources.getResourceAsProperties(resource));
      } else if (url != null) {
        defaults.putAll(Resources.getUrlAsProperties(url));
      }
      //3.Variables也全部加入Properties
      Properties vars = configuration.getVariables();
      if (vars != null) {
        defaults.putAll(vars);
      }
      parser.setVariables(defaults);
      configuration.setVariables(defaults);
    }
  }

具体的xml解析过程就没必要详细看了,最后可以看到所有的properties都被存入了Configuration的variables变量中,

然后往下看类型别名的解析,关于别名,首先Configuration类中定义了一个TypeAliasRegistry

//类型别名注册机
  protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();

这个TypeAliasRegistry中有一个Map存放了别名和别名的类

private final Map> TYPE_ALIASES = new HashMap>();

所以typeAliasesElement(root.evalNode("typeAliases"))这个方法中的操作就是解析出别名放入这个map中,定义别名的两种方式具体可以看官网。

再往下看,插件的解析

//3.插件
  //MyBatis 允许你在某一点拦截已映射语句执行的调用。默认情况下,MyBatis 允许使用插件来拦截方法调用
//
//  
//    
//  
//  
  private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        String interceptor = child.getStringAttribute("interceptor");
        Properties properties = child.getChildrenAsProperties();
        Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
        interceptorInstance.setProperties(properties);
        //调用InterceptorChain.addInterceptor
        configuration.addInterceptor(interceptorInstance);
      }
    }
  }

插件虽然比较复杂,但是解析的部分却很简单,主要是resolveClass方法

//根据别名解析Class,其实是去查看 类型别名注册/事务管理器别名
  protected Class resolveClass(String alias) {
    if (alias == null) {
      return null;
    }
    try {
      return resolveAlias(alias);
    } catch (Exception e) {
      throw new BuilderException("Error resolving class. Cause: " + e, e);
    }
  }

这个别名的解析过程其实就是去之前说的那个别名的map中查询,有的话就返回,没的话就直接转成Class,所以mybatis里面很多配置属性type="xxx"的,例如datasource的type="POOLED",这个POOLED其实就是类型的别名。最后获取到Class之后newInstance创建一个对象,放入Interceptor拦截器链中,这个拦截器链和SpringMvc类似,其实就是一个拦截器链对象InterceptorChain里面放了一个List集合,调用的时候for循环依次调用,去看看代码

protected final InterceptorChain interceptorChain = new InterceptorChain();

Configuration类中定义了这样一个过滤器链,后面某个地方肯定会执行pluginAll方法

public Object pluginAll(Object target) {
    //循环调用每个Interceptor.plugin方法
    for (Interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
  }

这地方用过插件就很熟悉了,plugin方法中我们基本都这样写,而这个方法就是创建了一个代理对象

return Plugin.wrap(target, this);
public static Object wrap(Object target, Interceptor interceptor) {
    //取得签名Map
    Map, Set> signatureMap = getSignatureMap(interceptor);
    //取得要改变行为的类(ParameterHandler|ResultSetHandler|StatementHandler|Executor)
    Class type = target.getClass();
    //取得接口
    Class[] interfaces = getAllInterfaces(type, signatureMap);
    //产生代理
    if (interfaces.length > 0) {
      return Proxy.newProxyInstance(
          type.getClassLoader(),
          interfaces,
          new Plugin(target, interceptor, signatureMap));
    }
    return target;
  }

先看获取签名getSignatureMap这个方法

//取得签名Map
  private static Map, Set> getSignatureMap(Interceptor interceptor) {
    //取Intercepts注解,例子可参见ExamplePlugin.java
    Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
    // issue #251
    //必须得有Intercepts注解,没有报错
    if (interceptsAnnotation == null) {
      throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());      
    }
    //value是数组型,Signature的数组
    Signature[] sigs = interceptsAnnotation.value();
    //每个class里有多个Method需要被拦截,所以这么定义
    Map, Set> signatureMap = new HashMap, Set>();
    for (Signature sig : sigs) {
      Set methods = signatureMap.get(sig.type());
      if (methods == null) {
        methods = new HashSet();
        signatureMap.put(sig.type(), methods);
      }
      try {
        Method method = sig.type().getMethod(sig.method(), sig.args());
        methods.add(method);
      } catch (NoSuchMethodException e) {
        throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
      }
    }
    return signatureMap;
  }

这里从我们注释在拦截器插件的类注解Intercepts 上获取Signature数组,循环数组,解析结果放入signatureMap中,signatureMap是一个Class为键,Method的Set列表为Value的Map,说白了这个解析结果就是一个对象中需要拦截的哪几个方法。

再回头往下看,

很熟悉的动态代理方法,因为传入的InvocationHandler也是Plugin这个类,所以invoke方法也在这个类中

@Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      //看看如何拦截
      Set methods = signatureMap.get(method.getDeclaringClass());
      //看哪些方法需要拦截
      if (methods != null && methods.contains(method)) {
        //调用Interceptor.intercept,也即插入了我们自己的逻辑
        return interceptor.intercept(new Invocation(target, method, args));
      }
      //最后还是执行原来逻辑
      return method.invoke(target, args);
    } catch (Exception e) {
      throw ExceptionUtil.unwrapThrowable(e);
    }
  }

分析一下这段代码,这就是从刚才解析的需要拦截的方法的Map中取出该类的拦截列表方法,看看是不是包括当前的方法,是的话就执行intercept也就是我们写的那些拦截方法。再最后执行方法本身的逻辑。标准老套娃!

再回到XMLConfigBuilder中,接着往下

//4.对象工厂
  objectFactoryElement(root.evalNode("objectFactory"));

这个就是解析出一个类方法放到Configuration的objectFactory中,覆盖它默认的对象工厂

然后是解析对象包装工厂,反射器工厂,settings,environments等等原理和之前都差不多,所以跳过,

看重点最后一个mapperElement方法

//10.映射器
//    10.1使用类路径
//    
//      
//      
//      
//    
//
//    10.2使用绝对url路径
//    
//      
//      
//      
//    
//
//    10.3使用java类名
//    
//      
//      
//      
//    
//
//    10.4自动扫描包下所有映射器
//    
//      
//    
  private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          //10.4自动扫描包下所有映射器
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        } else {
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          if (resource != null && url == null && mapperClass == null) {
            //10.1使用类路径
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            //映射器比较复杂,调用XMLMapperBuilder
            //注意在for循环里每个mapper都重新new一个XMLMapperBuilder,来解析
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            //10.2使用绝对url路径
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            //映射器比较复杂,调用XMLMapperBuilder
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
            //10.3使用java类名
            Class mapperInterface = Resources.classForName(mapperClass);
            //直接把这个映射加入配置
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
  }

直接看package的解析,其实 这种形式解析过程也类似,关键都是调用了configuration.addMapper这个方法,所以直接看这个方法,这个方法在Configuration类的mapperRegistry中

//看一下如何添加一个映射
  public  void addMapper(Class type) {
    //mapper必须是接口!才会添加
    if (type.isInterface()) {
      if (hasMapper(type)) {
        //如果重复添加了,报错
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        knownMappers.put(type, new MapperProxyFactory(type));
        // It's important that the type is added before the parser is run
        // otherwise the binding may automatically be attempted by the
        // mapper parser. If the type is already known, it won't try.
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        //如果加载过程中出现异常需要再将这个mapper从mybatis中删除,这种方式比较丑陋吧,难道是不得已而为之?
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

重点就是new MapperProxyFactory(type),这里将存入一个Mapper的代理工厂类。

再往下看,创建了一个MapperAnnotationBuilder,然后再看parse方法。

public void parse() {
    String resource = type.toString();
    if (!configuration.isResourceLoaded(resource)) {
      loadXmlResource();
      configuration.addLoadedResource(resource);
      assistant.setCurrentNamespace(type.getName());
      parseCache();
      parseCacheRef();
      Method[] methods = type.getMethods();
      for (Method method : methods) {
        try {
          // issue #237
          if (!method.isBridge()) {
            parseStatement(method);
          }
        } catch (IncompleteElementException e) {
          configuration.addIncompleteMethod(new MethodResolver(this, method));
        }
      }
    }
    parsePendingMethods();
  }

首先configuration.isResourceLoaded会判断是否加载了mapper的xml,很显然,如果用package方式的,走到这一步,就只是找到了接口,将代理工厂存入map中,并没有去加载xml,所以会loadXmlResource()

private void loadXmlResource() {
    // Spring may not know the real resource name so we check a flag
    // to prevent loading again a resource twice
    // this flag is set at XMLMapperBuilder#bindMapperForNamespace
    if (!configuration.isResourceLoaded("namespace:" + type.getName())) {
      String xmlResource = type.getName().replace('.', '/') + ".xml";
      InputStream inputStream = null;
      try {
        inputStream = Resources.getResourceAsStream(type.getClassLoader(), xmlResource);
      } catch (IOException e) {
        // ignore, resource is not required
      }
      if (inputStream != null) {
        XMLMapperBuilder xmlParser = new XMLMapperBuilder(inputStream, assistant.getConfiguration(), xmlResource, configuration.getSqlFragments(), type.getName());
        xmlParser.parse();
      }
    }
  }

这里将接口全面的.替换成了/,所以假如接口是a.test,那xml就一定得是a/test.xml,然后会新建一个XMLMapperBuilder,这里可以回去mapperElement方法中看的解析,也是通过XMLMapperBuilder,所以这些解析方式其实大同小异,然后再看XMLMapperBuilder的parse方法

//解析
  public void parse() {
    //如果没有加载过再加载,防止重复加载
    if (!configuration.isResourceLoaded(resource)) {
      //配置mapper
      configurationElement(parser.evalNode("/mapper"));
      //标记一下,已经加载过了
      configuration.addLoadedResource(resource);
      //绑定映射器到namespace
      bindMapperForNamespace();
    }

    //还有没解析完的东东这里接着解析?  
    parsePendingResultMaps();
    parsePendingChacheRefs();
    parsePendingStatements();
  }

先看configurationElement方法

//配置mapper元素
//    
//      
//    
  private void configurationElement(XNode context) {
    try {
      //1.配置namespace
      String namespace = context.getStringAttribute("namespace");
      if (namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      //2.配置cache-ref
      cacheRefElement(context.evalNode("cache-ref"));
      //3.配置cache
      cacheElement(context.evalNode("cache"));
      //4.配置parameterMap(已经废弃,老式风格的参数映射)
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      //5.配置resultMap(高级功能)
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      //6.配置sql(定义可重用的 SQL 代码段)
      sqlElement(context.evalNodes("/mapper/sql"));
      //7.配置select|insert|update|delete TODO
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
    }
  }

首先看cache-ref的解析

//2.配置cache-ref,在这样的 情况下你可以使用 cache-ref 元素来引用另外一个缓存。 
//
  private void cacheRefElement(XNode context) {
    if (context != null) {
      //增加cache-ref
      configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
      CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
      try {
        cacheRefResolver.resolveCacheRef();
      } catch (IncompleteElementException e) {
        configuration.addIncompleteCacheRef(cacheRefResolver);
      }
    }
  }

先往configuration中存放cache-ref的map中添加当前解析的cache-ref的namespace,然后创建一个cache-ref解析器解析,

public Cache resolveCacheRef() {
      //反调MapperBuilderAssistant解析
    return assistant.useCacheRef(cacheRefNamespace);
  }
public Cache useCacheRef(String namespace) {
    if (namespace == null) {
      throw new BuilderException("cache-ref element requires a namespace attribute.");
    }
    try {
      unresolvedCacheRef = true;
      Cache cache = configuration.getCache(namespace);
      if (cache == null) {
        throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.");
      }
      currentCache = cache;
      unresolvedCacheRef = false;
      return cache;
    } catch (IllegalArgumentException e) {
      throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.", e);
    }
  }

这里调用的是MapperBuilderAssistant这个助手的方法,而在这个助手类中,逻辑是这样的,去configuration的cache的map中获取cache,如果cache已经创建了,就返回。如果还没有创建,那么就抛出一个IncompleteElementException异常,异常被外部捕获,将当前cache-ref的解析器放入一个用来存放未完成cache-ref解析的列表中。

然后接下来解析cache,

//3.配置cache
  cacheElement(context.evalNode("cache"));

方法中依旧是调用助手类的方法

//调用builderAssistant.useNewCache
      builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);

接下来的几个resultmap,sql等解析的过程基本类似。

当前解析完成之后,再往下看,会去解析之前未完全解析的各类对象,进入第一个方法

private void parsePendingResultMaps() {
    Collection incompleteResultMaps = configuration.getIncompleteResultMaps();
    synchronized (incompleteResultMaps) {
      Iterator iter = incompleteResultMaps.iterator();
      while (iter.hasNext()) {
        try {
          iter.next().resolve();
          iter.remove();
        } catch (IncompleteElementException e) {
          // ResultMap is still missing a resource...
        }
      }
    }
  }

之前存入map中的未完全解析的解析器取出循环调用之前同样的方法,而在此刻,之前需要等待创建的对象现在都已经创建完成,所以可以完成创建(我想了一下,这里面好像没有a需要b,b需要c的这种,被依赖的好像都是没有需要依赖的)。

再回到MapperAnnotationBuilder中,接下去是方法的注解解析,和之前xml的区别就是解析的方法,跳过。

最终SqlSessionFactoryBuilder会执行到这行代码,生成一个DefaultSqlSessionFactory

public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

到此解析结束。

关注公众号:java宝典
a

你可能感兴趣的:(java)