图文并茂解析Mybatis配置加载过程！

public class MybatisDemo {
    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void init() throws IOException {
            //--------------------第一步：加载配置---------------------------
        // 1.读取mybatis配置文件创SqlSessionFactory
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            // 1.读取mybatis配置文件创SqlSessionFactory
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            inputStream.close();
    }

    @Test
    // 快速入门
    public void quickStart() throws IOException {
        //--------------------第二部，创建代理对象---------------------------
        // 2.获取sqlSession 
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 3.获取对应mapper
        TUserMapper mapper = sqlSession.getMapper(TUserMapper.class);

        //--------------------第三步：获取数据---------------------------
        // 4.执行查询语句并返回单条数据
        TUser user = mapper.selectByPrimaryKey();
        System.out.println(user);

        System.out.println("----------------------------------");

        // 5.执行查询语句并返回多条数据
//  List<TUser> users = mapper.selectAll();
//  for (TUser tUser : users) {
//   System.out.println(tUser);
//  }
    }
}

public class RedPacket {
    private String publisherName; //发包人
    private String acceptName; //收包人
    private BigDecimal packetAmount; //红包金额
    private int packetType; //红包类型
    private Date pulishPacketTime; //发包时间
    private Date openPacketTime; //抢包时间

    public RedPacket(String publisherName, String acceptName, BigDecimal packetAmount, int packetType, Date pulishPacketTime, Date openPacketTime) {
        this.publisherName = publisherName;
        this.acceptName = acceptName;
        this.packetAmount = packetAmount;
        this.packetType = packetType;
        this.pulishPacketTime = pulishPacketTime;
        this.openPacketTime = openPacketTime;
    }

    public String getPublisherName() {
            return publisherName;
    }

    public void setPublisherName(String publisherName) {
            this.publisherName = publisherName;
    }

    public String getAcceptName() {
            return acceptName;
    }

    public void setAcceptName(String acceptName) {
            this.acceptName = acceptName;
    }

    public BigDecimal getPacketAmount() {
            return packetAmount;
    }

    public void setPacketAmount(BigDecimal packetAmount) {
            this.packetAmount = packetAmount;
    }

    public int getPacketType() {
            return packetType;
    }

    public void setPacketType(int packetType) {
            this.packetType = packetType;
    }

    public Date getPulishPacketTime() {
            return pulishPacketTime;
    }

    public void setPulishPacketTime(Date pulishPacketTime) {
            this.pulishPacketTime = pulishPacketTime;
    }

    public Date getOpenPacketTime() {
            return openPacketTime;
    }

    public void setOpenPacketTime(Date openPacketTime) {
            this.openPacketTime = openPacketTime;
    }

    @Override
    public String toString() {
            return "RedPacket [publisherName=" + publisherName + ", acceptName="
                            + acceptName + ", packetAmount=" + packetAmount
                            + ", packetType=" + packetType + ", pulishPacketTime="
                            + pulishPacketTime + ", openPacketTime=" + openPacketTime + "]";
    }
}

public class Director {
    public static void main(String[] args) {
        RedPacket redPacket = RedPacketBuilderImpl.getBulider()
            .setPublisherName("DK").setAcceptName("粉丝")
            .setPacketAmount(new BigDecimal("888")).setPacketType()                       .setOpenPacketTime(new Date())
            .setPulishPacketTime(new Date()).build();
        System.out.println(redPacket);
    }
}

public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
      //读取配置文件
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
      return build(parser.parse());//解析配置文件得到configuration对象，并返回SqlSessionFactory
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        reader.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
}

public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

  private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
     //解析<properties>节点
      propertiesElement(root.evalNode("properties"));
      //解析<settings>节点
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      //解析<typeAliases>节点
      typeAliasesElement(root.evalNode("typeAliases"));
      //解析<plugins>节点
      pluginElement(root.evalNode("plugins"));
      //解析<objectFactory>节点
      objectFactoryElement(root.evalNode("objectFactory"));
      //解析<objectWrapperFactory>节点
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      //解析<reflectorFactory>节点
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);//将settings填充到configuration
      // read it after objectFactory and objectWrapperFactory issue #631
      //解析<environments>节点
      environmentsElement(root.evalNode("environments"));
      //解析<databaseIdProvider>节点
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      //解析<typeHandlers>节点
      typeHandlerElement(root.evalNode("typeHandlers"));
      //解析<mappers>节点
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }

private void configurationElement(XNode context) {
    try {
     //获取mapper节点的namespace属性
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      //设置builderAssistant的namespace属性
      builderAssistant.setCurrentNamespace(namespace);
      //解析cache-ref节点
      cacheRefElement(context.evalNode("cache-ref"));
      //重点分析 ：解析cache节点----------------1-------------------
      cacheElement(context.evalNode("cache"));
      //解析parameterMap节点（已废弃）
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      //重点分析 ：解析resultMap节点----------------2-------------------
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      //解析sql节点
      sqlElement(context.evalNodes("/mapper/sql"));
      //重点分析 ：解析select、insert、update、delete节点 ----------------3-------------------
      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);
    }
  }