mybatis源码(一)配置文件解析,mapper解析SqlSessionFactory生成

缺乏、安全感 2022-12-02 00:49 278阅读 0赞

### 文章目录 ###

*   *  官方网站
     *  简单使用mybatis
     *  简单分析
     *  新建SqlSessionFactory
     *   *  先看XMLConfigBuilder解析配置文件生成Configuration
         *  主要讲一下mapper扫描
     *  XMLMapperBuilder.parse()
     *   *  configurationElement
         *  bindMapperForNamespace
         *  parsePendingResultMaps,parsePendingCacheRefs,parsePendingStatements
     *  生成SqlSessionFactory

## 官方网站 ##

[mybatis3官网][mybatis3]  
[mybatis配置文件][mybatis]

## 简单使用mybatis ##

先写个简单的测试:当然环境的话都是比较简单的,新建个表,就这三个字段进行测试,mapper跟xml可以使用插件生成,比较简单,就不多说了;  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center]

新建简单配置文件mybatis2.xml:配置文件具体信息官网都写的很详细,具体使用可以直接看官网的;

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    
        <properties>
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>
            <property name="username" value="root"/>
            <property name="password" value="root"/>
            <property name="org.apache.ibatis.parsing.PropertyParser.enable-default-value" value="true"/>
        </properties>
    
        
        <settings>
            
            <setting name="cacheEnabled" value="true"></setting>
        </settings>
    
        
        <typeAliases>
            <package name="com.study.springbootplus.domain.entity" ></package>
        </typeAliases>
    
        
        <typeHandlers>
            
        </typeHandlers>
    
        
     
        
     
    
        
        <environments default="development">
            <environment id="development">
                <transactionManager type="JDBC"/>
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>
                    <property name="username" value="root"/>
                    <property name="password" value="root"/>
                </dataSource>
            </environment>
    
            <environment id="prod">
                
                <transactionManager type="JDBC"/>
                <dataSource type="POOLED">
                    <property name="driver" value="${driver}"/>
                    <property name="url" value="${url}"/>
                    <property name="username" value="${username}"/>
                    <property name="password" value="${password:123456}"/>
                </dataSource>
            </environment>
        </environments>
    
        
        <mappers>
            <mapper resource="mapper/UserMapper.xml"/>
        </mappers>
    
    
    </configuration>

写个简单的main方法进行测试:

public static void main(String[] args) throws IOException { 
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis2.xml");
        SqlSessionFactory sqlsessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream, "development");
        SqlSession session = sqlsessionFactory.openSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        User user = mapper.selectByPrimaryKey(1);
        System.out.println(JSON.toJSONString(user));
        session.close();
      }

执行成功,这时候简单的mybatis测试就建好了:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 1]

## 简单分析 ##

***通过读取指定的mybatis配置文件,生成SqlSessionFactory,然后通过SqlSessionFactory可以获取SqlSession,SqlSession有个方法getMapper,可以获取到对应的mapper接口,然后就可以执行mapper内部方法了;  
SqlSession获取mapper比较复杂,下期将,我们这篇主要讲通过配置文件生成对应的SqlSessionFactory;***

## 新建SqlSessionFactory ##

首先看SqlSessionFactoryBuilder的两个方,builder类就是用来创建对象的,源码的名字都取得超级规范,很多时候我们通过取得名字就知道这个类的作用:

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { 
        try { 
          //创建XMLConfigBuilder,通过XMLConfigBuilder的parse方法生成Configuration类
          XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
          //build方法就是新建一个默认的SqlSessionFactory,
          // DefaultSqlSessionFactory内部维护了Configuration,具体的执行方法都是通过Configuration对象去做的
          return build(parser.parse());
        } catch (Exception e) { 
          throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        } finally { 
          ErrorContext.instance().reset();
          try { 
            inputStream.close();
          } catch (IOException e) { 
            // Intentionally ignore. Prefer previous error.
          }
        }
      }
    
      public SqlSessionFactory build(Configuration config) { 
        return new DefaultSqlSessionFactory(config);
      }

### 先看XMLConfigBuilder解析配置文件生成Configuration ###

首先看XMLConfigBuilder的初始化,新建了个Configuration,其他解析xml生成xpath解析器,就不说了,  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 2]

