Une explication approfondie de la série Mybatis (6) --- Introduction et configuration d'objectFactory, des plugins et des mappeurs

L'article précédent "Introduction approfondie à la série Mybatis (5) --- Introduction et configuration de TypeHandler (code source mybatis)" a jeté un bref aperçu de TypeHandler. Cette fois, nous terminerons l'étude du fichier de configuration de mybatis. Cette fois, il s'agit de la configuration des nœuds restants qui ne sont pas mentionnés : objectFactory, databaseIdProvider, plugins et mappers.

Alors, maintenant, présentons brièvement les fonctions de ces configurations :

1. Que fait objectFactory ? Besoin de configurer ?

Chaque fois que MyBatis crée une nouvelle instance de l'objet résultat, il utilisera une instance ObjectFactory pour ce faire. Tout ce que la fabrique d'objets par défaut doit faire est d'instancier la classe cible, soit via le constructeur par défaut, soit via le constructeur de paramètres si une carte de paramètres existe. Par défaut, nous n'avons pas besoin de configurer, mybatis appellera l'implémentation par défaut d'objectFactory. À moins que nous souhaitions personnaliser l’implémentation d’ObjectFactory, nous devons alors la configurer manuellement.

Alors comment personnaliser l'implémentation d'ObjectFactory ? Comment le configurer ?

Pour personnaliser ObjectFactory, il vous suffit d'hériter de DefaultObjectFactory (qui est la classe d'implémentation de l'interface ObjectFactory) et de réécrire ses méthodes. Je n’entrerai pas dans les détails ici et je les expliquerai en détail plus tard.

Après avoir écrit l'ObjectFactory, il vous suffit de le configurer comme suit :

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

2. Quoi quel est le rôle du plugin ? Besoin de configurer ?

Les plugins sont une configuration facultative. Le plugin de mybatis est en fait un intercepteur. Il peut intercepter certaines méthodes d'Executor, ParameterHandler, ResultSetHandler et StatementHandler pour traiter notre propre logique. L'exécuteur est ce qui exécute réellement l'instruction SQL. ParameterHandler est ce qui traite les paramètres que nous transmettons. Je me souviens encore de ce que j'ai mentionné en parlant de TypeHandler plus tôt. Mybatis nous aide à implémenter de nombreux typesHandlers par défaut. mybatis Le typeHandler approprié sera automatiquement sélectionné pour l'exécution en fonction du type de paramètre, qui est en fait ParameterHandler. En choisissant. ResultSetHandler gère les résultats renvoyés.

Comment personnaliser le plugin ? Comment le configurer ?

Pour personnaliser un plugin, vous devez implémenter l'interface Interceptor. Je n'entrerai pas dans les détails ici, mais cela sera expliqué en détail dans la partie pratique plus tard. Après l'avoir défini, la configuration est la suivante :

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

3. Les mappeurs, cela fait ressortir un des coeurs de mybatis Quel est le rôle des mappeurs ?

Sous le nœud mappers, configurez notre fichier de mappage mapper. Le fichier de mappage mapper est un pont utilisé par mybatis pour établir le mappage entre les tables de données et les javabeans. Dans notre développement actuel, un fichier mappeur correspond généralement à une interface dao, et ce mappeur peut être considéré comme l'implémentation de dao. Par conséquent, les mappeurs doivent être configurés.

Alors comment le configurer ?

<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>

Cet article n'est qu'une brève introduction. Une utilisation plus avancée et ses principes de mise en œuvre seront expliqués en détail dans la partie pratique plus tard.

Le code source d'analyse de ces nœuds est similaire à l'analyse de ces nœuds mentionnés précédemment, il ne sera donc pas abordé ici. J'ai plié le code source, vous pouvez l'ouvrir si besoin.

/**
 * 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）！