MyBatis啟動以及各種類的作用

這篇文章主要講解了“MyBatis啟動以及各種類的作用”，文中的講解內(nèi)容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“MyBatis啟動以及各種類的作用”吧！

前言

MyBatis 作為目前最常用的持久層框架之一，分析其源碼，對我們的使用過程中可更好的運用它。本系列基于mybatis-3.4.6進行分析。 MyBatis 的初始化工作就是解析主配置文件，映射配置文件以及注解信息。然后保存在org.apache.ibatis.session.Configuration，供后期執(zhí)行數(shù)據(jù)請求的相關(guān)調(diào)用。 Configuration 里有大量配置信息，在后面每涉及到一個相關(guān)配置，會進行詳細的分析。

啟動

    public static void main(String[] args) throws IOException {
        // 獲取配置文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 通過 SqlSessionFactoryBuilder 構(gòu)建 sqlSession 工廠
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        // 獲取 sqlSession 實例
        SqlSession sqlSession = sqlSessionFactory.openSession();

        reader.close();
        sqlSession.close();
    }

分析

SqlSessionFactoryBuilder 類

SqlSessionFactoryBuilder 的build()是Mybatis啟動的初始化入口，使用builder模式加載配置文件。 通過查看該類，使用方法重載，有以下9個方法：

方法重載最終實現(xiàn)處理的方法源碼如下：

    public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
        try {
          // 實例化 XMLConfigBuilder，用于讀取配置文件信息
          XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
          // 解析配置信息，保存到 Configuration
          return build(parser.parse());
        } 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.
          }
        }
      }

• environment 是指定加載環(huán)境，默認值為 null。

• properties 是屬性配置文件，默認值為 null。 同時讀取配置文件既可字符流讀取，也支持字節(jié)流讀取。

    public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        try {
          XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
          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.
          }
        }
      }

實例化 XMLConfigBuilder 類

通過 SqlSessionFactoryBuilder 中 XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties), 分析 XMLConfigBuilder實例化過程。 該類中有四個變量：

    private boolean parsed;
    private final XPathParser parser;
    private String environment;
    private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();

• parsed 是否解析，一次解析即可。用于標志配置文件只解析一次，true為已解析過。

• parser 解析配置的解析器

• environment 加載環(huán)境，即 SqlSessionFactoryBuilder 中的 environment

• localReflectorFactory 用于創(chuàng)建和緩存Reflector對象，一個類對應一個Reflector。因為參數(shù)處理、結(jié)果映射等操作時，會涉及大量的反射操作。DefaultReflectorFactory實現(xiàn)類比較簡單，這里不再進行講解。

XMLConfigBuilder構(gòu)建函數(shù)實現(xiàn)：

    public XMLConfigBuilder(Reader reader, String environment, Properties props) {
        this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);
    }

實例化 XPathParser 對象

首先實例化 XPathParser 對象，里面定義了5個變量:

    private final Document document;
    private boolean validation;
    private EntityResolver entityResolver;
    private Properties variables;
    private XPath xpath;

• document 保存document對象

• validation xml解析時是否驗證文檔

• entityResolver 加載dtd文件

• variables 配置文件定義<properties>的值

• xpath Xpath對象，用于對XML文件節(jié)點的操作

XPathParser 對象構(gòu)造函數(shù)有：

函數(shù)里面都處理了兩件事：

    public XPathParser(Reader reader, boolean validation, Properties variables, EntityResolver entityResolver) {
        commonConstructor(validation, variables, entityResolver);
        this.document = createDocument(new InputSource(reader));
    }

1. 初始化賦值，和創(chuàng)建XPath對象，用于對XML文件節(jié)點的操作。

    private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver) {
        this.validation = validation;
        this.entityResolver = entityResolver;
        this.variables = variables;
        // 創(chuàng)建Xpath對象，用于對XML文件節(jié)點的操作
        XPathFactory factory = XPathFactory.newInstance();
        this.xpath = factory.newXPath();
    }

2. 創(chuàng)建Document對象并賦值到document變量, 這里屬于Document創(chuàng)建的操作,不再詳細講述，不懂可以點擊這里查看API

    private Document createDocument(InputSource inputSource) {
        // important: this must only be called AFTER common constructor
        try {
          // 實例化 DocumentBuilderFactory 對象，用于創(chuàng)建 DocumentBuilder 對象
          DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
          // 是否校驗文檔
          factory.setValidating(validation);
          // 設置 DocumentBuilderFactory 的配置
          factory.setNamespaceAware(false);
          factory.setIgnoringComments(true);
          factory.setIgnoringElementContentWhitespace(false);
          factory.setCoalescing(false);
          factory.setExpandEntityReferences(true);
          // 創(chuàng)建 DocumentBuilder
          DocumentBuilder builder = factory.newDocumentBuilder();
          builder.setEntityResolver(entityResolver);
          builder.setErrorHandler(new ErrorHandler() {
            @Override
            public void error(SAXParseException exception) throws SAXException {
              throw exception;
            }
    
            @Override
            public void fatalError(SAXParseException exception) throws SAXException {
              throw exception;
            }
    
            @Override
            public void warning(SAXParseException exception) throws SAXException {
            }
          });
          // 加載文件
          return builder.parse(inputSource);
        } catch (Exception e) {
          throw new BuilderException("Error creating document instance.  Cause: " + e, e);
        }
    }

