Refactoriser l'héritage PHP pour adhérer à des principes solides

Pour refactoriser le code PHP hérité, la réponse est d'améliorer la maintenabilité, la testabilité et la flexibilité du code grâce à une amélioration progressive plutôt qu'à une réécriture unique; Les pratiques spécifiques comprennent: 1. Suivez le principe de la responsabilité unique et divisez les classes qui assument trop de responsabilités en petites classes qui ne sont responsables que de fonctions spécifiques; 2. Suivez le principe de l'ouverture et de la fermeture, développez les fonctions à travers les interfaces et les mécanismes polymorphes plutôt que de modifier le code d'origine; 3. Suivez le principe du remplacement de Richter pour vous assurer que les sous-classes peuvent remplacer de manière transparente les classes des parents sans modifier l'exactitude du programme; 4. Suivez le principe de l'isolement de l'interface et divisez l'interface gonflée en interfaces dédiées plus petites; 5. Suivez le principe de l'inversion de la dépendance et faites en sorte que les modules de haut niveau dépendent de l'abstraction plutôt que de la mise en œuvre concrète par injection de dépendance; En fonctionnement réel, les tests doivent être rédigés en premier, les codes de problème doivent être identifiés et refactorisés par petites étapes, et avec l'aide de l'outil, améliorent progressivement la qualité du code plutôt que de poursuivre une perfection unique, et finalement rendre le code plus facile à comprendre et à développer.

Refactoriser le code PHP hérité pour suivre les principes solides ne consiste pas à réécrire tout du jour au lendemain - il s'agit d'apporter des améliorations incrémentielles et réfléchies qui augmentent la maintenabilité, la testabilité et la flexibilité. Les systèmes hérités souffrent souvent d'un couplage serré, d'une mauvaise séparation des préoccupations et de classes gonflées. L'application de principes solides aide à résoudre ces problèmes systématiquement.

Voici comment aborder le code PHP hérité de refactorisation avec chaque principe solide à l'esprit:

1. Principe de responsabilité unique (SRP)

Une classe ne devrait avoir qu'une seule raison de changer.

Dans Legacy PHP, vous trouverez souvent des classes qui font trop - de la maintien des requêtes de base de données, de la mise en forme de sortie, de la validation des entrées et de la gestion de la logique métier dans un seul fichier.

Que rechercher:

• Classes avec plusieurs méthodes publiques faisant des choses sans rapport
• De longues méthodes qui mélangent l'accès aux données, la logique et la sortie
• Contrôleurs qui gèrent également la validation ou la persistance

Comment le réflecteur:

• Briser les grandes classes en plus petites et concentrées
• Extraire la validation, le formatage ou l'accès aux données dans des classes dédiées
• Utilisez des cours de service pour encapsuler la logique commerciale

Exemple:

 // avant: classe d'utilisateurs en faisant trop
classe utilisateur {
    Fonction publique Save () {/ * enregistre sur db * /}
    Fonction publique SendWelcomeMail () {/ * Envoie un e-mail * /}
    Fonction publique Valider () {/ * Validation Logic * /}
}

// après: responsabilité séparée
class userservice {
    Registre des fonctions publiques (data userData $) {
        $ this-> validator-> valider ($ data);
        $ this-> userRepository-> Enregistrer ($ utilisateur);
        $ this-> e-mailservice-> SendWelcome ($ utilisateur);
    }
}

Cela rend chaque classe plus facile à tester et à modifier indépendamment.

2. Principe ouvert / fermé (OCP)

Les entités logicielles doivent être ouvertes à l'extension, mais fermées pour la modification.

Le code hérité nécessite souvent de modifier le code existant pour ajouter de nouvelles fonctionnalités - cela augmente le risque de briser quelque chose.

Que rechercher:

• Instructions de commutation ou de chaînes IF / ELONE BASE SUR TYPE
• Fonctions qui doivent être modifiées chaque fois qu'une nouvelle fonctionnalité est ajoutée

Comment le réflecteur:

• Utilisez des interfaces et du polymorphisme
• Remplacez les conditions par des modèles de stratégie ou d'usine

Exemple:

 // avant: l'ajout d'un nouveau mode de paiement nécessite de modifier ce code
Fonction ProcessPayment ($ Type, $ Montant) {
    if ($ type === 'paypal') {
        // traite PayPal
    } elseif ($ type === 'Stripe') {
        // traite la bande
    }
}

// après: s'étendre via de nouvelles classes, pas de modification
Interface Payment Processeur {
    Processus de fonction publique (Montant Float $): void;
}

Classe PayPalProcessor implémente PaymentProcessor {/ * ... * /}
Classe StripeProcessor implémente Paysprocessor {/ * ... * /}

Class PaymentService {
    Processus de fonction publique (Processeur de paiement de paiement $, Float $ Montant) {
        $ processeur-> processus (montant $);
    }
}

