Adobe AD0-E137 Dumps

Explanation (Adobe Docs Reference):

In Adobe Experience Manager (AEM), the SPA Editor enables the development of Single Page Applications (SPAs) that integrate with AEM’s content management capabilities. SPA components in AEM are typically React or Angular components mapped to AEM components, and their data is exposed to the SPA via JSON through the Sling Model Exporter framework. The ComponentExporter interface, part of the com.adobe.cq.export.json package, is used to define how AEM components are serialized into JSON for consumption by the SPA. By default, AEM provides a standard exporter (via the Sling Model Exporter) that serializes component data based on the Sling Model’s annotations and properties. However, developers can override this default exporter for specific components to customize the JSON output, such as adding, removing, or modifying fields.

The question specifies that the developer is creating a set of SPA components, where half do not require a custom component exporter (i.e., they can use the default exporter), and the other half need a custom exporter to override the default behavior. Let’s analyze the options to determine the correct approach:

Analysis of Options:

Option A: Implement ImplementationPicker service

The ImplementationPicker interface (from com.adobe.cq.wcm.core.components.util) is used in AEM’s Core Components to dynamically select the implementation of a component based on specific conditions, such as resource type or request context. It is not related to the Sling Model Exporter or JSON serialization for SPA components. Implementing an ImplementationPicker service would be relevant for selecting different component implementations (e.g., different HTL scripts or Java classes) but does not address the need to customize JSON export for SPA components. This option is incorrect.

Option B: Implement ComponentExporter service

The ComponentExporter interface is designed for SPA integration in AEM. When a Sling Model implements ComponentExporter, it can be serialized into JSON by the Sling Model Exporter, which is used by the SPA Editor to provide component data to the front-end SPA (React or Angular). To override the default exporter, a developer creates a Sling Model for each SPA component that requires customization, annotates it with @Model (specifying resourceType and exporters), and implements ComponentExporter. The model can then define custom methods or annotations (e.g., @JsonProperty, @ValueMapValue) to control the JSON output. For the components that do not require a custom exporter, the default Sling Model Exporter behavior (provided by AEM or Core Components) can be used without implementing ComponentExporter. This approach perfectly aligns with the requirement to override the default exporter for only half of the components. This option is correct.

Option C: Implement FallbackComponentImpl service

There is no such thing as a FallbackComponentImpl service in AEM or its SPA Editor framework. This appears to be a fictitious or misleading option. AEM’s SPA Editor and Sling Model Exporter do not use a “fallback” service for JSON export customization. Instead, customization is achieved through the ComponentExporter interface or by extending existing exporters. This option is incorrect.

Correct Implementation:

To meet the goal, the developer should:

For components that do not require a custom exporter, rely on the default Sling Model Exporter behavior. These components can use standard Sling Models (or Core Components) that are automatically serialized into JSON based on their properties and annotations.

For components requiring a custom exporter, create Sling Models that implement the ComponentExporter interface and annotate them with @Model (from org.apache.sling.models.annotations) and @Exporter (from org.apache.sling.models.annotations). For example:

import com.adobe.cq.export.json.ComponentExporter;

import org.apache.sling.api.SlingHttpServletRequest;

import org.apache.sling.models.annotations.Model;

import org.apache.sling.models.annotations.Exporter;

import org.apache.sling.models.annotations.injectorspecific.ValueMapValue;

import com.fasterxml.jackson.annotation.JsonProperty;

@Model(adaptables = SlingHttpServletRequest.class,

adapters = {ComponentExporter.class},

resourceType = "wknd/components/customcomponent",

exporters = @Exporter(name = "jackson", extensions = "json"))

