简单了解mybatis的执行原理：三大步

mybatis的执行原理三大步：

主要就是看以下几个步骤的源码，了解执行的过程：

​ DefaultSqlSession是实现了SqlSession接口的类

//1.读取配置文件
InputStream stream = Resources.getResourceAsStream("mybatis-config.xml");
//2.加载配置文件内容
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(stream);
//3.得到sqlsession对象，代表了与数据库的一次会话
//只要可以得到会话对象，就说明和数据库建立了连接
//通过该对象也会执行sql语句
SqlSession session = factory.openSession();

第1步：

​ 首先以：InputStreaminput Stream=Resources.getResourceAsStream(“mybatis-config.xml”);以流的形式把配置文件加载进来，

//1.读取配置文件
InputStream stream = Resources.getResourceAsStream("mybatis-config.xml");

第2部：

​ new SqlSessionFactoryBuilder().build(inputStream);调用build方法，产生一个XMLConfigBuilder的解析器parser，parse调用parse()方法对配置文件进行解析

//1.读取配置文件
InputStream stream = Resources.getResourceAsStream("mybatis-config.xml");
//2.加载配置文件内容
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(stream);

  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
        //产生一个XMLConfigBuilder解析器对象
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        //parse调用parse()方法对配置文件进行解析
      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.
      }
    }
  }

第2.1步：

​ 调用parse()方法会把解析了xml的配置文件封装成一个Configuration对象

​ Configuration对象中有：

​ environment 对应的是数据源

​ mappedStatements 对应的是映射文件的数据

​ key ----> namespace.标签id

​ values ----->MappedStatement 存储sql对应的所有信息

​ Executor sql语句的执行者

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

第2.2步：

​ 返回第二部，该方法返回一个build(parser.parse())，也就相当于返回一个SqlSessionFactory对象

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

第2.3步：

​ return new DefaultSqlSessionFactory(config);把第三步的Configuration对象传进来，最终得到一个DefaultSqlSessionFactory对象

  public DefaultSqlSessionFactory(Configuration configuration) {
    this.configuration = configuration;
  }

第3步：

​ 通过这个对象调用它内部的openSession()方法,得到DefaultSqlSession对象

//3.得到sqlsession对象，代表了与数据库的一次会话
//只要可以得到会话对象，就说明和数据库建立了连接
//通过该对象也会执行sql语句
SqlSession session = factory.openSession();

第3.1步：

​ openSession(boolean autoCommit)方法，最终会得到一个DefaultSqlSession对象

通过调用   @Override
  public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
        //数据源对象
      final Environment environment = configuration.getEnvironment();
        //得到数据的对象
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
        //得到sql语句执行的对象
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

第3.2步：

​ 这个类DefaultSqlSession实现了SqlSession接口，可以看到里边有很多的操作数据库的方法,在这只写了两个，最后通过生成的一个session对象，直接调用方法就实现了功能。

  @Override
  public int insert(String statement) {
    return insert(statement, null);
  }
    @Override
  public int update(String statement) {
    return update(statement, null);
  }
....
....
....