Que signifie Single Level of Abstraction (SLA) et Single Responsibility Principle (SRP) en développement logiciel ?
Continuer
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.
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();
}
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);
}
}
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.