Comment la configuration contextuelle imbriquée facilite la configuration complexe dans AEM / Blogs / Perficient

La gestion des configurations dans Adobe Experience Manager (AEM) peut s’avérer difficile, en particulier lors du partage de configurations sur différents sites Web, régions ou composants. Le framework Context-Aware Configuration (CAC) dans AEM simplifie la gestion des configurations en permettant aux développeurs de définir et de résoudre les configurations en fonction du contexte, comme la hiérarchie du contenu. Cependant, à mesure que les projets évoluent, les besoins de configuration peuvent devenir plus complexes, impliquant des configurations imbriquées et des scénarios variés.

Dans ce blog, nous explorerons Configurations contextuelles imbriquées et comment ils fournissent une solution évolutive pour gérer les configurations multicouches et complexes dans AEM. Nous aborderons les cas d’utilisation, la mise en œuvre technique et les meilleures pratiques pour tirer le meilleur parti de CAC.

Comprendre la configuration contextuelle imbriquée

AEM Configuration contextuelle vous permet de créer et de résoudre des configurations de manière dynamique, en fonction de la structure du contenu, afin que la même configuration puisse s’appliquer différemment selon l’endroit où elle est résolue dans l’arborescence de contenu. Cependant, certains projets nécessitent des niveaux de configuration plus profonds, non seulement basés sur la structure du contenu, mais également sur différentes catégories au sein d’une configuration elle-même. C’est ici configurations imbriquées entrer en jeu.

Configuration contextuelle imbriquée implique d’avoir une ou plusieurs configurations intégrées dans une autre configuration. Cette configuration est particulièrement utile lorsqu’il s’agit de configurations hiérarchiques ou multidimensionnelles, telles que des paramètres qui dépendent à la fois de contextes globaux et locaux ou de configurations spécifiques à un composant au sein d’une configuration de page plus large.

Vous pouvez en apprendre davantage sur concepts de configuration de base sur Adobe Experience League.

Catégorisation des configurations avec des contextes imbriqués

Les configurations imbriquées sont particulièrement utiles pour catégoriser les configurations en fonction de catégories larges telles que image de marque, analytiqueou autorisationspuis en imbriquant des configurations plus spécifiques dans ces catégories.

Par exemple, au niveau parentvous pouvez définir des catégories globales pour le suivi analytique, la personnalisation ou les autorisations des utilisateurs. Sous chaque catégorie, vous pouvez ensuite avoir des configurations imbriquées pour les remplacements spécifiques à une région, telles que :

• Configuration d’analyse globale: ID de suivi partagé pour l’ensemble du site.
• Configuration d’analyse régionale: remplacez le suivi analytique global pour des régions spécifiques.
• Configuration d’analyse des composants: Différentes configurations de suivi pour les composants qui rapportent les analyses séparément.

Cette structure :

• Simplifie la gestion: Réduit la redondance en catégorisant les configurations et en utilisant des mécanismes de secours.
• Améliore l’organisation: Chaque configuration est soigneusement classée et peut être héritée des configurations parentes si nécessaire.
• Améliore l’évolutivité: Permet une extension et un ajout faciles de nouvelles configurations imbriquées sans affecter l’ensemble de la structure de configuration.

Avantages de la configuration contextuelle imbriquée

1. Évolutivité: les configurations imbriquées vous permettent de faire évoluer votre structure de configuration à mesure que votre projet se développe, sans créer de paramètres redondants ou qui se chevauchent.
2. Granularité: Fournit un contrôle précis sur les configurations, vous permettant d’appliquer des paramètres spécifiques à différents niveaux (mondial, régional, composant).
3. Mécanisme de repli: si une configuration n’est pas trouvée à un niveau spécifique, AEM revient automatiquement à une configuration parent, garantissant ainsi que le système dispose d’un ensemble fiable de valeurs par défaut avec lequel travailler.
4. Maintenabilité: En organisant les configurations de manière hiérarchique, vous simplifiez la maintenance. Les modifications au niveau global s’appliquent automatiquement aux niveaux inférieurs, sauf si elles sont explicitement annulées.

Cas d’utilisation avancés

1. Gestion des indicateurs de fonctionnalités: Nested CAC vous permet de gérer les indicateurs de fonctionnalités dans différents contextes. Par exemple, les indicateurs de fonctionnalité globaux peuvent être remplacés par des indicateurs de fonctionnalité spécifiques à une région ou à un composant.
2. Personnalisation: utilisez des configurations imbriquées pour gérer des expériences personnalisées basées sur des segments d’utilisateurs, avec des règles globales retombant sur une personnalisation plus spécifique au niveau régional ou de la page.
3. Localisation: Nested CAC peut gérer les configurations de localisation, vous permettant de définir des paramètres de contenu spécifiques à une langue dans le cadre de configurations régionales ou mondiales plus larges.

Mise en œuvre