public class CustomComponentModel implements ComponentExporter {

@ValueMapValue

private String customField;

@JsonProperty("renamedField")

The @Model annotation specifies that the class is a Sling Model adaptable from a SlingHttpServletRequest and implements ComponentExporter.

The @Exporter annotation registers the model with the Sling Model Exporter for JSON output (using Jackson).

The getExportedType() method, required by ComponentExporter, returns the resource type, which is used by the SPA to identify the component.

Custom logic (e.g., toUpperCase()) or annotations like @JsonProperty can be used to modify the JSON output.

Ensure the SPA Editor is configured correctly in AEM (e.g., the SPA project is set up with proper page templates and policies) to map these components to their front-end counterparts.

Why Option B is Correct:

Implementing ComponentExporter allows the developer to define custom Sling Models for the components that need a customized JSON output, overriding the default exporter’s behavior.

For the other half of the components, the default exporter (provided by AEM or Core Components) can be used without additional implementation.

This approach leverages AEM’s SPA Editor and Sling Model Exporter framework, which is specifically designed for exposing AEM component data to SPAs via JSON.

Exact Extracts from Adobe Experience Manager (AEM) Sites Developer Documents:

From "SPA Editor - Developing SPAs for AEM": "AEM components, which are used within the SPA Editor, must implement the ComponentExporter interface to be serialized correctly into the JSON format expected by the SPA. This interface allows developers to customize the JSON export of components for SPA integration."

From "Sling Model Exporter": "The Sling Model Exporter framework allows Sling Models to be exported as JSON for SPA integration. By implementing ComponentExporter and annotating with @Exporter(name = 'jackson', extensions = 'json'), developers can control the JSON output of their components."

From "AEM SPA Editor and React/Angular": "For custom components requiring specific JSON structures, implement a Sling Model with ComponentExporter and define custom getters to shape the JSON output. Components without custom exporters can rely on the default JSON serialization provided by AEM."

In AEM as a Cloud Service, dedicated preview service endpoints are configured under publish run modes. The correct configuration folder for a UAT preview service is config.publish.uat within the ui.config project. Option A incorrectly places the configuration under author run mode, which is unrelated to preview endpoints. Option C misorders the naming convention, using config.uat.author instead of the proper config.publish.uat. Adobe’s guidance specifies that preview service configuration is a publish-tier responsibility, requiring config.publish. folders in the configuration project.

Explanation (Adobe Docs Reference):

The correct OSGi Declarative Services (DS) implementation in AEM:

Must use implements (not extends).

Must register the service interface (SimpleService.class).

Should return an implementation for getMessage().

Option D is the correct implementation.

Options A, B, C are wrong because:

A incorrectly uses extends.

B and C register the wrong service type (MySimpleService).

Adobe Documentation:

“An OSGi service implementation must implement its interface and be annotated with @Component(service=Interface.class) to register the service.”

— OSGi Services in AEM

In AEM’s Template Editor, there are multiple modes that allow template authors to configure different aspects of templates. The Structure mode defines static and editable areas in templates. The Page Policy allows defining rules such as which components are available for use. However, the Layout mode is specifically designed for defining grid settings for different devices. With Layout mode, template authors can configure responsive layouts and grid behavior across breakpoints such as desktop, tablet, and mobile. This ensures consistent responsive design and adaptability across devices. Adobe documentation specifies that “Layout mode allows authors to configure responsive grid layouts for different breakpoints, ensuring that pages render appropriately on devices of varying screen sizes.” This mode is essential for enabling adaptive and responsive designs in AEM projects. Options B and C do not allow for device-specific grid settings and thus are not correct.

The recommended way to generate a new AEM project is by using the official Adobe AEM Maven Archetype. Developers must specify the correct groupId (com.adobe.aem) and artifactId (aem-project-archetype). The archetypeVersion should match the latest stable archetype version (e.g., 50 for AEM 6.5). The groupId of the project should be set to the organization’s package, in this case com.mysite. The appId defines the project name and should match the intended application (mysite). The version is defined as 2.0 to represent the project version, while aemVersion=6.5 ensures compatibility with AEM 6.5. Option A is invalid because the archetype groupId is incorrect and the values are mismatched. Option C contains placeholders and an invalid groupId. Adobe’s official documentation for generating projects specifies option B as the valid approach.

In Adobe Experience Manager (AEM), editable templates are a key feature introduced in AEM 6.3 and enhanced in subsequent versions, including AEM as a Cloud Service. These templates allow authors to create and manage page templates dynamically through the Template Editor, unlike static templates that reside under /apps. Editable templates are stored in the CRX repository under the /conf directory, which is the designated location for configuration-related content, including templates and policies.

When a developer creates an editable template, such as home-template in the AEM application wknd, AEM automatically generates a specific node structure in the CRX repository under /conf. The structure follows a standardized hierarchy to store template configurations, policies, and associated metadata. The correct structure for an editable template is as follows:

/conf: The root node for configuration data in AEM, used to store project-specific configurations like editable templates.

wknd [sling:Folder]: A folder node representing the project or tenant (in this case, the wknd application).

settings [sling:Folder]: A subfolder that organizes WCM (Web Content Management) configurations.

wcm [cq:Page]: A node representing the Web Content Management configurations, typically stored as a cq:Page to align with AEM’s page structure.

templates [cq:Page]: A node that holds all editable templates for the project, stored as a cq:Page to allow for template metadata and properties.

home-template [cq:Template]: The actual template node, which is of type cq:Template. This node contains the template’s configuration, including its structure, initial content, and policies.

The node type for the template itself (home-template) is cq:Template, which defines it as an editable template that can be used to create pages. This distinguishes it from a cq:Page node, which is used for actual content pages or structural nodes like the templates parent node. The other options provided in the question are incorrect for the following reasons:

Option A: Incorrectly specifies the home-template node as cq:Page instead of cq:Template. Editable templates are always stored as cq:Template nodes.

Option C: Incorrectly places the structure directly under /wknd without the /conf root, which is not the standard location for editable templates.

Option D: Incorrectly places the structure under /apps, which is used for static templates and application code, not editable templates.

This structure ensures that editable templates are stored in a configuration scope that is separate from application code (/apps) and content (/content), allowing for better management and scalability, especially in multi-tenant environments like AEM as a Cloud Service.

Exact Extracts from Adobe Experience Manager (AEM) Sites Developer Documents:

From "Editable Templates": "Editable templates allow authors to create and maintain templates from the UI. These templates are stored under /conf in the repository, typically in a structure like /conf//settings/wcm/templates/. The template node itself is of type cq:Template."

From "AEM Project Structure": "Editable templates are stored under /conf//settings/wcm/templates. Each template is a cq:Template node, and the parent templates node is a cq:Page. This structure separates configuration data from content and code."

From "Template Editor": "When a template is created via the Template Editor, AEM creates a node structure under /conf//settings/wcm/templates/ with the template node being of type cq:Template, which holds the template’s definition, policies, and initial content."

The issue in this case is that the title field is declared but not annotated with @Inject. In Sling Models, all fields that should be populated from the resource or request must be annotated appropriately (@Inject, @ValueMapValue, or @Self). Without this annotation, the Sling Model cannot populate the field when adapting from the resource, resulting in the model not functioning as expected. Option A is incorrect because Resource.class is a valid adaptable for Sling Models. Option C does not apply because the problem is not with hard-coded paths but with injection. Option D is also incorrect because while @PostConstruct must be properly annotated, the root issue here is missing injection on the field. Adobe’s Sling Models documentation emphasizes correct use of injection annotations as a core requirement.

When workflows require complex conditional logic or integration with external systems, Adobe recommends writing custom workflow process steps in Java. By implementing the WorkflowProcess interface, developers can evaluate metadata dynamically and invoke APIs or services as needed. Option A is too limited because out-of-the-box workflow steps support simple operations but cannot manage advanced branching or integrations. Option C is not suitable because content fragments are intended for structured content authoring, not for managing asset workflows. Adobe’s documentation states that workflows should remain modular, with custom steps encapsulating business-specific logic, while the Workflow Model defines the process flow. This ensures extensibility, testability, and clean separation between workflow orchestration and implementation logic.

When unit testing a service that depends on JCR queries, the best practice is to use mocking frameworks (such as Mockito) to mock the Query and QueryResult objects. The purpose of a unit test is to isolate the service under test and not rely on a real JCR repository or SlingContext persistence layer, which moves testing into integration testing territory. By mocking the Query object and using the when(...).thenReturn(...) pattern, developers can control query results and validate how the service behaves under different scenarios. This ensures that the test runs quickly, without dependency on repository setup or external data. Option B is incorrect because currentResource() is used in Sling Model tests rather than for query-driven services. Option C with SlingContext and JCR_OAK would be used in integration or functional tests, not in lightweight unit tests. Adobe documentation highlights that JCR queries should be mocked in unit tests to ensure isolation and speed.

By default, when saving dialog values, AEM stores them as String types in the JCR unless a type hint is provided. To ensure a checkbox is stored as a Boolean, developers must add a hidden TypeHint field to the dialog. This informs Sling Post Servlet about the correct JCR type when persisting values. Option A, using a JCR Event Listener, is inefficient and adds unnecessary complexity. Option C, using a Switch, would still result in a String unless the TypeHint is specified. Adobe documentation specifies that TypeHint fields should be added whenever developers need precise control over how values are stored, especially for Boolean, Long, or Date properties.

Workflow launchers in AEM are designed to monitor changes in specific repository paths such as /content, /content/dam, and /conf. However, changes under certain system-level paths, including /var, do not trigger workflows. This restriction is intentional, as /var is used for system-generated and internal data such as workflow instances, audit logs, and temporary nodes. Triggering workflows on changes under /var could result in recursive or unintended behavior. Option A is unrelated because Workflow Process Legacy Mode refers to backwards compatibility. Option B is incorrect, as AEM does allow system nodes under /var, but they are not workflow-launcher enabled. Adobe documentation makes clear that workflow launchers must be configured under supported content paths for them to execute correctly.

Explanation (Adobe Docs Reference):

Editable templates + Policies: Editable templates allow developers to restrict which components are available by defining policies that control allowed components for layout containers.

Content Fragment Model validation: Developers can define validation rules (e.g., regex, required fields, min/max length) directly in the content fragment model.

Options A, C, and D are incorrect:

Field validation is not configured in editable templates (A is wrong).

Workflows are not used for enforcing component usage (C is wrong).

Dynamic templates are deprecated in favor of editable templates (D is wrong).

Adobe Documentation:

“Editable templates support defining policies to determine which components can be used in the layout container.”

— AEM Templates – Defining Policies

“Content Fragment Models can include validation rules to ensure data integrity, including regex patterns, length restrictions, and required fields.”

— AEM Content Fragment Models – Validation Rules

Explanation (Adobe Docs Reference):

When querying with QueryBuilder API:

type=cq:Page ensures only AEM pages are selected.

property=jcr:content/cq:template filters by the template path.

property.value=/conf/geometrixx/templates/homepage ensures only pages created with the homepage template are returned.

p.hits=selective restricts returned properties.

p.properties=jcr:title ensures only the jcr:title is returned.

Options B, C, and D are invalid due to wrong property paths (jcr:title/cq:template, cq:template, or jcr:content/template) or typos (jrc:title).

Adobe Documentation:

“The property parameter can be used to restrict results based on template usage. Use jcr:content/cq:template to filter by template and p.properties with p.hits=selective to return specific fields.”

— AEM QueryBuilder API Guide

In Dispatcher configuration, request filtering is handled through the filters.any file. To deny access to specific content types or formats (like .json and .xml) for certain paths, the configuration must explicitly match both the extension and the path using correct syntax. The valid approach uses:

/0001 { /type "deny" /extension "(xml|json)" /path "(/path2|/path3)/*" }

Options A and B contain syntax errors. Option A incorrectly uses JSON/* instead of paths, and Option B mixes array-style brackets instead of regex or path expressions. Option C follows the correct pattern of specifying deny rules with /extension and /path. Adobe recommends always explicitly denying unwanted selectors or extensions to prevent exposure of sensitive content through JSON or XML requests.

When defining component style options in AEM, authors can select from pre-defined CSS classes by configuring them in the component’s cq:editConfig node under /cq:style. The correct properties are:

cq:styleClasses: Defines the list of CSS classes that authors can apply.

cq:styleLabel: Defines the label displayed in the authoring dialog for the style selection.

Options B, C, D are incorrect because they use invalid property names (cssClasses, styleLabel, cssStyles, cssLabel) which are not recognized by AEM.

From Adobe Documentation:

“Component styles can be defined using the cq:editConfig node. Authors can choose between style variations configured under cq:styleClasses with a descriptive cq:styleLabel.”

— AEM 6.5 – Defining Component Styles with cq:editConfig

— AEM Core Components – Style System