Dans le développement Java, MyBatis et MyBatis-Plus sont des frameworks populaires pour la couche de persistance. Voici une exploration détaillée de leurs classes fondamentales et de leur utilisation.

Composants Essentiels de MyBatis

1. SqlSessionFactoryBuilder

   • Rôle : Construit l'instance de SqlSessionFactory, servant de point d'entrée initial.

   • Contexte : Utilisé au démarrage pour charger la configuration (par exemple, un fichier XML) et instancier la fabrique.

   • Exemple de Code : ``` String configPath = "mybatis-config.xml"; InputStream configStream = Resources.getResourceAsStream(configPath); SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(configStream);

2. SqlSessionFactory

   • Rôle : Génère des instances de SqlSession, gérant les connexions aux bases de données et les transactions.

   • Contexte : Fournit des sessions pour exécuter des opérations SQL via des mappers.

   • Exemple de Code : ``` try (SqlSession dbSession = factory.openSession()) { UtilisateurMapper userMapper = dbSession.getMapper(UtilisateurMapper.class); Utilisateur user = userMapper.recupererParId(10); }

3. SqlSession

   • Rôle : Permet l'exécution de requêtes SQL, la gestion des transactions et des connexions.

   • Contexte : Utilisé directement ou via des interfaces mapper pour interagir avec la base.

   • Exemple de Code : ``` // Exécution directe Utilisateur user = dbSession.selectOne("com.exemple.mapper.UtilisateurMapper.recupererParId", 10);

     // Via l'interface mapper UtilisateurMapper mapper = dbSession.getMapper(UtilisateurMapper.class); Utilisateur user = mapper.recupererParId(10);

4. Interface Mapper

   • Rôle : Définit des méthodes liées aux opérations de base de données, mappées à du SQL via XML ou annotations.

   • Contexte : Permet d'appeler du SQL sans code d'exécution manuel.

   • Exemple de Code : ``` public interface UtilisateurMapper { @Select("SELECT * FROM utilisateurs WHERE id = #{identifiant}") Utilisateur recupererParId(int identifiant); }

5. Executor

   • Rôle : Composant central pour l'exécution des instructions SQL, avec des variantes comme simple, réutilisable ou par lots.
   • Contexte : Appelé en interne par SqlSession, rarement utilisé directement par les développeurs.

