• Accueil / Salesforce / Blog de Bob…

Blog de Bob Buzzard : ApexTypeImplementor au printemps 225 minutes de lecture


, Blog de Bob Buzzard : ApexTypeImplementor au printemps 22<span class="wtr-time-wrap after-title"><span class="wtr-time-number">5</span> minutes de lecture</span>


Remarque : Cette fonctionnalité peut être en version bêta au printemps 22 : les notes de version dans
L’aide de Salesforce dit qu’il est en version bêta, la version PDF n’en fait pas mention.
Si je reçois une confirmation de toute façon, je mettrai à jour ce post! Souviens-toi de ce printemps
22 est toujours en avant-première, donc cette fonctionnalité pourrait ne jamais voir le jour
en tous cas!

introduction

La version Spring 22 de Salesforce introduit le
ApexTypeImplémenteur objet, qui
contient des informations sur les classes qui implémentent une interface, soit
directement ou indirectement. Vous avez pu accéder aux corps de classe Apex pendant
années, donc la mise en œuvre directe d’une interface a été
possible pendant un certain temps. Comprendre que l’interface est implémentée dans
la hiérarchie d’héritage devient un peu plus délicate. Dans les deux cas, avoir le
la plate-forme s’en occupe pour vous enlève un morceau de code, qui est toujours un
bonne chose.

Cas d’utilisation

Lorsque je suis tombé sur cette nouvelle fonctionnalité pour la première fois, elle avait une touche de « solution
à la recherche d’un problème » à ce sujet, mais une fois que j’ai eu la chance de creuser dans un
un peu plus de détails, j’ai un certain nombre de scénarios où je pourrai appliquer
dès qu’il sera disponible/peut-être hors de la version bêta.

Moteur de règles

Le cas d’utilisation le plus courant de mon point de vue est le plug and play configurable
moteur. J’ai plusieurs moteurs de règles où une classe est considérée comme une règle
car il implémente une interface spécifique. J’aurai un certain nombre de cours qui
mettre en œuvre des variantes de règles, et ces règles sont activées et appliquées dans un
commande en fonction de la configuration.

ApexTypeImplementor n’aide pas en termes de classes de règles à utiliser
appliqué, car je veux toujours qu’il soit piloté par la configuration plutôt que par le
code simplement en appliquant tout ce qu’il peut trouver dans n’importe quel ordre dans lequel ils reviennent.
Là où cela aide, c’est d’aider l’administrateur qui configure les règles. Plutôt
qu’eux doivent se souvenir des noms des classes ou les rechercher et
copier/coller à partir d’autres pages de configuration, je peux créer une page de configuration personnalisée
qui ne leur propose que les classes qui implémentent l’interface, assurant ainsi
que les classes configurées sont disponibles.

Vérification de la configuration

Un cas d’utilisation moins évident est la confirmation qu’un système est installé et configuré
correctement – c’est-à-dire qu’il n’y a pas de configuration manquante ou manifestement cassée
cela provoquera des erreurs lors de l’exécution. Chaque fonctionnalité qui peut être activée a un
classe associée qui vérifie que la fonctionnalité est configurée correctement (ou au moins
plausible car il est assez difficile de confirmer l’exactitude sans exécuter un tas de
essais). Tant que chacune de ces classes implémente la même interface, je peux
exécuter le code d’un administrateur en cliquant sur un bouton ou une action rapide qui trouve tout
les classes qui implémentent l’interface de vérification. Chacun de ceux-ci est
instancié et la méthode qui vérifie la configuration est exécutée. Cette
fonctionne très bien si les fonctionnalités supplémentaires sont fournies via une organisation dépendante
ou des packages déverrouillés, comme le code qui implémente la fonctionnalité et le code
qui vérifie qu’il sont développés en tandem.

Confirmation de formation

Le troisième cas d’utilisation que j’ai concerne la formation et la garantie que le
la formation a été retenue. J’ai une collection de colis que je peux déposer
dans une organisation qui demande à l’utilisateur d’effectuer une configuration ou
travail commercial, puis vérifier qu’ils l’ont exécuté correctement.

Pour le moment, les packages créent des entrées de configuration lorsqu’ils sont
installé, et ces entrées de configuration sont utilisées pour générer des cartes sur un
page de l’application afin que les utilisateurs puissent accéder et vérifier les défis. Parce que je
veulent que tous les défis qui sont installés soient disponibles pour l’utilisateur,
avec le ApexTypeImplémenteur je peux
supprimez les entrées de configuration et affichez simplement les détails des utilisateurs de tous
les classes qui implémentent l’interface.

Exemple d’application

J’ai créé un exemple d’application dans mon Référentiel Spring 22 à
Afficher ApexTypeImplémenteur utilisé
en colère. J’ai une interface qu’une classe implémente pour se décrire
parties intéressées :

public interface ClassInfoIF 
{
    String getDescription();
    String getAuthor();
}

J’utilise un composant Web Lightning pour afficher les détails des classes,
qui les extrait d’un contrôleur dédié (qui implémente également le
interface !) :

@AuraEnabled(cacheable=true)
public static List GetClassDetails()
{
    List classDetails=new List();
    List classInfoTypes = 
           [SELECT ApexClassId, ClassName, ClassNamespacePrefix
            FROM ApexTypeImplementor
            WHERE InterfaceName = 'ClassInfoIF' and IsConcrete=true];

    for (ApexTypeImplementor classInfoType : classInfoTypes)
    {
        ClassDetail classDetail=new ClassDetail();
        classDetail.classId=classInfoType.ApexClassId;
        classDetail.fullName='';
        if (null!=classInfoType.ClassNamespacePrefix)
        {
            classDetail.fullName=classInfoType.ClassNamespacePrefix + '.';
        }

        classDetail.fullName+=classInfoType.ClassName;
        ClassInfoIF classInfo = 
                    (ClassInfoIF) Type.forName(classInfoType.ClassNamespacePrefix,
                                            classInfoType.ClassName).newInstance();

        classDetail.description=classInfo.getDescription();
        classDetail.author=classInfo.getAuthor();
        classDetails.add(classDetail);
    }

    return classDetails;
}

Les sections en gras ci-dessus montrent la requête qui extrait les classes qui implémentent l’interface et le code qui construit la classe en tant qu’instance de ClassInfoIF et exécute les méthodes qui décrivent la classe. Si une nouvelle classe est ajoutée à l’organisation qui implémente cette interface, elle est automatiquement incluse la prochaine fois que j’accède à la page.

J’ai également mis quelques fausses classes, dont une qui implémente l’interface en remplaçant les méthodes de sa superclasse pour vérifier que le côté indirect des choses fonctionne également. L’accès à la page de candidature affiche les informations qui m’intéressent pour chaque classe :

, Blog de Bob Buzzard : ApexTypeImplementor au printemps 22<span class="wtr-time-wrap after-title"><span class="wtr-time-number">5</span> minutes de lecture</span>

En rapport





Source de l’article traduit automatiquement en Français

Besoin d'aide ?
Vous utilisez Pardot depuis un certain temps mais vous n'êtes pas sûr d'en
exploiter tout le potentiel

Notre analyse de votre Pardot offerte dès aujourd'hui
Merci, vous pouvez compléter notre questionnaire
Nous allons revenir vers vous rapidement !

Fermer