AD0-E137 Adobe Experience Manager Sites Developer Expert Questions and Answers

Two important weekly maintenance tasks for repository health are:

Datastore Garbage Collection (A): Cleans up unreferenced binaries in the datastore, preventing unnecessary growth in storage size.

Online Revision Cleanup (D): Reclaims space in the segment store by compacting revisions and removing obsolete data.

Option B, Clientlib Dumps, does not affect repository size. Option C, Version Purge, should be scheduled daily rather than weekly for continuous health. Adobe’s official guidelines recommend combining datastore GC with revision cleanup to prevent segment store bloat and performance degradation, ensuring repositories remain lean and optimized.

The Oak query engine, which underpins AEM’s repository search and indexing capabilities, supports multiple query syntaxes. However, Adobe recommends using XPath or JCR-SQL2, with XPath being the most widely used. JCR-SQL (option A) is deprecated and should not be used in modern AEM implementations. Plain SQL (option B) is not supported as queries must operate within the JCR structure. Option C, XPath, integrates tightly with Oak’s indexing system and provides efficient query execution. Adobe documentation states explicitly that developers should use XPath or JCR-SQL2 for queries, as both are optimized for Oak’s indexing and repository structure. Since the question provides XPath as an option but not JCR-SQL2, XPath is the correct answer.

To optimize queries against DAM assets with custom properties, developers must extend the existing damAssetLucene index. The correct method is to add the custom property under:

oak:index/damAssetLucene/indexRules/dam:Asset/properties. This ensures that the property is indexed for all assets and avoids traversal queries. Option B refers to a non-existent lucene index path, and Option C incorrectly suggests adding a property value (Hello) instead of the property name. Adobe’s indexing guidelines specify that extending existing Lucene indexes such as damAssetLucene is the standard approach for asset-related queries. This ensures queries remain efficient, scalable, and compatible across environments.

The correct approach to implementing an OSGi service in AEM is to use the Declarative Services annotation @Component(service = Interface.class). This ensures that the OSGi container properly registers the service against its interface, making it available for injection into other services, Sling Models, or servlets. In this case, the service is required to fetch store locations from an external API. Using an HTTP client within the OSGi service is the appropriate method to manage these requests. Option A is invalid because @OSGIService is not a valid annotation for service declaration. Option C is incorrect because @Service is not an OSGi Declarative Services annotation in this context. Adobe emphasizes encapsulating external API logic in OSGi services so that components and Sling Models can consume the data in a decoupled manner. This promotes separation of concerns and reusability.

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.

Explanation (Adobe Docs Reference):

AEM supports basic multi-tenancy through separation by content paths, ACLs, and templates. However, this is not true multi-tenancy. For strict isolation with no code/content overlap, separate AEM instances per tenant is required. Adobe’s official recommendation for true isolation (zero cross-tenant knowledge or sharing) is to run dedicated AEM environments per tenant.

Adobe Documentation:

“AEM supports multi-tenancy by allowing separation of content trees, ACLs, and components. However, for strict tenant isolation (true multi-tenancy), each tenant must be deployed on separate AEM environments.”

— Adobe AEM Multi-tenancy Concepts

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.

The Dispatcher should be configured to cache static pages like .html, but when query parameters are present (used for personalization, targeting, or dynamic rendering), the dispatcher must invalidate or bypass cache to prevent stale or incorrect content delivery.

Option A is correct → balances performance (cache static .html) and personalization (invalidate with query strings).

Option B is incorrect → POST requests should never be cached, as they modify content.

Option C is incorrect → disabling cache for all .html removes performance benefits.

Adobe Documentation:

“The dispatcher can be configured to cache .html responses while invalidating the cache when query string parameters are present. This ensures efficient caching while supporting personalization and dynamic content.”

— AEM Dispatcher Caching Guidelines

The error clearly indicates that the bundle is exporting a package without specifying a version. In OSGi, best practices dictate that every exported package must declare a version in the Export-Package manifest header. Furthermore, consumers of these packages must use Import-Package with version ranges to ensure compatibility and avoid conflicts during runtime. The absence of a version means other bundles cannot reliably resolve the correct package version, leading to potential deployment issues. Option A and D are general dependency resolution checks but do not address the specific missing version. Option B relates to conflicts with AEM-provided bundles, which is not the cause here. The correct fix is to add a version to the Export-Package declaration and ensure imports define version ranges. Adobe explicitly highlights this as part of OSGi bundle troubleshooting.

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."

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):

The recommended way to bind servlets in AEM (OSGi DS) is via the @SlingServletResourceTypes annotation.

The methods value must be uppercase "GET".

doGet() method must use SlingHttpServletRequest and SlingHttpServletResponse instead of standard Servlet API request/response.

SlingAllMethodsServlet is safe for handling multiple HTTP verbs, but you can extend SlingSafeMethodsServlet too. However, in Adobe docs examples, the uppercase "GET" with doGet(SlingHttpServletRequest, SlingHttpServletResponse) is correct.