Adobe AD0-E134 Adobe Experience Manager Developer Exam Exam Practice Test

Code Quality Testing is a type of Cloud Manager tests that are enabled for all Cloud Manager production pipelines and cannot be skipped. Code Quality Testing checks the code quality of the project using SonarQube and reports any issues or vulnerabilities. Code Quality Testing can fail the pipeline if the code quality does not meet the minimum standards defined by Adobe. References:

Creating a heap dump and a thread dump are two steps that should be taken after confirming the problem is related to a memory issue. A heap dump is a snapshot of the memory usage of the Java Virtual Machine (JVM) at a given point in time. A heap dump can be used to identify memory leaks, memory consumption patterns, and objects that occupy large amounts of memory. A thread dump is a snapshot of the state of all threads that are part of the JVM process. A thread dump can be used to identify deadlocks, blocked threads, and CPU-intensive threads. References:

The Auto Replicate via On Off Trigger Configuration is a feature that allows content to be replicated as soon as the On Time and Off Times are reached. This feature can be enabled by creating an OSGi configuration for the com.day.cq.wcm.core.impl.servlets.OnOffTimeServlet service. This service listens for changes in the On Time and Off Time properties of pages and triggers replication accordingly. References:

To read a list of spoken languages from the configuration of an OSGi service, the correct snippet to use is Option B. This snippet demonstrates how to define and read the configuration properties using the OSGi R7 annotations (@ObjectClassDefinition and @AttributeDefinition), which are the recommended way for defining OSGi configurations in modern AEM projects.

Here is the detailed explanation of the snippet:

Option B Snippet Explanation:

Component Definition:

@Component(

service = { LanguageService.class }

)

@Designate(ocd = LanguageServiceImpl.Config.class)

public class LanguageServiceImpl implements LanguageService {

 This defines an OSGi component and designates a configuration class for it.

 Configuration Interface:

@ObjectClassDefinition(

name = "Sample - Language Service",

description = "OSGi Service providing information about languages"

)

@interface Config {

@AttributeDefinition(

name = "Sample Languages",

description = "List of spoken languages"

)

String[] languages() default { "English", "Japanese" };

}

 This defines the configuration interface with annotations to describe the configuration properties. The languages attribute is defined with a default value of {"English", "Japanese"}.

