Injection de dépendances dans Salesforce / Blogs / Perficient

Dans le développement de logiciels modernes, les modèles de conception jouent un rôle crucial dans la création d’applications évolutives et maintenables. Un de ces modèles puissants est Injection de dépendances (DI). Bien qu’elle soit largement reconnue dans d’autres paradigmes de programmation, la DI peut également être utilisée efficacement dans Salesforce pour promouvoir un code propre, modulaire et testable.

Que vous soyez un développeur Salesforce chevronné ou que vous commenciez tout juste votre parcours, la compréhension et la mise en œuvre de l’injection de dépendances peuvent améliorer la conception de votre application.

Qu’est-ce que l’injection de dépendances ?

L’injection de dépendances est un modèle de conception dans lequel les dépendances d’un objet (telles que des services, des référentiels ou des configurations) sont fournies en externe plutôt que par l’objet qui les crée lui-même. Cette approche favorise un couplage lâche entre les composants et améliore la flexibilité.

Dans Salesforce, ce modèle devient particulièrement utile pour les classes Apex, les composants Web Lightning (LWC) et les frameworks personnalisés.

Principaux avantages de l’injection de dépendances dans Salesforce

1. Couplage lâche : Les composants ne sont plus étroitement liés à des implémentations spécifiques, ce qui les rend plus faciles à remplacer ou à modifier.
2. Testabilité améliorée : Les dépendances peuvent être simulées ou remplacées par des implémentations de tests, conduisant à des tests unitaires plus efficaces.
3. Réutilisabilité : Les services partagés peuvent être injectés dans plusieurs classes, évitant ainsi la redondance.
4. Évolutivité : Les applications deviennent plus modulaires et plus simples à étendre à mesure que les besoins de l’entreprise augmentent.

Implémentation de l’injection de dépendances dans Salesforce

1. Utilisation des interfaces dans Apex

L’un des moyens les plus simples d’implémenter DI dans Salesforce consiste à utiliser des interfaces. Cela garantit qu’une classe ne s’appuie pas sur une implémentation spécifique mais peut fonctionner avec n’importe quel objet implémentant l’interface.

Exemple : injection de classe de service

// Define an interface
public interface GreetingService {
    String getGreeting();
}

// Implement the interface
public class MorningGreetingService implements GreetingService {
    public String getGreeting() {
        return 'Good Morning!';
    }
}

// Another implementation
public class EveningGreetingService implements GreetingService {
    public String getGreeting() {
        return 'Good Evening!';
    }
}

// Consumer class using Dependency Injection
public class GreetingController {
    private GreetingService greetingService;

    // Constructor injection
    public GreetingController(GreetingService service) {
        this.greetingService = service;
    }

    public String deliverGreeting() {
        return greetingService.getGreeting();
    }
}

Usage

GreetingController controller = new GreetingController(new MorningGreetingService()); System.debug(controller.deliverGreeting()); // Output: Good Morning!

2. Utilisation de métadonnées personnalisées pour les dépendances configurables

Salesforce vous permet d’externaliser les configurations à l’aide de métadonnées personnalisées, rendant ainsi la gestion des dépendances dynamique.

Exemple : injection de service dynamique

1. Créer des métadonnées personnalisées pour mapper les classes aux services :
   • Nom: MorningGreetingService
   • Nom de la classe : MorningGreetingService
2. Utiliser Reflection pour injecter des services de manière dynamique

public class GreetingController {
    private GreetingService greetingService;

    public GreetingController() {
        String serviceName="MorningGreetingService"; // Dynamically retrieved, e.g., from Custom Metadata
        greetingService = (GreetingService) Type.forName(serviceName).newInstance();
    }

    public String deliverGreeting() {
        return greetingService.getGreeting();
    }
}

Avantage: Basculez facilement entre les services en mettant à jour les métadonnées sans modifier le code.

3. Application de l’injection de dépendances dans LWC

Dans Lightning Web Components, la DI peut être réalisée en externalisant la logique dans des modules JavaScript partagés ou en injectant des services via des événements personnalisés ou des API.

Exemple : injecter un service

// service.js
export function getGreeting() {
    return 'Hello from the Service!';
}

// LWC Component
import { LightningElement } from 'lwc';
import { getGreeting } from 'c/service';

export default class GreetingComponent extends LightningElement {
    greeting;

    connectedCallback() {
        this.greeting = getGreeting();
    }
}

Cas d’utilisation réels

1. Configuration multi-environnement : Injecter différents services en fonction de l’environnement (ex : Sandbox, Production).
2. Logique métier dynamique : Échangez les règles métier ou les algorithmes, pilotés par des métadonnées personnalisées, sans altérer la logique de base.
3. Tests et moqueries : Remplacez les services réels par des services fictifs dans les tests unitaires pour valider les cas extrêmes.

Exemple : services moqueurs dans les classes de test

@IsTest
public class GreetingControllerTest {
    private class MockGreetingService implements GreetingService {
        public String getGreeting() {
            return 'Mock Greeting!';
        }
    }

    @IsTest
    static void testGreeting() {
        GreetingController controller = new GreetingController(new MockGreetingService());
        System.assertEquals('Mock Greeting!', controller.deliverGreeting());
    }
}

Meilleures pratiques

• Utilisez les interfaces à bon escient : Concevez des interfaces flexibles capables de s’adapter aux changements futurs.
• Tirez parti des métadonnées personnalisées : Externalisez la configuration pour rendre le système dynamique et éviter le codage en dur.
• Réduire la logique du constructeur : Gardez les constructeurs légers pour éviter la complexité.
• Combinez DI avec des tests unitaires : Assurez-vous que les dépendances sont simulables pour une meilleure couverture des tests.

Conclusion

L’injection de dépendances change la donne pour les développeurs Salesforce qui souhaitent écrire du code propre, maintenable et évolutif. En adoptant ce modèle, vous pouvez réduire le couplage, améliorer la réutilisabilité et créer un système qui s’adapte au changement sans effort.

Que vous créiez des services Apex, des LWC dynamiques ou que vous exploitiez des métadonnées personnalisées pour les configurations, DI vous permet de concevoir de meilleures applications. Commencez petit, explorez son potentiel et regardez vos solutions Salesforce atteindre de nouveaux sommets d’efficacité et d’élégance. Bon codage ! 🚀

Sécuriser votre écosystème Salesforce : un guide complet d’utilisation de Checkmarx