135-1821-9792

Mybatis是如何解析配置文件的？看完终于明白了

在以前文章中，我们把Mybatis源码阅读的整个流程梳理了一遍。今天，我们来详细聊聊，Mybatis是如何解析配置文件的。

创新互联为您提适合企业的网站设计 让您的网站在搜索引擎具有高度排名，让您的网站具备超强的网络竞争力！结合企业自身，进行网站设计及把握，最后结合企业文化和具体宗旨等，才能创作出一份性化解决方案。从网站策划到成都网站制作、网站设计， 我们的网页设计师为您提供的解决方案。

这是今天分析的流程图：

还是从案例开始。

demo案例

 
 
 
 
    
  
  
  
  
  1. public static void main(String[] args) { 
    2.   
  
  
  
  2.         String resource = "mybatis-config.xml"; 
    3.   
  
  
  
  3.         InputStream inputStream = null; 
    4.   
  
  
  
  4.         SqlSession sqlSession = null; 
    5.   
  
  
  
  5.         try { 
    6.   
  
  
  
  6.             inputStream = Resources.getResourceAsStream(resource); 
    7.   
  
  
  
  7.             SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); 
    8.   
  
  
  
  8.             sqlSession = sqlSessionFactory.openSession(); 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.             UserMapper userMapper = sqlSession.getMapper(UserMapper.class); 
    11.   
  
  
  
  11.             System.out.println(userMapper.selectById(1)); 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.         } catch (Exception e) { 
    14.   
  
  
  
  14.             e.printStackTrace(); 
    15.   
  
  
  
  15.         } finally { 
    16.   
  
  
  
  16.             try { 
    17.   
  
  
  
  17.                 inputStream.close(); 
    18.   
  
  
  
  18.             } catch (IOException e) { 
    19.   
  
  
  
  19.                 e.printStackTrace(); 
    20.   
  
  
  
  20.             } 
    21.   
  
  
  
  21.             sqlSession.close(); 
    22.   
  
  
  
  22.         } 
    23.   
  
  
  
  23.     } 
    24.

见证奇迹

从SqlSessionFactoryBuilder开始。

SqlSessionFactoryBuilder类

 
 
 
 
    
  
  
  
  
  1. org.apache.ibatis.session.SqlSessionFactoryBuilder 
    2.

该类里全是build方法各种重载。

 
 
 
 
    
  
  
  
  
  1. //这个方法啥也没干   
    2.   
  
  
  
  2. public SqlSessionFactory build(InputStream inputStream) { 
    3.   
  
  
  
  3.     return build(inputStream, null, null); 
    4.   
  
  
  
  4.  } 
    5.

最终来到另外一个build方法里：

 
 
 
 
    
  
  
  
  
  1. public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { 
    2.   
  
  
  
  2.    try { 
    3.   
  
  
  
  3.      //创建一个XMLConfigBuilder对象   
    4.   
  
  
  
  4.      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties); 
    5.   
  
  
  
  5.      return build(parser.parse()); 
    6.   
  
  
  
  6.    } catch (Exception e) { 
    7.   
  
  
  
  7.      throw ExceptionFactory.wrapException("Error building SqlSession.", e); 
    8.   
  
  
  
  8.    } finally { 
    9.   
  
  
  
  9.      ErrorContext.instance().reset(); 
    10.   
  
  
  
  10.      try { 
    11.   
  
  
  
  11.        inputStream.close(); 
    12.   
  
  
  
  12.      } catch (IOException e) { 
    13.   
  
  
  
  13.        // Intentionally ignore. Prefer previous error. 
    14.   
  
  
  
  14.      } 
    15.   
  
  
  
  15.    } 
    16.   
  
  
  
  16.  } 
    17.

XMLConfigBuilder类

该类的构造方法重载：

首先进入：

 
 
 
 
    
  
  
  
  
  1. public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) { 
    2.   
  
  
  
  2.     this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment,      
    3.   
  
  
  
  3.          props); 
    4.   
  
  
  
  4. } 
    5.   
  
  
  
  5. private XMLConfigBuilder(XPathParser parser, String environment, Properties props) { 
    6.   
  
  
  
  6.     super(new Configuration()); 
    7.   
  
  
  
  7.     ErrorContext.instance().resource("SQL Mapper Configuration"); 
    8.   
  
  
  
  8.     this.configuration.setVariables(props); 
    9.   
  
  
  
  9.     this.parsed = false; 
    10.   
  
  
  
  10.     this.environment = environment; 
    11.   
  
  
  
  11.     this.parser = parser; 
    12.   
  
  
  
  12. } 
    13.