 Activate Method:

private String[] languages;

@Activate

protected void activate(Config config) {

this.languages = config.languages();

}

The activate method reads the configuration values and assigns them to the instance variable languages when the service is activated.

Here is the complete Option B code:

@Component(

service = { LanguageService.class }

)

@Designate(ocd = LanguageServiceImpl.Config.class)

public class LanguageServiceImpl implements LanguageService {

@ObjectClassDefinition(

name = "Sample - Language Service",

description = "OSGi Service providing information about languages"

)

@interface Config {

@AttributeDefinition(

name = "Sample Languages",

description = "List of spoken languages"

)

String[] languages() default { "English", "Japanese" };

}

private String[] languages;

@Activate

protected void activate(Config config) {

this.languages = config.languages();

}

// Additional methods to use the languages array

}

By using this approach, you ensure that your OSGi service can dynamically read and use the list of spoken languages specified in its configuration, making it adaptable to different environments and requirements.

References:

OSGi R7 Annotations

Adobe Experience Manager - OSGi Configuration

The aemVersion property specifies the target AEM version for the project. To create a project based on AEM as a Cloud Service SDK, the value should be set to cloud. The sdkVersion property specifies the AEM as a Cloud Service SDK version to use for local development. To use a specific SDK version, the value should be set to the exact version number, such as 2022.5.7575.20220530T152407Z-220401. References:

To implement a new component called "Page Headline" which takes the text from the current page title instead of jcr:title, you should create a proxy component from the core title component and implement a Sling Model accordingly. Option C demonstrates the correct approach to achieve this functionality.

Here is a detailed explanation of Option C:

Create Proxy Component:

Create a new component in your project that will act as a proxy to the core title component. This involves creating a new component node in the repository that inherits from the core title component.

Example path: /apps/myproject/components/pageHeadline with sling:resourceSuperType set to core/wcm/components/title/v2/title.

Implement Sling Model:

Implement a Sling Model that adapts from SlingHttpServletRequest and Title.class, ensuring it overrides the text fetching logic to retrieve the title from the current page's title.

The model will use @ScriptVariable to inject the current page and @Self to access the core title component's logic.

@Model(adaptables = SlingHttpServletRequest.class, adapters = Title.class, resourceType = "myproject/components/pageHeadline")

public class PageHeadline implements Title {

@ScriptVariable

private Page currentPage;

@Self @Via(type = ResourceSuperType.class)

private Title title;

@Override

public String getText() {

return currentPage.getTitle();

}

@Override

public String getType() {

return title.getType();

}

}

@Model Annotation: Specifies that this class is a Sling Model and adapts from SlingHttpServletRequest. It is also an adapter for Title.class and applies to the myproject/components/pageHeadline resource type.

@ScriptVariable: Injects the current Page object, which allows access to the current page's properties.

@Self @Via(type = ResourceSuperType.class): Injects the core title component, allowing the reuse of existing logic.

getText() Method: Overrides the getText() method to return the title from the current page instead of the jcr:title.

getType() Method: Delegates to the core title component's getType() method to maintain existing functionality.

This approach leverages the power of Sling Models and the core components to extend functionality while keeping the implementation clean and maintainable.

References:

Adobe Experience Manager - Core Components

Sling Models Documentation

The developer should add the defaultInjectionStrategy = DefaultInjectionStrategy property to the @Model Class annotation to fix the snippet. The defaultInjectionStrategy property defines how the Sling Model handles missing or null values for the injected fields. By default, the Sling Model uses the REQUIRED injection strategy, which means that all fields must have a non-null value or else an exception is thrown. By setting the defaultInjectionStrategy property to OPTIONAL, the Sling Model allows null values for the injected fields and does not throw an exception. This way, if the page field is null because the resource is not a page, the Sling Model can still work without errors.References:

To create Sling Models that can export data in a human-readable yaml format, the following steps are required:

Create Sling models to export as yaml. Sling models are Java classes that can be used to represent resources in AEM. Sling models can use annotations to define how they can be adapted from a resource and how they can export data in different formats. To export data in yaml format, the Sling model class needs to use the @Model annotation with the resourceType parameter set to the resource type of the resource that the model represents. The Sling model class also needs to implement the org.apache.sling.models.annotations.Exporter annotation with the name parameter set to “jackson” and the extensions parameter set to “yaml”. The Sling model class also needs to use the @JsonProperty annotation on the fields or methods that need to be exported in yaml format.

Configure mime type in Apache Sling MIME Type Service. The Apache Sling MIME Type Service is an OSGi service that maps file extensions to MIME types and vice versa. To enable the yaml format for Sling models, the MIME Type Service needs to be configured with a new entry for the yaml extension and its corresponding MIME type, which is “application/x-yaml”. This can be done by creating an OSGi configuration for the org.apache.sling.commons.mime.internal.MimeTypeServiceImpl service and adding the entry “yaml=application/x-yaml” to the mime.types property. References:

To resolve the domain name by the dispatcher, you should configure it in the vhosts file. The vhosts file is part of the Apache HTTP server configuration and allows you to define how requests for different domain names are handled. This is crucial for setting up virtual hosts, which is essential for resolving domain names and directing them to the appropriate content served by your AEM instance.

Here are the detailed steps to configure domain name resolution in the vhosts file:

Locate the vhosts file: The file is typically located in the conf directory of your Apache HTTP server installation. Common paths are:

/etc/httpd/conf/httpd.conf (on many Linux systems)

/usr/local/apache2/conf/httpd.conf (if installed from source)

Edit the vhosts file: Open the file with a text editor. You might need superuser permissions to edit this file.

Add a VirtualHost directive: Define a new VirtualHost block for your domain. For example:

ServerName

ServerAlias example.com

DocumentRoot "/path/to/your/document/root"

# Dispatcher configuration

SetHandler dispatcher-handler

ModMimeUsePathInfo On

AllowOverride None

Options FollowSymLinks

Require all granted