对XML的解析,一定要事先看官网的xml配置详解:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 3]

public Configuration parse() { 
        //防止重复加载
        if (parsed) { 
          throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        parsed = true;
        //解析节点的主要方法,前面将配置文件解析为XPathParser解析器就不看了,应该就是将xml解析为dom树;
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
      }
    
     //主要方法,针对xml的配置文件里面的东西分方法进行解析;
      //更多详细看官网配置详解,一定要看
      private void parseConfiguration(XNode root) { 
        try { 
          //issue #117 read properties first
          //拿到properties节点,设置configuration的Properties variables属性;
          propertiesElement(root.evalNode("properties"));
          //拿到settings节点,生成Properties settings对象;
          Properties settings = settingsAsProperties(root.evalNode("settings"));
          //根据对应的setting配置设置configuration的vfs
          loadCustomVfs(settings);
          //日志配置
          loadCustomLogImpl(settings);
          //别名配置
          typeAliasesElement(root.evalNode("typeAliases"));
          //插件设置,一般用来做拦截
          pluginElement(root.evalNode("plugins"));
          //configuration的对象工厂设置
          objectFactoryElement(root.evalNode("objectFactory"));
          //设置configuration的对象包装工厂
          objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
          //反射工厂
          reflectorFactoryElement(root.evalNode("reflectorFactory"));
          //将其他settings设置;
          settingsElement(settings);
          // read it after objectFactory and objectWrapperFactory issue #631
          //环境
          environmentsElement(root.evalNode("environments"));
          //设置configuration的数据库id
          databaseIdProviderElement(root.evalNode("databaseIdProvider"));
          //设置configuration的类型处理器
          typeHandlerElement(root.evalNode("typeHandlers"));
          //设置configuration的mapper扫描规则并添加mapper
          mapperElement(root.evalNode("mappers"));
        } catch (Exception e) { 
          throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
        }
      }

### 主要讲一下mapper扫描 ###

//mappper配置解析
      private void mapperElement(XNode parent) throws Exception { 
        if (parent != null) { 
          //单独的mapper节点
          for (XNode child : parent.getChildren()) { 
            //package标签 , 映射文件跟mapper接口必须在同一个包,且名字对应
            if ("package".equals(child.getName())) { 
              String mapperPackage = child.getStringAttribute("name");
              configuration.addMappers(mapperPackage);
            } else { 
              //resource标签,可以配置,url,resource,class
              String resource = child.getStringAttribute("resource");
              String url = child.getStringAttribute("url");
              String mapperClass = child.getStringAttribute("class");
    
              if (resource != null && url == null && mapperClass == null) { 
                //resource类型
                ErrorContext.instance().resource(resource);
                //获取mapper流
                InputStream inputStream = Resources.getResourceAsStream(resource);
                //初始化mapper解析器,并解析
                XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                mapperParser.parse();
              } else if (resource == null && url != null && mapperClass == null) { 
                //url类型
                ErrorContext.instance().resource(url);
                // 获取mapper流
                // 初始化mapper解析器,并解析
                InputStream inputStream = Resources.getUrlAsStream(url);
                XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                mapperParser.parse();
              } else if (resource == null && url == null && mapperClass != null) { 
                // class类型
                Class<?> mapperInterface = Resources.classForName(mapperClass);
                //通过configuration自己的addMapper去添加
                configuration.addMapper(mapperInterface);
              } else { 
                //只能有一种节点
                throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
              }
            }
          }
        }
      }

## XMLMapperBuilder.parse() ##

通过class类型的跟通过xml解析的差不多,我们看一下通过xml进行加载的例子,也就是XMLMapperBuilder类的解,我们看parse方法:

public void parse() { 
        // 判断是否加载过
        if (!configuration.isResourceLoaded(resource)) { 
          //拿到mapper下节点进行加载
          configurationElement(parser.evalNode("/mapper"));
          //加入到resource中
          configuration.addLoadedResource(resource);
          //将mapper跟namespace绑定
          bindMapperForNamespace();
        }
        //进行resultmap的加载
        parsePendingResultMaps();
        //缓存加载
        parsePendingCacheRefs();
        //sql语句加载
        parsePendingStatements();
      }

### configurationElement ###

private void configurationElement(XNode context) { 
        try { 
          //获取namespace,就是接口地址
          String namespace = context.getStringAttribute("namespace");
          if (namespace == null || namespace.equals("")) { 
            throw new BuilderException("Mapper's namespace cannot be empty");
          }
          //设置namespace
          builderAssistant.setCurrentNamespace(namespace);
          //缓存引用
          cacheRefElement(context.evalNode("cache-ref"));
          //设置缓存
          cacheElement(context.evalNode("cache"));
          //设置参数的parameterMap
          parameterMapElement(context.evalNodes("/mapper/parameterMap"));
          //设置返回的resultMap
          resultMapElements(context.evalNodes("/mapper/resultMap"));
          //设置sql
          sqlElement(context.evalNodes("/mapper/sql"));
          //设置sql的执行类型,就是增删改查
          buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
        } catch (Exception e) { 
          throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
        }
      }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 4]