build(parser.parse());中的parser.parse();

mybatis-config.xml在哪里解析的呢?

请看下面这个方法：

 
 
 
 
    
  
  
  
  
  1. //该方法返回一个Configuration对象 
    2.   
  
  
  
  2. public Configuration parse() { 
    3.   
  
  
  
  3.   if (parsed) { 
    4.   
  
  
  
  4.     throw new BuilderException("Each XMLConfigBuilder can only be used once."); 
    5.   
  
  
  
  5.   } 
    6.   
  
  
  
  6.   parsed = true; 
    7.   
  
  
  
  7.   //关键点 
    8.   
  
  
  
  8.   parseConfiguration(parser.evalNode("/configuration")); 
    9.   
  
  
  
  9.   return configuration; 
    10.   
  
  
  
  10. } 
    11.

parseConfiguration(parser.evalNode("/configuration"));

终于看到开始解析配置文件了:

进入方法parseConfiguration。

 
 
 
 
    
  
  
  
  
  1. private void parseConfiguration(XNode root) { 
    2.   
  
  
  
  2.   try { 
    3.   
  
  
  
  3.     //issue #117 read properties first 
    4.   
  
  
  
  4.     propertiesElement(root.evalNode("properties")); 
    5.   
  
  
  
  5.     Properties settings = settingsAsProperties(root.evalNode("settings")); 
    6.   
  
  
  
  6.     loadCustomVfs(settings); 
    7.   
  
  
  
  7.     loadCustomLogImpl(settings); 
    8.   
  
  
  
  8.     typeAliasesElement(root.evalNode("typeAliases")); 
    9.   
  
  
  
  9.     pluginElement(root.evalNode("plugins")); 
    10.   
  
  
  
  10.     objectFactoryElement(root.evalNode("objectFactory")); 
    11.   
  
  
  
  11.     objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); 
    12.   
  
  
  
  12.     reflectorFactoryElement(root.evalNode("reflectorFactory")); 
    13.   
  
  
  
  13.     settingsElement(settings); 
    14.   
  
  
  
  14.     // read it after objectFactory and objectWrapperFactory issue #631 
    15.   
  
  
  
  15.     environmentsElement(root.evalNode("environments")); 
    16.   
  
  
  
  16.     databaseIdProviderElement(root.evalNode("databaseIdProvider")); 
    17.   
  
  
  
  17.     typeHandlerElement(root.evalNode("typeHandlers")); 
    18.   
  
  
  
  18.     mapperElement(root.evalNode("mappers")); 
    19.   
  
  
  
  19.   } catch (Exception e) { 
    20.   
  
  
  
  20.     throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e); 
    21.   
  
  
  
  21.   } 
    22.   
  
  
  
  22. } 
    23.

这里就是把mybatis-config.xml内容解析，然后设置到Configuration对象中。

那么我们定义的Mapper.xml是在哪里解析的呢?

我们的Mapper.xml在mybatis-config.xml中的配置是这样的：

使用方式有以下四种： 

 
 
 
 
    
  
  
  
  
  1. //1使用类路径 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.      
    4.   
  
  
  
  4.        
    5.   
  
  
  
  5.     
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. //2使用绝对url路径 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.     
    10.   
  
  
  
  10.     
    11.   
  
  
  
  11.     
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. //3使用java类名 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.     
    16.   
  
  
  
  16.     
    17.   
  
  
  
  17.     
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20. //4自动扫描包下所有映射器 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.     
    23.   
  
  
  
  23.  
    24.

继续源码分析，我们在上面mybatis-config.xml解析中可以看到：