 ServerName specifies the primary domain name.

ServerAlias allows you to specify additional names that should resolve to the same content.

DocumentRoot specifies the directory from which the content should be served.

The section includes the Dispatcher handler configuration.

 Restart Apache: After saving the changes to the vhosts file, restart the Apache server to apply the changes.

sudo systemctl restart httpd

# or

sudo service apache2 restart

References:

Adobe Experience Manager Dispatcher Configuration

Apache HTTP Server Documentation on VirtualHost

An experience fragment is a group of one or more components including content and layout that can be referenced within pages. Experience fragments allow authors to create variations for different channels and modify them for specific time periods. Experience fragments also support versioning and restoring previous versions. References:

The Apache Jackrabbit Oak External Login Module and Apache Jackrabbit Oak Default Sync Handler are the two OSGi configurations that are required for LDAP integration in AEM. The External Login Module defines how AEM connects to the LDAP server and authenticates users against it. The Default Sync Handler defines how AEM synchronizes users and groups from the LDAP server to the repository. References:

Utilizing model props to drill down and access or set the state on desired components is the least complex approach for sharing information between Single Page Application (SPA) components in AEM.

Here’s why using model props is effective:

Simplicity: This approach leverages the existing component hierarchy and properties, making it straightforward to pass data between components.

Direct Access: Model props allow for direct access to the state and properties of parent or sibling components, enabling easy data sharing.

Minimal Setup: Unlike implementing a state library or customizing container components, using model props requires minimal additional setup, reducing complexity and potential overhead.

Steps to utilize model props for state management:

Define the State in the Parent Component: Ensure that the parent component maintains the state that needs to be shared.

Pass Props to Child Components: Pass the necessary state and any setter functions as props to the child components. For example, in a React-based SPA, you can do this using JSX syntax:

function ParentComponent() {

const [sharedState, setSharedState] = useState(initialState);

return (

);

}

Access and Modify State in Child Components: In the child components, access and modify the shared state using the props passed from the parent:

function ChildComponentA({ sharedState, setSharedState }) {

return (

);

}

By using this approach, you ensure a simple and effective way of managing and sharing state across components in your SPA, adhering to best practices for component-based architecture.

References:

React Documentation on Props

AEM SPA Editor Documentation

Option B is the final rendered html output for the code snippet. The code snippet uses the data-sly-list block statement to iterate over the child pages of the current page. The data-sly-list statement assigns each child page to a variable named page and provides an index variable named i. The code snippet then uses the data-sly-test block statement to check if the index is odd or even and applies a different CSS class accordingly. The code snippet also uses the data-sly-element block statement to create an HTML element with the name specified by the elementName variable. The code snippet also uses the data-sly-attribute block statement to add an attribute with the name specified by the attrName variable and the value specified by the attrValue variable. The code snippet also uses the data-sly-resource block statement to include a resource with the path specified by the page.path variable and the resourceType specified by the resourceType variable.References:

A mock framework is a tool that allows creating mock objects that simulate the behavior of real objects in a controlled way. A mock framework can be used in a unit test to inject the EmployeeService dependency into the CalculationService and verify its interactions. This way, the unit test can focus on testing the logic of the CalculationService without relying on the actual implementation of the EmployeeService.References:

Option C is the correct implementation for the Sling Model. Option C uses the @Model annotation with the adaptables parameter set to Resource.class. This allows the Sling Model to adapt from a resource object and access its properties using the ValueMap interface. Option C also uses the @Inject annotation with the name parameter set to “./name” and “./occupations” to inject the values of the name and occupations properties into the name and occupations fields. Option C also uses the @Named annotation with the value parameter set to “byline” to specify the name of the Sling Model that can be used in HTL scripts. References:

This syntax allows the developer to reference a secret variable that is stored in the Cloud Manager UI under Environment Details > Variables. The secret variable name must start with a lowercase letter and can contain alphanumeric characters and underscores.References:

Option B is a potential fix for the issue. Option B uses the data-sly-attribute block statement to add the href attribute to the anchor tag. The data-sly-attribute statement uses an expression to append “.html” to the item.path value. This way, the link will have the correct extension and will resolve to the corresponding page. References:

To ensure that text pasted inside the Text component in AEM is stripped of all styling and formatting, you need to override the RTE (Rich Text Editor) plugin implementation and change the default paste behavior. The correct option to achieve this is defaultPasteMode=plaintext.

Steps to configure the RTE plugin for plain text pasting:

Locate the RTE Configuration: Find the existing configuration for the RTE or create a new one in the /apps directory of your AEM project.

Modify the Plugin Configuration: Add or update the configuration to include the defaultPasteMode parameter. The configuration might look something like this:

{

"jcr:primaryType": "nt:unstructured",

"features": "[text]",

"defaultPasteMode": "plaintext"

}

Apply the Configuration: Ensure that this configuration is applied to the Text component. This typically involves updating the component dialog or design dialog to reference the updated RTE configuration.

Test the Configuration: In the AEM author instance, open the page with the Text component and paste text using CTRL+V. The pasted text should now be stripped of all styling and formatting, adhering to the plaintext mode.

By setting defaultPasteMode to plaintext, you ensure that the RTE only accepts plain text input, removing any formatting that might come from external sources.

References:

AEM Rich Text Editor (RTE) Documentation

Configuring the Rich Text Editor in AEM

The order of resolution for OSGi configurations at runtime in AEM is as follows:

Web Console Configuration:

Changes made through the OSGi Web Console take immediate effect and have the highest precedence. This is because these configurations are considered the most direct way to adjust OSGi settings at runtime.

References:OSGi Configuration in AEM

/apps Configuration:

Configurations in the /apps directory take precedence over those in the /libs directory. This allows custom configurations to override the default configurations provided by AEM.

References:AEM Project Structure

/libs Configuration:

Configurations in the /libs directory are the default configurations provided by AEM. They are overridden by any configurations in the /apps directory.

References:AEM Configuration

By understanding this order, developers can effectively manage and prioritize their OSGi configurations to ensure the desired behavior of their AEM instances.

The warning WARN* Traversed 1000 nodes with filter Filter (query=select…) indicates that the query is performing a traversal instead of using an index. This results in poor performance, especially when the client has a large number of nodes (e.g., more than 100,000).

To resolve this issue, you should create a custom Oak index for the custom page property. This ensures that the queries can leverage the index for efficient data retrieval.

Steps to create a custom Oak index:

Define the Oak Index:

Navigate to the /oak:index node in CRXDE Lite

Create a new node of type oak:QueryIndexDefinition.

Configure the Index:

Set the properties of the new index node to define the indexing rules for the custom page property.

{

"jcr:primaryType": "oak:QueryIndexDefinition",

"type": "property",

"propertyNames": ["customPageProperty"],

"reindex": true,

"async": "async"

}

Deploy and Reindex:

Save the changes and initiate a reindexing process.

Ensure that the reindex flag is set to true for the newly created index.

Validate the Index:

Use the Index Manager or the AEM Web Console to validate that the new index is enabled and functioning correctly.

By creating a custom Oak index for the custom page property, the queries will be optimized to use the index, significantly improving the search performance and resolving the client's issue.

References:

Adobe Experience Manager - Oak Indexing

Apache Jackrabbit Oak - Indexing

A content fragment is a reusable piece of content that can be authored and managed independently from a page. Content fragments are based on structured data models that define the elements and data types of the content. Content fragments can be delivered as JSON using various APIs, such as Assets HTTP API, Content Fragments REST API, or Content Fragments GraphQL API. Content fragments are suitable for creating multi-channel applications that use AEM as a headless CMS. References: