Eine ausführliche Erklärung der Mybatis-Reihe (6) --- Einführung und Konfiguration von objectFactory, Plugins und Mappern

Der vorherige Artikel „Ausführliche Einführung in die Mybatis-Serie (5) --- Einführung und Konfiguration von TypeHandler (Mybatis-Quellcode)“ warf einen kurzen Blick auf TypeHandler. Diesmal beenden wir das Studium der Konfigurationsdatei von mybatis. Diesmal geht es um die Konfiguration der verbleibenden Knoten, die nicht erwähnt werden: objectFactory, DatabaseIdProvider, Plugins und Mapper.

Als nächstes stellen wir kurz die Funktionen dieser Konfigurationen vor:

1 Was macht objectFactory? Müssen Sie konfigurieren?

Jedes Mal, wenn MyBatis eine neue Instanz des Ergebnisobjekts erstellt, verwendet es dazu eine ObjectFactory-Instanz. Die Standardobjektfabrik muss lediglich die Zielklasse instanziieren, entweder über den Standardkonstruktor oder über den Parameterkonstruktor, wenn eine Parameterzuordnung vorhanden ist. Standardmäßig müssen wir keine Konfiguration vornehmen. Mybatis ruft die Standardimplementierung von objectFactory auf. Sofern wir die Implementierung von ObjectFactory nicht anpassen möchten, müssen wir sie manuell konfigurieren.

Wie kann man also die Implementierung von ObjectFactory anpassen? Wie konfiguriere ich es?

Um ObjectFactory anzupassen, müssen Sie nur DefaultObjectFactory (die Implementierungsklasse der ObjectFactory-Schnittstelle) erben und ihre Methoden neu schreiben. Ich werde hier nicht auf Details eingehen und sie später im Detail erläutern.

Nachdem Sie die ObjectFactory geschrieben haben, müssen Sie sie nur noch wie folgt konfigurieren:

<configuration>
    ......    <objectFactory type="org.mybatis.example.ExampleObjectFactory">
        <property name="someProperty" value="100"/>
    </objectFactory>
    ......  </configuration

2. Was ist die Rolle des Plugins? Müssen Sie konfigurieren?

Plugins sind eine optionale Konfiguration. Das Plugin in mybatis ist eigentlich ein Interceptor. Es kann einige Methoden von Executor, ParameterHandler, ResultSetHandler und StatementHandler abfangen, um unsere eigene Logik zu verarbeiten. Der Executor ist das, was die SQL-Anweisung tatsächlich ausführt. Ich erinnere mich noch daran, was ich zuvor erwähnt habe, als wir über TypeHandler gesprochen haben, wenn wir TypeHandler nicht explizit konfigurieren. mybatis Der entsprechende TypeHandler wird automatisch basierend auf dem Parametertyp zur Ausführung ausgewählt, bei dem es sich tatsächlich um ParameterHandler handelt. Beim Wählen. ResultSetHandler verarbeitet die zurückgegebenen Ergebnisse.

Wie kann ich das Plugin anpassen?

Um ein Plugin anzupassen, müssen Sie die Interceptor-Schnittstelle implementieren. Ich gehe hier nicht auf Details ein, werde aber später im praktischen Teil ausführlich erläutert. Nach der Definition lautet die Konfiguration wie folgt:

<configuration>
    ......    <plugins>
      <plugin interceptor="org.mybatis.example.ExamplePlugin">
        <property name="someProperty" value="100"/>
      </plugin>
    </plugins>
    ......  </configuration>

3. Mapper, dies bringt einen der Kerne von mybatis zum Vorschein. Welche Rolle spielen Mapper?

Konfigurieren Sie unter dem Mappers-Knoten unsere Mapper-Mapping-Datei. Die sogenannte Mapper-Mapping-Datei ist eine Brücke, die von Mybatis verwendet wird, um eine Zuordnung zwischen Datentabellen und Javabeans herzustellen. In unserer tatsächlichen Entwicklung entspricht eine Mapper-Datei normalerweise einer Dao-Schnittstelle, und dieser Mapper kann als Implementierung von Dao betrachtet werden. Daher müssen Mapper konfiguriert werden.

Wie konfiguriert man es?

<configuration>
    ......    <mappers>
      <!-- 第一种方式：通过resource指定 -->
    <mapper resource="com/dy/dao/userDao.xml"/>
    
     <!-- 第二种方式， 通过class指定接口，进而将接口与对应的xml文件形成映射关系
             不过，使用这种方式必须保证 接口与mapper文件同名(不区分大小写)， 
             我这儿接口是UserDao,那么意味着mapper文件为UserDao.xml 
     <mapper class="com.dy.dao.UserDao"/>      -->
      
      <!-- 第三种方式，直接指定包，自动扫描，与方法二同理 
      <package name="com.dy.dao"/>      -->
      <!-- 第四种方式：通过url指定mapper文件位置
      <mapper url="file://........"/>       -->
  </mappers>
    ......  </configuration>

Dieser Artikel ist nur eine kurze Einführung und seine Implementierungsprinzipien werden später im praktischen Teil ausführlich erläutert.

Der Parsing-Quellcode dieser Knoten ähnelt dem Parsing der zuvor erwähnten Knoten und wird daher hier nicht erläutert. Ich habe den Quellcode gefaltet, Sie können ihn bei Bedarf öffnen.

/**
 * objectFactory 节点解析 
 */private void objectFactoryElement(XNode context) throws Exception {    
 if (context != null) {      
 //读取type属性的值， 接下来进行实例化ObjectFactory, 并set进 configuration      
 //到此，简单讲一下configuration这个对象，其实它里面主要保存的都是mybatis的配置
      String type = context.getStringAttribute("type");      
      //读取propertie的值， 根据需要可以配置， mybatis默认实现的objectFactory没有使用properties
      Properties properties = context.getChildrenAsProperties();
      
      ObjectFactory factory = (ObjectFactory) resolveClass(type).newInstance();
      factory.setProperties(properties);
      configuration.setObjectFactory(factory);
    }
 } 
  
  /**
   * plugins 节点解析   */
  private void pluginElement(XNode parent) throws Exception {    if (parent != null) {      for (XNode child : parent.getChildren()) {
        String interceptor = child.getStringAttribute("interceptor");
        Properties properties = child.getChildrenAsProperties();        //由此可见，我们在定义一个interceptor的时候，需要去实现Interceptor, 这儿先不具体讲，以后会详细讲解
        Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
        interceptorInstance.setProperties(properties);
        configuration.addInterceptor(interceptorInstance);
      }
    }
  }  
  /**
   * mappers 节点解析
   * 这是mybatis的核心之一，这儿先简单介绍，在接下来的文章会对它进行分析   */
  private void mapperElement(XNode parent) throws Exception {    if (parent != null) {      for (XNode child : parent.getChildren()) {        if ("package".equals(child.getName())) {          //如果mappers节点的子节点是package, 那么就扫描package下的文件, 注入进configuration
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        } else {
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");          //resource, url, class 三选一
          
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);            //mapper映射文件都是通过XMLMapperBuilder解析
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          } 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.");
          }
        }
      }
    }
  }

本次就简单的到此结束， 从下篇文章开始，将会开始接触到mybatis的核心部分，不过首先还是要讲mapper文件的配置及使用， 并通过源码进一步深入核心。

 以上就是深入浅出Mybatis系列（六）---objectFactory、plugins、mappers简介与配置的内容，更多相关内容请关注PHP中文网（www.php.cn）！