(I) : Application du « Principe de ségrégation d'interface » avec Typescript et Java

Concepts

SOLID est un acronyme qui représente cinq principes fondamentaux de la programmation orientée objet, proposés par Robert C. Martin - Oncle Bob. Ici vous pouvez en savoir plus sur son article.
Ces principes visent à améliorer la structure et la maintenance du code, le rendant plus flexible, évolutif et plus facile à comprendre. De tels principes aident le programmeur à créer des codes plus organisés, en répartissant les responsabilités, en réduisant les dépendances, en simplifiant le processus de refactorisation et en favorisant la réutilisation du code.

Le « I » dans l'acronyme signifie « Interface Segregation Principe ». La phrase qu'oncle Bob a utilisée pour définir ce principe était :

"Aucun client ne devrait être obligé de dépendre d'interfaces qu'il n'utilise pas"

Le Principe de ségrégation des interfaces résout un problème courant : les interfaces trop grandes qui forcent des implémentations inutiles dans des classes qui n'en ont pas besoin.

Application pratique

Imaginez un système d'authentification dans une application, où différentes méthodes sont utilisées pour authentifier un utilisateur (par exemple, par mot de passe, par biométrie, par QR Code).

Tout d'abord, regardons l'application de cette classe sans utiliser le FAI en Java et Typescript :

Java

interface Authenticator {
    boolean authenticateWithPassword(String userId, String password);
    boolean authenticateWithBiometrics(String userId);
    boolean authenticateWithQRCode(String qrCode);
}

class PasswordAuthenticator implements Authenticator {
    @Override
    public boolean authenticateWithPassword(String userId, String password) {
        System.out.println("Authenticating with password...");
        return true;
    }

    @Override
    public boolean authenticateWithBiometrics(String userId) {
        throw new UnsupportedOperationException("Not implemented");
    }

    @Override
    public boolean authenticateWithQRCode(String qrCode) {
        throw new UnsupportedOperationException("Not implemented");
    }
}

Manuscrit

interface Authenticator {
  authenticateWithPassword(userId: string, password: string): boolean;
  authenticateWithBiometrics(userId: string): boolean;
  authenticateWithQRCode(qrCode: string): boolean;
}

class PasswordAuthenticator implements Authenticator {
  authenticateWithPassword(userId: string, password: string): boolean {
    console.log("Authenticating with password...");
    return true;
  }

  authenticateWithBiometrics(userId: string): boolean {
    throw new Error("Not implemented");
  }

  authenticateWithQRCode(qrCode: string): boolean {
    throw new Error("Not implemented");
  }
}

Problèmes :

1. Méthodes inutilisées : La classe PasswordAuthenticator implémente des méthodes qui n'ont pas de sens pour sa fonction.
2. Maintenance problématique : Si l'interface change, toutes les classes d'implémentation doivent être modifiées, même si elles n'utilisent pas les nouvelles méthodes.
3. Violation de responsabilité unique : Les classes commencent à traiter des préoccupations qui ne devraient pas être les leurs.

Pour résoudre le problème, nous pouvons diviser l'interface Authenticator en interfaces plus petites et plus spécifiques.

Java

interface PasswordAuth {
    boolean authenticateWithPassword(String userId, String password);
}

interface BiometricAuth {
    boolean authenticateWithBiometrics(String userId);
}

interface QRCodeAuth {
    boolean authenticateWithQRCode(String qrCode);
}

class PasswordAuthenticator implements PasswordAuth {
    @Override
    public boolean authenticateWithPassword(String userId, String password) {
        System.out.println("Authenticating with password...");
        return true;
    }
}

class BiometricAuthenticator implements BiometricAuth {
    @Override
    public boolean authenticateWithBiometrics(String userId) {
        System.out.println("Authenticating with biometrics...");
        return true;
    }
}

class QRCodeAuthenticator implements QRCodeAuth {
    @Override
    public boolean authenticateWithQRCode(String qrCode) {
        System.out.println("Authenticating with QR Code...");
        return true;
    }
}

Manuscrit

interface PasswordAuth {
  authenticateWithPassword(userId: string, password: string): boolean;
}

interface BiometricAuth {
  authenticateWithBiometrics(userId: string): boolean;
}

interface QRCodeAuth {
  authenticateWithQRCode(qrCode: string): boolean;
}

class PasswordAuthenticator implements PasswordAuth {
  authenticateWithPassword(userId: string, password: string): boolean {
    console.log("Authenticating with password...");
    return true;
  }
}

class BiometricAuthenticator implements BiometricAuth {
  authenticateWithBiometrics(userId: string): boolean {
    console.log("Authenticating with biometrics...");
    return true;
  }
}

class QRCodeAuthenticator implements QRCodeAuth {
  authenticateWithQRCode(qrCode: string): boolean {
    console.log("Authenticating with QR Code...");
    return true;
  }
}

Avantages de la refactorisation

1. Interfaces spécifiques : Chaque classe implémente uniquement les méthodes qu'elle utilise réellement.
2. Flexibilité : L'ajout de nouvelles méthodes ou modes d'authentification n'a pas d'impact sur les implémentations existantes.
3. Maintenance plus simple : réduit l'impact des modifications de code, évitant ainsi les refactorisations inutiles.

Conclusion

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!