我们不妨进入这个方法看看：

 
 
 
 
    
  
  
  
  
  1. private void mapperElement(XNode parent) throws Exception { 
    2.   
  
  
  
  2.    if (parent != null) { 
    3.   
  
  
  
  3.      for (XNode child : parent.getChildren()) { 
    4.   
  
  
  
  4.        //自动扫描包下所有映射器 
    5.   
  
  
  
  5.        if ("package".equals(child.getName())) { 
    6.   
  
  
  
  6.          String mapperPackage = child.getStringAttribute("name"); 
    7.   
  
  
  
  7.          //放   
    8.   
  
  
  
  8.          configuration.addMappers(mapperPackage); 
    9.   
  
  
  
  9.        } else { 
    10.   
  
  
  
  10.          String resource = child.getStringAttribute("resource"); 
    11.   
  
  
  
  11.          String url = child.getStringAttribute("url"); 
    12.   
  
  
  
  12.          String mapperClass = child.getStringAttribute("class"); 
    13.   
  
  
  
  13.          //使用java类名 
    14.   
  
  
  
  14.          if (resource != null && url == null && mapperClass == null) { 
    15.   
  
  
  
  15.            ErrorContext.instance().resource(resource); 
    16.   
  
  
  
  16.             //根据文件存放目录，读取XxxMapper.xml 
    17.   
  
  
  
  17.            InputStream inputStream = Resources.getResourceAsStream(resource); 
    18.   
  
  
  
  18.             //映射器比较复杂，调用XMLMapperBuilder 
    19.   
  
  
  
  19.            //注意在for循环里每个mapper都重新new一个XMLMapperBuilder，来解析 
    20.   
  
  
  
  20.            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments()); 
    21.   
  
  
  
  21.            mapperParser.parse(); 
    22.   
  
  
  
  22.          //使用绝对url路径 
    23.   
  
  
  
  23.          } else if (resource == null && url != null && mapperClass == null) { 
    24.   
  
  
  
  24.            ErrorContext.instance().resource(url); 
    25.   
  
  
  
  25.            InputStream inputStream = Resources.getUrlAsStream(url); 
    26.   
  
  
  
  26.            //映射器比较复杂，调用XMLMapperBuilder 
    27.   
  
  
  
  27.            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments()); 
    28.   
  
  
  
  28.            mapperParser.parse(); 
    29.   
  
  
  
  29.          //使用类路径     
    30.   
  
  
  
  30.          } else if (resource == null && url == null && mapperClass != null) { 
    31.   
  
  
  
  31.            Class mapperInterface = Resources.classForName(mapperClass); 
    32.   
  
  
  
  32.            //直接把这个映射加入配置 
    33.   
  
  
  
  33.            configuration.addMapper(mapperInterface); 
    34.   
  
  
  
  34.          } else { 
    35.   
  
  
  
  35.            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one."); 
    36.   
  
  
  
  36.          } 
    37.   
  
  
  
  37.        } 
    38.   
  
  
  
  38.      } 
    39.   
  
  
  
  39.    } 
    40.   
  
  
  
  40.  } 
    41.

这里刚刚和我们的上面说的 使用的方式完全是一模一样的。

到这里，配置文件mybatis-config.xml和我们定义映射文件XxxMapper.xml就全部解析完成。

回到SqlSessionFactoryBuilder类

前面讲到了XMLConfigBuilder中的parse方法，并返回了一个Configuration对象。

build(parser.parse());

这个build方法就是传入一个Configuration对象，然后构建一个DefaultSqlSession对象。

 
 
 
 
    
  
  
  
  
  1. public SqlSessionFactory build(Configuration config) { 
    2.   
  
  
  
  2.   return new DefaultSqlSessionFactory(config); 
    3.   
  
  
  
  3. } 
    4.

继续回到我们的demo代码中这一行代码里：

 
 
 
 
    
  
  
  
  
  1. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); 
    2.

这一行代码就相当于：

 
 
 
 
    
  
  
  
  
  1. SqlSessionFactory sqlSessionFactory = new new DefaultSqlSessionFactory(); 
    2.

到这里，我们的整个流程就搞定了。

本文转载自微信公众号「 Java后端技术全栈  」，可以通过以下二维码关注。转载本文请联系 Java后端技术全栈  公众号。


分享题目：Mybatis是如何解析配置文件的？看完终于明白了
文章分享：http://wtcwzsj.com/article/dpscdhc.html

其他资讯


关于我们
我们的服务
网站建设案例
新闻动态
联系我们

135-1821-9792

公司服务热线
友情链接： 康明斯发电机销售   网络口碑营销   广告扇定制制作   公关活动   成都公司转让   成都展柜设计   尊格展览   成都网站维护   艾瑞格衣柜   成都雪糕加盟   

Copyright © 2009-2022 www.wtcwzsj.com 青羊区广皓图文设计工作室（个体工商户） 版权所有　蜀ICP备19037934号