XMLConfigBuilder構(gòu)造函數(shù)賦值

    private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
        super(new Configuration());
        ErrorContext.instance().resource("SQL Mapper Configuration");
        this.configuration.setVariables(props);
        this.parsed = false;
        this.environment = environment;
        this.parser = parser;
    }

1. 初始化父類BaseBuilder的值。

2. 將外部值賦值給對象。

3. 將實例化的XPathParser賦值給parser。

最后返回XMLConfigBuilder對象。

解析 XMLConfigBuilder 對象

通過 XMLConfigBuilder.parse() 解析配置信息，保存至Configuration。解析詳解在后面文章中進行分析。

    public Configuration parse() {
        // 是否解析過配置文件
        if (parsed) {
          throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        // 標志解析過，定義為 true
        parsed = true;
        // 解析 configuration 節(jié)點中的信息
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
    }

創(chuàng)建 SqlSessionFactory

DefaultSqlSessionFactory實現(xiàn)了SqlSessionFactory接口。 通過上面解析得到的Configuration，調(diào)用SqlSessionFactoryBuilder.build(Configuration config)創(chuàng)建一個 DefaultSqlSessionFactory。

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

實例化DefaultSqlSessionFactory的過程，就是將Configuration傳遞給DefaultSqlSessionFactory成員變量configuration。

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

創(chuàng)建 SqlSession

通過調(diào)用SqlSessionFactory.openSession()創(chuàng)建SqlSession。

    public interface SqlSessionFactory {
      // 默認創(chuàng)建
      SqlSession openSession();
    
      SqlSession openSession(boolean autoCommit);
      SqlSession openSession(Connection connection);
      SqlSession openSession(TransactionIsolationLevel level);
    
      SqlSession openSession(ExecutorType execType);
      SqlSession openSession(ExecutorType execType, boolean autoCommit);
      SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
      SqlSession openSession(ExecutorType execType, Connection connection);
    
      Configuration getConfiguration();
    
    }

• autoCommit 是否自動提交事務，

• level 事務隔離級別（共5個級別）， 可查看相關(guān)源碼

• connection 連接

• execType 執(zhí)行器的類型：SIMPLE(不做特殊處理), REUSE（復用預處理語句）, BATCH（會批量執(zhí)行）

因為上面DefaultSqlSessionFactory實現(xiàn)了SqlSessionFactory接口，所以進入到DefaultSqlSessionFactory查看openSession()。

    public SqlSession openSession() {
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
    }

openSession()方法最終實現(xiàn)代碼如下：

    private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
        Transaction tx = null;
        try {
          // 獲取configuration中的加載環(huán)境
          final Environment environment = configuration.getEnvironment();
          // 獲取事務工廠
          final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
          // 創(chuàng)建一個事務
          tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
          // 生成一個處理器，事務保存在處理器 BaseExecutor 中
          final Executor executor = configuration.newExecutor(tx, execType);
          // 實例化一個 DefaultSqlSession，DefaultSqlSession實現(xiàn)了SqlSession接口
          return new DefaultSqlSession(configuration, executor, autoCommit);
        } catch (Exception e) {
          // 異常情況下關(guān)閉事務
          closeTransaction(tx); // may have fetched a connection so lets call close()
          throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
        } finally {
          // 充值錯誤實例上下文
          ErrorContext.instance().reset();
        }
    }

生成處理器Configuration.newExecutor(Transaction transaction, ExecutorType executorType)：

    public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
        // 默認為 ExecutorType.SIMPLE
        executorType = executorType == null ? defaultExecutorType : executorType;
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
        Executor executor;
        if (ExecutorType.BATCH == executorType) {
          executor = new BatchExecutor(this, transaction);
        } else if (ExecutorType.REUSE == executorType) {
          executor = new ReuseExecutor(this, transaction);
        } else {
          executor = new SimpleExecutor(this, transaction);
        }
        if (cacheEnabled) {
          executor = new CachingExecutor(executor);
        }
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
    }

以ExecutorType.SIMPLE為例, BatchExecutor, ReuseExecutor同理：

感謝各位的閱讀，以上就是“MyBatis啟動以及各種類的作用”的內(nèi)容了，經(jīng)過本文的學習后，相信大家對MyBatis啟動以及各種類的作用這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關(guān)知識點的文章，歡迎關(guān)注！