Pour implémenter les configurations imbriquées, nous devons d’abord définir les configurations pour les modules individuels. Dans l’exemple ci-dessous, nous allons créer SiteConfig qui aura des configurations ainsi que deux configurations imbriquées, puis la configuration imbriquée aura ses propres attributs.

Définissons d’abord la configuration individuelle. Ils ressembleront à ceci :

@Configuration(label = "Global Site Config", description = "Global Site Context Config.") 
public @interface SiteConfigurations { 
 
    @Property(label = "Parent Config - Property 1", 
            description = "Description for Parent Config Property 1", order = 1) 
    String parentConfigOne(); 
 
    @Property(label = "Parent Config - Property 2", 
            description = "Description for Parent Config Property 2", order = 2) 
    String parentConfigTwo(); 
 
    @Property(label = "Nested Config - One", 
            description = "Description for Nested Config", order = 3) 
    NestedConfigOne NestedConfigOne(); 
 
    @Property(label = "Nested Config - Two", 
            description = "Description for Nested Config", order = 4) 
    NestedConfigTwo[] NestedConfigTwo(); 
 
}

Suite avec ce Nested ConfigOne unsd NestedConfigDeux ressemblera à ce:

public @interface NestedConfigOne { 
 
    @Property(label = "Nested Config - Property 1", 
            description = "Description for Nested Config Property 1", order = 1) 
    String nestedConfigOne(); 
 
 
    @Property(label = "Nested Config - Property 2", 
            description = "Description for Nested Config Property 2", order = 2) 
    String nestedConfigTwo(); 
 
 
}

Et…

public @interface NestedConfigTwo { 
 
    @Property(label = "Nested Config - Boolean Property 1", 
            description = "Description for Nested Config Boolean Property 1", order = 1) 
    String nestedBooleanProperty(); 
 
    @Property(label = "Nested Config - Multi Property 1", 
            description = "Description for Nested Config Multi Property 1", order = 1) 
    String[] nestedMultiProperty(); 
 
}

Notez que nous n’avons pas annoté les configurations imbriquées avec Property car ce n’est pas la configuration principale.

Créons un service pour lire ceci et cela ressemblera à ceci :

public interface NestedConfigService { 
    SiteConfigurationModel getAutoRentalConfig(Resource resource); 
}

La mise en œuvre du service ressemblera à ce:

@Component(service = NestedConfigService.class, 
        immediate = true) 
@ServiceDescription("Implementation For NestedConfigService") 
public class NestedConfigServiceImpl implements NestedConfigService { 
 
    @Override 
    public SiteConfigurationModel getAutoRentalConfig(Resource resource) { 
        final SiteConfigurations configs = getConfigs(resource); 
        return new SiteConfigurationModel(configs); 
    } 
 
    private SiteConfigurations getConfigs(Resource resource) { 
        return resource.adaptTo(ConfigurationBuilder.class) 
                .name(SiteConfigurations.class.getName()) 
                .as(SiteConfigurations.class); 
    } 
 
}

Modèle de configuration de site contiendra la configuration finale comprenant toutes les configurations. Nous pouvons modifier getters en fonction des besoins. Donc actuellement, j’ajoute simplement son implémentation factice.

public class SiteConfigurationModel { 
    public SiteConfigurationModel(SiteConfigurations configs) { 
 
        String parentConfigOne = configs.parentConfigOne(); 
        NestedConfigOne nestedConfigOne = configs.NestedConfigOne(); 
        NestedConfigTwo[] nestedConfigTwos = configs.NestedConfigTwo(); 
        //Construct SiteConfigurationModel As per Need 
 
    } 
}

Une fois que vous avez déployé le menu de configuration du code sur site dans l’éditeur de contexte, il devrait ressembler à comme :

Nous pouvons voir que cela nous a donné la possibilité de configurer directement la propriété 1 et la propriété 2, mais pour celle imbriquée, cela a donné un supplémentaire Bouton Modifier qui nous amènera à configurer le Nested Configurations et ça ressemblera à ce :

Étant donné que la configuration imbriquée deux est multichamp, elle donne la possibilité d’ajouter une entrée supplémentaire.

Une solution puissante pour simplifier et rationaliser

La configuration contextuelle imbriquée dans AEM offre une solution puissante pour gérer des configurations complexes aux niveaux mondial, régional et des composants. En tirant parti des contextes imbriqués, vous pouvez facilement catégoriser les configurations, appliquer des mécanismes de secours et faire évoluer votre gestion des configurations à mesure que votre projet évolue.

Qu’il s’agisse de travailler sur un site multirégional, de gérer divers segments d’utilisateurs ou de gérer des composants complexes, les configurations imbriquées peuvent vous aider à simplifier et à rationaliser votre structure de configuration tout en conservant flexibilité et évolutivité.

Apprendre encore plus

Fais surc’est ça suivez notre blog Adobe pour plus d’informations sur la plateforme Adobe !