### bindMapperForNamespace ###

将mapper跟namespace进行绑定

private void bindMapperForNamespace() { 
        //获取namespace
        String namespace = builderAssistant.getCurrentNamespace();
        if (namespace != null) { 
          Class<?> boundType = null;
          try { 
            //反射获取接口
            boundType = Resources.classForName(namespace);
          } catch (ClassNotFoundException e) { 
            //ignore, bound type is not required
          }
          if (boundType != null) { 
            if (!configuration.hasMapper(boundType)) { 
              //第一次加载指定类型mapper
              // Spring may not know the real resource name so we set a flag
              // to prevent loading again this resource from the mapper interface
              // look at MapperAnnotationBuilder#loadXmlResource
              //添加namespace
              configuration.addLoadedResource("namespace:" + namespace);
              //将当前通过反射获取的类型通过接口类型添加,后台通过configuration可以获取指定mapper
              configuration.addMapper(boundType);
            }
          }
        }
      }

addMapper走的是configuration类内部的MapperRegistry属性的方法,而MapperRegistry就是存储mapper接口的地方,后面根据sqlsession获取mapper的时候回用的MapperRegistry内部存储的mapper接口类:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 5]

addMapper里面的方法,直接点到最终实现地方:

public <T> void addMapper(Class<T> type) { 
        if (type.isInterface()) { 
          if (hasMapper(type)) { 
            throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
          }
          boolean loadCompleted = false;
          try { 
            //新建mapper代理工厂,跟类型进行对应
            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 { 
            if (!loadCompleted) { 
              knownMappers.remove(type);
            }
          }
        }
      }

### parsePendingResultMaps,parsePendingCacheRefs,parsePendingStatements ###

这三个加载几乎一样,就只看看cacheref的解析,前面将节点的信息都保存进configuration中,这三个方法都是将对应的节点信息取出来进行处理:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 6]  
使用cache就是通过namespace将存储的cache对象取出来设置为MapperBuilderAssistant的cache引用吧.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 7]

## 生成SqlSessionFactory ##

前面将mybatis.xml解析,mappper的解析都讲完了这时候就生成了Configuration对象,简单的说Configuration对象就是存储了mybatis几乎所有的配置.然后就直接通过Configuration对象生成SqlSessionFactory对象了:  
![在这里插入图片描述][20200829165349871.png_pic_center]  
DefaultSqlSessionFactory就是内部维护了Configuration对象,具体的执行都需要考Configuration对象来完成:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 8]

[mybatis3]: https://mybatis.org/mybatis-3/zh/index.html
[mybatis]: https://mybatis.org/mybatis-3/zh/configuration.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/3e7baa4fb4b942a9bd5fc4d29ad1b07d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/31bea3b2664545a3a10e884e2c6dcb76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/f34c0ae57d884b1da5cc7ea79235f7a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/bd15342aa5c04f55bc444e7512d4469b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/eda3d107fc604b388310e358726186ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/89694a73df1a42f79a5d48b58ef38464.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/b0458b8d569a4ba7a4d0162da0b33a42.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/3418778c9ca44ab8993dd7d94e5cf963.png
[20200829165349871.png_pic_center]: /images/20221123/ee923561b3414547a112dcaae456eecc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzY2MDYz_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/eadd0e3f95cf4aef8ed2e3d678d7f51c.png