Comment créer du code robuste avec le Single Level of Abstraction (SLA) et le Single Responsibility Principle (SRP) ?

01/02/2025

Dans le développement logiciel, la robustesse du code est un facteur crucial pour garantir des applications fiables, maintenables et évolutives. Deux principes fondamentaux pour atteindre cet objectif sont le Single Level of Abstraction (SLA) et le Single Responsibility Principle (SRP). Explorons ces concepts en détail.

Single Level of Abstraction (SLA)

Le principe SLA stipule que chaque fonction ou méthode doit opérer à un seul niveau d'abstraction. Cela signifie que le code doit être cohérent et ne pas mélanger des détails de bas niveau avec des concepts de haut niveau. En respectant ce principe, vous pouvez améliorer la lisibilité et la compréhension de votre code.

Exemple :

function processOrder(order: Order): void {
    // Tâche de haut niveau : Vérification de l'état de la commande
    validateOrder(order);

    // Tâche de bas niveau : Mise à jour de la base de données
    const connection: SqlConnection = new SqlConnection(connectionString);
    connection.open();
    const command: SqlCommand = connection.createCommand();
    command.commandText: string = "INSERT INTO Orders VALUES (...)";
    command.executeNonQuery();
    connection.close();

    // Tâche de haut niveau : Envoi de la confirmation par email
    sendConfirmationEmail(order);
}

Dans cet exemple, la fonction processOrder mélange des opérations de haut niveau (vérification de l'état de la commande, envoi de confirmation) avec des opérations de bas niveau (mise à jour de la base de données). Pour respecter le principe SLA, il serait préférable de séparer ces responsabilités.

Refactorisation :

function processOrder(order: Order): void {
    validateOrder(order);
    saveOrderToDatabase(order);
    sendConfirmationEmail(order);
}

function saveOrderToDatabase(order: Order): void {
    const connection: SqlConnection = new SqlConnection(connectionString);
    connection.open();
    const command: SqlCommand = connection.createCommand();
    command.commandText: string = "INSERT INTO Orders VALUES (...)";
    command.executeNonQuery();
    connection.close();
}

Single Responsibility Principle (SRP)

Le principe SRP, proposé par Robert C. Martin (Uncle Bob, co-auteur du Manifeste Agile), stipule qu'une classe ou un module doit avoir une, et une seule, raison de changer. En d'autres termes, chaque composant doit avoir une responsabilité unique. Cela facilite la maintenance et l'évolution du code, car les modifications sont localisées et n'affectent pas d'autres parties du système.

Exemple :

class Order {
    constructor(public orderId: string, public customer: Customer, public items: Item[]) {}

    calculateTotal(): number {
        // Calcul du total de la commande
        return this.items.reduce((total, item) => total + item.price, 0);
    }

    saveToDatabase(): void {
        // Sauvegarde de la commande dans la base de données
        saveOrder(this);
    }

    sendConfirmationEmail(): void {
        // Envoi de l'email de confirmation
        sendEmail(this.customer, this.orderId);
    }
}

Dans cet exemple, la classe Order a plusieurs responsabilités : calculer le total de la commande, sauvegarder la commande dans la base de données, et envoyer un email de confirmation. Pour respecter le principe SRP, il serait préférable de séparer ces responsabilités en différentes classes.

Refactorisation :

class Order {
    constructor(public orderId: string, public customer: Customer, public items: Item[]) {}

    calculateTotal(): number {
        // Calcul du total de la commande
        return this.items.reduce((total, item) => total + item.price, 0);
    }
}

class OrderRepository {
    saveToDatabase(order: Order): void {
        // Sauvegarde de la commande dans la base de données
        saveOrder(order);
    }
}

class EmailService {
    sendConfirmationEmail(customer: Customer, orderId: string): void {
        // Envoi de l'email de confirmation
        sendEmail(customer, orderId);
    }
}

Conclusion

En appliquant les principes SLA et SRP, vous pouvez améliorer la robustesse, la lisibilité et la maintenabilité de votre code. Ces principes encouragent une séparation claire des responsabilités et des niveaux d'abstraction, ce qui facilite la compréhension et l'évolution des systèmes logiciels.