重新学习MyBatis(六)

查询流程：

代码debug分析：

public class MyBatisTest {

    public SqlSessionFactory getSqlSessionFactory() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return new SqlSessionFactoryBuilder().build(inputStream);
    }

    /**
     * 1、获取sqlSessionFactory对象:
     *         解析文件的每一个信息保存在Configuration中，返回包含Configuration的DefaultSqlSession；
     *         注意：【MappedStatement】：代表一个增删改查的详细信息
     * 
     * 2、获取sqlSession对象
     *         返回一个DefaultSQlSession对象，包含Executor和Configuration;
     *         这一步会创建Executor对象；
     * 
     * 3、获取接口的代理对象（MapperProxy）
     *         getMapper，使用MapperProxyFactory创建一个MapperProxy的代理对象
     *         代理对象里面包含了，DefaultSqlSession（Executor）
     * 4、执行增删改查方法
     * 
     * 总结：
     *     1、根据配置文件（全局，sql映射）初始化出Configuration对象
     *     2、创建一个DefaultSqlSession对象，
     *         他里面包含Configuration以及
     *         Executor（根据全局配置文件中的defaultExecutorType创建出对应的Executor）
     *  3、DefaultSqlSession.getMapper（）：拿到Mapper接口对应的MapperProxy；
     *  4、MapperProxy里面有（DefaultSqlSession）；
     *  5、执行增删改查方法：
     *          1）、调用DefaultSqlSession的增删改查（Executor）；
     *          2）、会创建一个StatementHandler对象。
     *              （同时也会创建出ParameterHandler和ResultSetHandler）
     *          3）、调用StatementHandler预编译参数以及设置参数值;
     *              使用ParameterHandler来给sql设置参数
     *          4）、调用StatementHandler的增删改查方法；
     *          5）、ResultSetHandler封装结果
     *  注意：
     *      四大对象每个创建的时候都有一个interceptorChain.pluginAll(parameterHandler);
     * 
     * @throws IOException
     */
    @Test
    public void test01() throws IOException {
        // 1、获取sqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        // 2、获取sqlSession对象
        SqlSession openSession = sqlSessionFactory.openSession();
        try {
            // 3、获取接口的实现类对象
            //会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            Employee employee = mapper.getEmpById(1);
            System.out.println(mapper);
            System.out.println(employee);
        } finally {
            openSession.close();
        }

    }

}

Configuration的创建过程如下：

/*
Configuration的创建过程：
1.sqlSessionFactoryBuilder.build(inputStream)

2.build(InputStream inputStream, String environment, Properties properties);

3.build(parser.parse())--->parser.parse()

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

5.private void parseConfiguration(XNode root) {
    try {
      Properties settings = settingsAsPropertiess(root.evalNode("settings"));
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties"));       // ① 读取<properties>，并设置
      loadCustomVfs(settings);                              // ② 读取之前<settings>，并设置
      typeAliasesElement(root.evalNode("typeAliases"));     // ③ 读取<typeAliases>，并设置
      pluginElement(root.evalNode("plugins"));              // ④ 读取<plugins>，并设置
      objectFactoryElement(root.evalNode("objectFactory")); // ⑤ 读取<objectFactory>，并设置
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); // ⑥ 读取<objectWrapperFactory>，并设置
      reflectorFactoryElement(root.evalNode("reflectorFactory")); // ⑦ 读取<reflectorFactory>，并设置
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));   // ⑧ 读取<environments>，并设置
      databaseIdProviderElement(root.evalNode("databaseIdProvider")); // ⑨ 读取<databaseIdProvider>，并设置
      typeHandlerElement(root.evalNode("typeHandlers")); // ⑨ 读取<databaseIdProvider>，并设置
      mapperElement(root.evalNode("mappers"));  // ⑨ 读取<mappers>，并设置
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

// 读取xxxMapper.xml或者xxxMapperAnnotation...
6.private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          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) {
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse(); // 解析mapper,xml--->configurationElement(parser.evalNode("/mapper"));
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            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<?> 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.");
          }
        }
      }
    }
  }
// 解析具体的mapper.xml 
7.private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      cacheRefElement(context.evalNode("cache-ref"));
      cacheElement(context.evalNode("cache"));
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      sqlElement(context.evalNodes("/mapper/sql"));
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
    }
  }
 */