6. TypeHandler

   • Rôle : Convertit entre les types Java et les types JDBC.

   • Contexte : Personnalise les conversions, pour les énumérations ou les dates par exemple.

   • Exemple de Code : ``` public class GestionnaireDate extends BaseTypeHandler<Date> { @Override public void setNonNullParameter(PreparedStatement stmt, int index, Date valeur, JdbcType type) throws SQLException { stmt.setTimestamp(index, new Timestamp(valeur.getTime())); } }

7. Plugin

   • Rôle : Mécanisme d'interception pour modifier le comportement de l'exécution SQL, utile pour la pagination ou le monitoring.

   • Contexte : Implémente l'interface Interceptor pour ajouter une logique personnalisée.

   • Exemple de Code : ``` @Intercepts({ @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}) }) public class IntercepteurPagination implements Interceptor { @Override public Object intercepter(Invocation invocation) throws Throwable { // Logique d'interception return invocation.proceed(); } }

Composants Essentiels de MyBatis-Plus

MyBatis-Plus étend MyBatis avec des fonctionnalités supplémentaires pour simplifier le développement.

1. BaseMapper<T>

   • Rôle : Interface Mapper générique offrant des méthodes CRUD intégrées comme selectById, insert, updateById, deleteById.

   • Contexte : En héritant, on évite de rédiger du SQL de base, accélérant le développement.

   • Exemple de Code : ``` public interface UtilisateurMapper extends BaseMapper<Utilisateur> { List<Utilisateur> chercherParNom(@Param("nom") String nom); }

2. QueryWrapper<T> / LambdaQueryWrapper<T>

   • Rôle : Constructeurs de conditions pour les requêtes, supportant les appels chaînés et les expressions Lambda.

   • Contexte : Idéal pour les requêtes dynamiques et les conditions complexes.

   • Exemple de Code : ``` // Avec QueryWrapper QueryWrapper<Utilisateur> wrapper = new QueryWrapper<>(); wrapper.eq("nom", "Jean").gt("age", 25); List<Utilisateur> liste = utilisateurMapper.selectList(wrapper);

     // Avec LambdaQueryWrapper LambdaQueryWrapper<Utilisateur> lambdaWrapper = new LambdaQueryWrapper<>(); lambdaWrapper.eq(Utilisateur::getNom, "Jean").gt(Utilisateur::getAge, 25); List<Utilisateur> liste = utilisateurMapper.selectList(lambdaWrapper);

3. UpdateWrapper<T> / LambdaUpdateWrapper<T>

   • Rôle : Constructeurs de conditions pour les mises à jour.

   • Contexte : Permet des mises à jour dynamiques sans fixer tous les champs.

   • Exemple de Code : ``` // Avec UpdateWrapper UpdateWrapper<Utilisateur> wrapper = new UpdateWrapper<>(); wrapper.eq("nom", "Jean").set("age", 30); utilisateurMapper.update(null, wrapper);

     // Avec LambdaUpdateWrapper LambdaUpdateWrapper<Utilisateur> lambdaWrapper = new LambdaUpdateWrapper<>(); lambdaWrapper.eq(Utilisateur::getNom, "Jean").set(Utilisateur::getAge, 30); utilisateurMapper.update(null, lambdaWrapper);

4. Page<T>

   • Rôle : Objet paramétrique pour la pagination, à combiner avec un plugin de pagination.

   • Contexte : Implémente des requêtes paginées de manière déclarative.

   • Exemple de Code : ``` Page<Utilisateur> page = new Page<>(2, 5); // Page numéro 2, 5 éléments par page IPage<Utilisateur> resultat = utilisateurMapper.selectPage(page, null); List<Utilisateur> donnees = resultat.getRecords(); long totalElements = resultat.getTotal();

5. MybatisPlusInterceptor

   • Rôle : Classe centrale pour gérer les plugins MyBatis-Plus, comme la pagination ou le verrouillage optimiste.

   • Contexte : Configurée dans une classe Spring Boot pour enregistrer les plugins.

   • Exemple de Code : ``` @Configuration public class ConfigurationMybatisPlus { @Bean public MybatisPlusInterceptor interceptor() { MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); interceptor.addInnerInterceptor(new PaginationInnerInterceptor()); interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor()); return interceptor; } }

6. AutoFillMetaObjectHandler

   • Rôle : Remplit automatiquement des champs comme les horodatages de création ou de modification.

   • Contexte : Implémente l'interface MetaObjectHandler pour une logique de remplissage personnalisée.

   • Exemple de Code : ``` @Component public class GestionnaireChamps implements MetaObjectHandler { @Override public void insertFill(MetaObject metaObjet) { this.strictInsertFill(metaObjet, "dateCreation", LocalDateTime.class, LocalDateTime.now()); }

       @Override
       public void updateFill(MetaObject metaObjet) {
           this.strictUpdateFill(metaObjet, "dateMiseAJour", LocalDateTime.class, LocalDateTime.now());
       }
     

     }

7. ActiveRecord

   • Rôle : Supporte le modèle ActiveRecord, où les entités peuvent appeler dircetement des méthodes CRUD.

   • Contexte : Simplifie le code, mais nécessite que l'entité hérite de Model<T>.

   • Exemple de Code : ``` public class Utilisateur extends Model<Utilisateur> { // Champs et accesseurs }

     // Utilisation Utilisateur user = new Utilisateur(); user.setNom("Paul").setAge(22); user.insert(); // Insertion en base

8. Classe Utilitaire SimpleQuery

   • Fonctionnalité : Emballe les résultats de selectList pour un traitement via des flux Stream, simplifiant les appels API.

   • Exemple : ``` List<Utilisateur> utilisateurs = SimpleQuery.list( Wrappers.lambdaQuery(Utilisateur.class) .eq(Utilisateur::getStatut, 1), Utilisateur::getId, user -> System.out.println("Traitement de l'utilisateur: " + user.getId()) );

9. Classe Utilitaire Db

   • Fonctionnalité : Permet d'exécuter des opérations CRUD via des appels statiques, évitant les problèmes d'injection circulaire dans Spring.

   • Exemple : ``` // Insertion Utilisateur utilisateur = new Utilisateur(); utilisateur.setNom("Utilisateur Test"); utilisateur.setAge(28); Db.save(utilisateur);

     // Requête Utilisateur recupere = Db.getById(Utilisateur.class, 2L);

Comparaison des Approches

MyBatis offre un contrôle total sur les requêtes SQL, idéal pour des scénarios complexes ou hautes performances. MyBatis-Plus accélère le développement en encapsulant les opérations courantes, mais avec moins de flexibilité pour les requêtes personnalisées. Le choix dépend des besoins spécifiques du projet en termes de rapidité d'exécution et de complexité des données.