Vous pouvez maintenant ajouter de nouvelles méthodes de paiement sans toucher à la logique existante.

3. Principe de substitution de Liskov (LSP)

Les sous-types doivent être substituables à leurs types de base.

Cela devient souvent violent lorsque l'héritage est utilisé de manière incorrecte dans le code hérité - EG, une classe d'enfants l'emporte sur une méthode parent d'une manière qui rompt les attentes.

Que rechercher:

• Classes d'enfants lançant NotImplementedException
• Méthodes qui changent le comportement de manière inattendue
• Héritage utilisé uniquement pour la réutilisation du code, pas vrai

Comment le réflecteur:

• Favoriser la composition sur l'héritage
• Utilisez des interfaces pour définir les contrats
• Les hiérarchies de restructuration afin que les classes dérivées ne surprennent pas les utilisateurs

Exemple: Évitez de créer une classe Rectangle et la sous-classe en Square si la largeur du réglage affecte la hauteur de façon inattendue. Utilisez plutôt la composition ou des classes indépendantes séparées.

4. Principe de ségrégation de l'interface (ISP)

Les clients ne devraient pas être obligés de dépendre des interfaces qu'ils n'utilisent pas.

Dans Legacy PHP, vous pourriez voir de grandes interfaces ou des classes de base avec de nombreuses méthodes, forçant les implémenteurs à échouer inutilisé.

Que rechercher:

• Interfaces avec trop de méthodes
• Classes mettant en œuvre des méthodes dont ils n'ont pas besoin (par exemple, retourner null ou lancer des exceptions)

Comment le réflecteur:

• Diviser les grandes interfaces en plus petites et basées sur des rôles
• Laissez les classes implémenter uniquement ce dont ils ont besoin

Exemple:

 // avant: une grande interface
Interface Usermanagement {
    Fonction publique Save ();
    fonction publique delete ();
    fonction publique SendEmail ();
    Fonction publique GenerateReport ();
}

// après: interfaces séparées
Interface Storable {Fonction publique Save (); }
interface amovible {public function delete (); }
Interface Mailable {Fonction publique SendEmail (); }
Interface signalable {public function generateReport (); }

Classe GuestUser implémente le stockage, envoyez par la poste {}
L'administrateur de classe implémente le stockage, amovible, signalable {}

Maintenant, les cours ne dépendent que de ce qu'ils utilisent réellement.

5. Principe d'inversion de dépendance (DIP)

Dépendent des abstractions, pas des bétons.

Le PHP Legacy a souvent des dépendances codées en dur (par exemple, new Database() dans une classe), ce qui rend les tests et échangez des implémentations difficiles.

Que rechercher:

• new mot-clé utilisé dans la logique commerciale
• Noms de classe codés en dur dans les méthodes
• Difficulté à moquer les dépendances dans les tests

Comment le réflecteur:

• Injecter des dépendances via le constructeur ou la méthode
• Utilisez des interfaces pour se découpler à partir des implémentations concrètes
• Introduction Un conteneur DI simple si nécessaire (même l'injection manuelle aide)

Exemple:

 // avant: couplage serré
class userservice {
    Private $ dB;
    fonction publique __construct () {
        $ this-> db = new mysqldatabase (); // codé en dur
    }
}

// Après: injection de dépendance
class userservice {
    Fonction publique __construct (private databaseInterface $ db) {}

    fonction publique getuser ($ id) {
        return $ this-> db-> fetch ('utilisateurs', $ id);
    }
}

Vous pouvez maintenant injecter une base de données simulée pour tester ou passer à un autre backend de stockage.

Étapes pratiques pour refactoriser le code hérité

Vous n'avez pas besoin d'appliquer tous les principes solides à la fois. Commencez petit:

• Écrivez d'abord les tests (s'il n'existe pas): utilisez des tests d'intégration ou d'unité pour épingler le comportement de courant.
• Identifiez les pires délinquants : recherchez les cours de Dieu, les longues méthodes ou les zones de désabonnement élevé.
• Refactor en petites étapes : Extraire Méthodes → Extraire Classes → Introduction Interfaces → Dépendances inversées.
• Utiliser des outils : le phpstan, le psaume ou le recteur peuvent aider à détecter les problèmes et à automatiser un peu de refactorisation.
• Ne visez pas la perfection : rendez-la légèrement meilleure qu'auparavant. Progrès sur la pureté.

Solid n'est pas une liste de contrôle de réécriture - c'est un état d'esprit. Dans Legacy PHP, l'application de ces principes conduit progressivement à un code plus facile à comprendre, à tester et à étendre. Commencez par SRP et DIP; Ils donnent souvent les plus grandes victoires avec le moindre risque.

Fondamentalement, ne laissez pas le parfait être l'ennemi du meilleur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!