Une application de gestion commence avec des dossiers Controller, Entity, Repository et Service. Trois ans plus tard, modifier une règle de retour touche un formulaire, deux listeners, une commande console et un import. Personne ne sait si le remboursement appartient à Commande, Paiement ou Support. Le problème n’est pas que Symfony manque de structure ; la structure technique initiale ne raconte plus les capacités du produit.
En pratique, l’objectif consiste à rendre le changement local. Une décision métier doit posséder un vocabulaire, un responsable, des données et des interfaces identifiables. Le projet peut conserver un seul dépôt et un seul déploiement tout en établissant des frontières fermes. La modularité commence dans les dépendances, pas dans le nombre de bundles ou de services réseau.
Contrairement à ce que suggère une arborescence propre, déplacer les classes ne suffit pas. Réorganiser les dossiers trop tôt peut masquer le travail difficile : un namespace Retour qui conserve les écritures croisées crée une façade de modularité. L’équipe doit partir des flux, des invariants et des conflits de responsabilité, puis déplacer le code à mesure que les contrats deviennent vrais et testés.
Dans un projet de développement web sur mesure, cette progression évite la grande réécriture. Elle sélectionne une douleur, ferme une frontière et mesure le résultat. Cette méthode sert notamment à une reprise d’application Symfony sur mesure lorsque le produit doit continuer à évoluer pendant la restructuration.
Reconnaître un domaine qui déborde la structure
Suivre une modification récente
Le diagnostic choisit cinq demandes livrées et relève les classes, tables, files et équipes touchées. Si une règle commerciale exige des changements dispersés dans plusieurs contrôleurs, la décision n’a plus de lieu. Si un module central change pour toutes les demandes, il porte probablement trop de responsabilités ou un vocabulaire faussement commun.
Les incidents complètent l’analyse. Un statut inexplicable, une correction SQL ou une relance réservée à un expert signalent une frontière absente. Le nombre de fichiers n’est pas le problème ; l’impossibilité de prédire les effets d’une modification l’est. Le coût caché se trouve dans les revues, la recette élargie et le diagnostic.
Observer les dépendances plutôt que les noms
Un namespace « Domain » peut dépendre de Doctrine, du client HTTP et de la session. Un service appelé « Manager » peut modifier quatre agrégats. L’équipe inspecte les imports, les écritures et les effets déclenchés. Le nom ne vaut qu’après la preuve de la dépendance.
Cartographier les capacités avant les dossiers
Un atelier part des verbes du métier : tarifer, accepter une commande, préparer une livraison, facturer, rembourser. Chaque capacité possède une décision et un résultat. Les participants identifient les mots ambigus. « Client » peut désigner un compte commercial, un destinataire ou un payeur ; partager le même objet crée des dépendances inutiles.
La carte note les systèmes sources, les données possédées et les événements importants. Elle ne cherche pas à produire un modèle parfait. Elle révèle les endroits où deux équipes pensent posséder la même règle ou où aucune ne la possède. Ces conflits deviennent les candidats prioritaires.
Commencer par la frontière qui coûte
L’équipe choisit un module dont les changements fréquents provoquent des régressions ou du support. Un domaine stable mais imparfait peut attendre. La priorité combine fréquence, coût d’erreur et possibilité d’isoler un pilote. Cette décision évite un programme de rangement sans bénéfice métier.
Donner à chaque module une responsabilité
Un module contient ses cas d’usage, ses règles, ses ports et ses adaptateurs. Il expose des commandes et des requêtes nommées avec le vocabulaire métier. Les autres modules n’instancient pas ses entités et n’appellent pas ses repositories. Ils passent par un contrat public réduit.
La structure peut utiliser des namespaces comme CommandeApplication, CommandeDomain et CommandeInfrastructure. Elle n’est pas obligatoire pour chaque petite capacité. Une arborescence moins profonde reste acceptable si les dépendances vont dans le bon sens et si les responsabilités sont comprises.
Éviter le bundle comme unité métier automatique
Le système de bundles sert surtout à empaqueter et réutiliser des extensions. Un module interne n’a pas besoin de sa propre extension de conteneur. La documentation des bonnes pratiques Symfony déconseille de créer un bundle pour organiser le seul code applicatif. Namespaces, configuration et tests suffisent souvent.
Séparer décision, orchestration et infrastructure
Le domaine porte les invariants et calculs indépendants des mécanismes. L’application orchestre un cas d’usage, contrôle la transaction et appelle les ports. L’infrastructure implémente base, HTTP, messagerie ou fichier. Cette séparation permet de tester une règle sans kernel tout en conservant des tests d’intégration sur Doctrine et Symfony.
Elle ne doit pas multiplier les interfaces sans raison. Un port est utile lorsqu’il représente une dépendance externe, une source variable ou une frontière qu’il faut simuler. Une classe interne stable peut être injectée directement. La clarté prime sur la pureté.
Garder le contrôleur à sa place
Le contrôleur traduit identité, paramètres et format, puis appelle le cas d’usage. Il ne calcule pas le remboursement et ne choisit pas la prochaine transition. Une commande console et un consommateur peuvent réutiliser la même orchestration avec des entrées différentes.
Utiliser Doctrine sans laisser l’ORM dessiner le métier
Une entité Doctrine peut aussi porter des comportements, mais elle ne doit pas devenir le graphe global de l’application. Les relations bidirectionnelles entre modules rendent chaque chargement et chaque migration imprévisibles. Une référence scalaire ou un objet de valeur limite l’exposition.
Les repositories appartiennent au module qui possède l’agrégat. Un autre module demande une information par requête publique ou projection. Les lectures transverses peuvent être optimisées sans donner un droit d’écriture. Cette dissociation réduit les dépendances tout en acceptant que le monolithe partage encore une base.
Faire évoluer le schéma par étapes compatibles
Le code lit l’ancien et le nouveau format pendant la transition. Un backfill borné remplit les données, les écarts sont comptés, puis l’écriture bascule. Le rollback applicatif reste possible avant le retrait final. La migration est testée sur un volume représentatif.
Choisir des échanges synchrones ou événementiels
Une commande synchrone convient lorsqu’une décision est nécessaire pour répondre et que l’échec doit annuler l’opération. Un événement décrit un fait déjà accepté et permet des conséquences différées. Publier un événement pour éviter un appel ne supprime pas la dépendance ; il ajoute délai, livraison multiple et reprise.
Le contrat d’événement contient un identifiant, une version, la date et les données minimales. Les consommateurs tolèrent une nouvelle livraison. Une outbox relie la transaction métier à la publication lorsque la perte d’événement est inacceptable. La file et les erreurs sont observées comme une capacité du produit.
Nommer l’état intermédiaire
Si le remboursement est accepté mais pas encore exécuté, l’interface l’affiche. Elle ne confond pas la mise en file avec le résultat. Le support connaît les statuts, la corrélation et le geste de reprise. La modularité reste visible dans la promesse utilisateur.
Cas concret : reprendre un domaine de retours
Cas concret hypothétique. Un distributeur gère les retours dans Commande, Support et Paiement. Un agent approuve, un listener déclenche un avoir et un cron remet le stock. Une panne du prestataire de paiement laisse certains dossiers sans statut. Relancer le cron peut produire un second avoir.
La cible crée un module Retour. Il possède demande, décision, motifs et état de remboursement. Paiement reçoit une commande idempotente et renvoie un résultat ; Stock consomme un événement après acceptation physique. L’interface distingue retour accepté, remboursement en attente, remboursé et intervention requise.
Le pilote reçoit les profils concernés et provoque une réponse perdue du prestataire, une demande déjà traitée et un refus de droit. Chaque résultat doit rester explicable ; aucun essai ne doit créer un second avoir. La durée et la couverture des essais se décident avec les responsables du flux, sans prétendre démontrer l’absence de tous les incidents possibles.
Mesurer la localisation du changement
Une nouvelle règle de délai doit toucher Retour et son contrat public, pas les contrôleurs de Support et de Paiement. L’équipe compare le nombre de modules modifiés, le temps de recette et les incidents. Le bénéfice vient de la réduction des effets imprévus.
Tester les règles et les frontières
Les tests unitaires exercent les invariants avec des objets simples. Les tests d’intégration vérifient mapping Doctrine, transactions et adaptateurs. Les tests de contrat fixent ce qu’un module accepte et renvoie. Quelques parcours de bout en bout prouvent l’assemblage sans porter toute la combinatoire.
Une règle d’architecture interdit les imports non autorisés. Elle est exécutée dans la CI. Les exceptions temporaires mentionnent motif, propriétaire et date de sortie. Une frontière non contrôlée se dégrade dès que la pression de livraison augmente.
Tester les refus comme des résultats
Un montant hors plafond, un rôle insuffisant ou un état périmé produit une erreur métier stable. Le contrôleur la traduit ; la règle ne dépend pas du format HTTP. Ces cas protègent la frontière mieux qu’un test qui vérifie seulement la réponse nominale.
Faire respecter l’architecture par l’outillage
Composer et l’autoloading reflètent les namespaces. La configuration des services peut limiter les ressources découvertes par l’autowiring, tandis que les services restent privés par défaut. Des outils d’analyse statique détectent dépendances interdites et types ambigus. Les commandes de CI restent rapides pour être exécutées à chaque changement.
La journalisation ajoute module, cas d’usage et corrélation. Le monitoring suit erreurs par capacité et messages en attente. Un tableau global sans propriété produit peu d’action ; une alerte Retour doit mener au runbook et à l’équipe responsable.
Documenter les décisions qui changent le code
Une décision courte explique pourquoi une frontière existe, quelles alternatives ont été refusées et quel signal déclencherait une révision. Elle ne remplace pas les tests. Elle aide les nouveaux arrivants à distinguer une contrainte d’une préférence.
Attribuer la responsabilité des modules
Chaque capacité possède un référent métier et un collectif technique, pas forcément une équipe exclusive. Ils valident contrats, changements sensibles et incidents. Le référent ne devient pas un goulot : la connaissance est partagée par revue, rotation et exercices de reprise.
La roadmap suit les dettes de frontière comme des risques produit. Une dépendance illégale peut être temporairement acceptée si son retrait est planifié. Sans échéance, l’exception devient la nouvelle architecture. Le responsable arbitre avec coût et bénéfice visibles.
Pour qui la modularisation doit rester légère
Une petite application stable n’a pas besoin de seize modules et de trois couches par fonctionnalité. Regrouper des capacités proches réduit la cérémonie. La séparation devient utile quand vocabulaire, fréquence de changement, données ou responsabilité divergent.
Un domaine en croissance bénéficie d’une modularisation progressive. Il n’a pas besoin de microservices immédiats. Si une capacité acquiert plus tard une charge ou une équipe autonome, ses contrats et sa propriété de données rendent l’extraction plus sûre.
Erreurs fréquentes quand le domaine grossit
Réorganiser tous les dossiers en une fois
La grande bascule produit un diff impossible à relire et mélange déplacement, comportement et migration. L’équipe ferme une frontière, garde les tests verts puis poursuit. Les anciens chemins peuvent cohabiter brièvement avec une échéance.
Créer une interface pour chaque classe
Une abstraction sans alternative ni frontière augmente le vocabulaire sans protéger le métier. Les interfaces se concentrent sur les ports, les contrats publics et les dépendances instables.
Partager un modèle canonique universel
Forcer tous les modules à utiliser le même Client, Produit ou Statut lie leurs évolutions. Les traductions locales paraissent redondantes, mais elles protègent des sens et des cycles distincts.
Arbitrer une nouvelle frontière
La matrice examine vocabulaire propre, invariants, données, fréquence de changement, incidents et responsabilité. Un candidat fort cumule plusieurs signaux. Une simple différence d’écran ne justifie pas un module séparé.
Le comité peut isoler maintenant, observer ou refuser. Il isole quand la dépendance coûte déjà et qu’un contrat est testable. Il observe quand les usages restent incertains. Il refuse lorsque la frontière ne possède ni décision ni données propres.
- D’abord, prioriser la capacité où les régressions et corrections manuelles consomment le plus de temps.
- Ensuite, commencer par interdire les nouvelles écritures croisées avant de déplacer tout le code.
- Puis, différer l’événement asynchrone tant que le délai et la reprise ne sont pas acceptés.
- Enfin, étendre lorsque le changement, le refus et l’incident restent locaux au module.
Plan d’action : extraire une capacité puis vérifier son autonomie
Établir la preuve du problème à résoudre
L’équipe suit changements et incidents, cartographie capacités et choisit une douleur. Elle fixe le résultat attendu, les seuils et le périmètre. Les responsabilités métier et techniques sont nommées.
Créer le contrat avant de déplacer le code
Les entrées, sorties, refus et dépendances sont écrits. Les tests de règle et de contrat précèdent les déplacements. L’ancien code appelle progressivement la nouvelle orchestration. La CI bloque les nouvelles violations.
Migrer les écritures et les lecteurs concernés
Les écritures rejoignent le module, les lectures transverses utilisent une requête publique et les messages nécessaires deviennent idempotents. La journalisation porte module et corrélation. Le monitoring relie chaque seuil à une action.
Éprouver les incidents avant d’étendre le périmètre
Un lot limité passe par le nouveau chemin. Le support exécute le runbook, un retry et le rollback. Le dossier final décrit contrat, dépendances, instrumentation, erreurs et dettes. L’équipe élargit seulement si les mesures locales tiennent sans aide orale.
Le pilote provoque aussi une version d’événement inconnue, un remboursement déjà exécuté et une référence de commande supprimée. Chaque cas doit produire un refus stable ou une reprise documentée. Le responsable métier confirme que le statut visible correspond à la décision, tandis que l’équipe technique retrouve la trace et la dépendance sans parcourir les autres modules.
La revue finale compare le délai d’une modification de règle, la surface de recette, les écritures croisées et le temps nécessaire pour expliquer un incident. Elle garde les mesures brutes et les limites de l’échantillon. Si le changement reste diffus, l’équipe corrige la frontière avant de déplacer une nouvelle capacité ; si le résultat tient, elle reprend la même méthode sur la douleur suivante.
Transmettre les décisions et les moyens de diagnostic
La mise en œuvre attribue explicitement les responsabilités de la CI, du monitoring et du rollback. Elle nomme les entrées, les sorties, les dépendances et le seuil d’arrêt. Cette gouvernance empêche le module de devenir un simple dossier neuf autour d’un ancien couplage, tout en donnant à la maintenance un contrat vérifiable au prochain changement.
Une décision d’architecture courte consigne la frontière choisie, les solutions écartées et le signal qui déclencherait une révision. Produit et support la relisent avec un exemple de dossier, car un vocabulaire compris seulement par les développeurs ne localise pas la responsabilité. Cette trace aide une nouvelle personne à distinguer un invariant durable d’un compromis temporaire.
Le pilote inclut un contrôle de performance ciblé sur les nouvelles requêtes publiques. Une projection plus claire peut introduire une lecture coûteuse ou un chargement excessif ; l’équipe mesure plan SQL, volume et latence sur les données représentatives. Elle optimise le contrat sans redonner aux consommateurs un accès direct aux tables, afin que la pression du run ne dissolve pas la frontière obtenue.
La sortie de cette phase n’est pas une arborescence figée. C’est une capacité dont une nouvelle personne peut comprendre le vocabulaire, modifier une règle, observer un refus et reprendre un incident à partir des contrats publics. Ce critère protège l’adoption interne et révèle rapidement les abstractions qui n’aident que leurs auteurs.
Exemple technique : extraire une règle sans déplacer toute l’application
Dans cet exemple, gardez le projet livré en un seul ensemble et faites passer la décision de retour par le même service depuis le formulaire et l’import. Le calcul détermine une quantité éligible et un motif. Le traitement applicatif qui confirme le retour porte la transaction et vérifie la quantité encore disponible avant l’écriture. Le conteneur de services Symfony permet de fournir l’adaptateur de lecture au traitement. La cohérence dépend ensuite du mécanisme de transaction exercé par le test de concurrence.
Exemple fictif : une règle de retour vérifie une période autorisée et une quantité encore éligible. Son calcul ne doit pas dépendre du contrôleur qui reçoit la demande. Commencez par écrire les entrées et les refus attendus, puis faites appeler la même décision par le formulaire et par l’import.
Retour/
Domain/PolitiqueRetour.php
Application/DemanderRetour.php
Application/CommandeLecture.php
Infrastructure/DoctrineCommandeLecture.php
UI/Http/DemanderRetourController.php
Cette arborescence illustre un découpage possible, sans constituer une convention imposée par Symfony. Le port de lecture fournit les informations nécessaires à la décision ; son adaptateur charge les données. Un petit module peut conserver moins de répertoires si ses responsabilités restent claires et ses dépendances contrôlées.
Recevoir le déplacement avec des comportements observables
| Essai | Résultat attendu | Ce qu’il protège |
|---|---|---|
| Même dossier reçu par formulaire et import | Même décision et même motif de refus. | Absence de règle dupliquée dans les points d’entrée. |
| Deux demandes concurrentes sur la même quantité | La quantité acceptée ne dépasse pas le disponible. | Invariant conservé par le mécanisme transactionnel choisi. |
| Nouvelle livraison du même message | Aucun second remboursement. | Reconnaissance d’un effet déjà exécuté. |
Le premier test peut rester unitaire pour le calcul pur. La concurrence et la transaction exigent un essai d’intégration avec les mécanismes réellement utilisés. Un test qui invoque deux fois la méthode à la suite ne prouve pas le comportement de deux traitements simultanés.
Garder la configuration Symfony explicite
Si plusieurs adaptateurs implémentent le même port, la configuration doit identifier celui qui sera injecté dans le contexte concerné. L’autowiring simplifie le câblage, mais ne décide pas quelle source possède la donnée. Contrôlez la compilation du conteneur et le parcours complet après le déplacement, y compris ses droits et sa configuration de production.
La documentation officielle de Messenger rappelle qu’un message peut être livré plusieurs fois. La reconnaissance des effets déjà produits reste donc une responsabilité applicative ; activer une file et des nouvelles tentatives ne suffit pas à garantir un remboursement unique.
Un enregistrement local de l’événement avec la décision métier peut sécuriser la publication ultérieure, selon l’architecture retenue. Il reste nécessaire de traiter l’intervalle où le prestataire a accepté un remboursement mais où la réponse est perdue. Une référence stable et un rapprochement avec le destinataire doivent rendre cet état explicable avant toute relance.
Préparer l’évolution du schéma et des lecteurs
Une extraction change parfois une colonne, un statut ou une projection. Décrivez quelles versions applicatives peuvent encore lire les données pendant le déploiement et le retour arrière. Un changement compatible s’installe avant le retrait de l’ancien format ; les tâches et les exports oubliés doivent également rejoindre l’inventaire des lecteurs.
Le signal d’alerte apparaît quand un module est déclaré autonome mais qu’un traitement de nuit continue de modifier ses tables. Recherchez ces écritures dans commandes, imports et scripts d’exploitation. Leur suppression ou leur adaptation fait partie du lot, avec un responsable et une preuve de rapprochement des données après migration.
Relier la modularisation à une reprise Symfony exploitable
Une application déjà utilisée ne peut pas toujours suspendre ses évolutions pour réorganiser son code. Choisissez une capacité limitée, empêchez les nouvelles dépendances interdites et laissez les autres changements suivre leur rythme. Le coût caché d’un déplacement global apparaît dans les conflits de développement et les recettes qu’il faut élargir sans bénéfice visible pour les métiers.
Notre accompagnement en reprise et migration d’applications Symfony rapproche audit du socle, règles métier et conditions de livraison. La frontière technique retenue doit pouvoir être livrée, observée et maintenue dans le SI du client, avec ses contraintes d’hébergement et d’accès.
Livrer un dossier que l’équipe suivante peut utiliser
La réception rassemble contrat public, règles de dépendance, tests, changements de données et procédure d’incident. Elle nomme les réserves et les anciennes écritures encore tolérées. La DSI peut alors accepter le lot sur des preuves identifiées ; la maintenance retrouve les décisions sans dépendre exclusivement de la personne qui a déplacé le code.
Guides complémentaires pour prolonger le découpage
Pour identifier une frontière à partir des transactions, commencez par la cartographie des écritures. Si le socle doit évoluer aussi, le plan de migration Symfony aide à prévoir la montée de version et ses propres preuves.
Ces lectures approfondissent les choix de structure et de recette lorsque la première frontière devient testable dans votre application.
Maintenir un monolithe modulaire
Tenir un monolithe Symfony modulaire relie frontières, transactions et décision d’extraction.
Découper le domaine
Découper un domaine fonctionnel approfondit responsabilités, langage et contrats entre capacités.
Tester le workflow
Tester les exceptions d’un workflow aide à rendre les refus et reprises indépendants de l’interface.
- Partir d’une décision métier douloureuse plutôt que d’une arborescence idéale.
- Fermer les écritures et dépendances avant de multiplier les mécanismes d’échange.
- Vérifier chaque frontière par un changement, un refus et un incident simulé.
Conclusion : rendre le changement local
Choisissez une règle qui change souvent et donnez-lui une seule porte d’entrée métier. Vérifiez que les appels du formulaire et de l’import rendent la même décision, puis soumettez deux demandes concurrentes pour recevoir l’écriture réelle.
Consignez la raison du découpage, les entrées autorisées et le module qui confirme le retour. L’équipe peut alors modifier la politique d’éligibilité et retrouver les preuves de fonctionnement dans le même projet.
Notre accompagnement en reprise et migration de projets Symfony permet de tester ce premier déplacement sur le projet existant et d’en mesurer les effets pour le métier.