Are you struggling to understand how to retrieve page properties in Adobe Experience Manager (AEM)? If so, you’re not alone. Working with page properties is a fundamental aspect of AEM development, and mastering this skill is crucial for building robust and customized solutions.

Introduction

AEM is a powerful content management system that allows you to create, manage, and deliver digital experiences across various channels. One of the key features of AEM is its ability to store and manage page properties, which are essentially metadata associated with each page. These properties can include everything from basic information like titles and descriptions to more complex data structures like lists, maps, and nested objects.

Key Takeaways

• Page properties in AEM are metadata associated with each page, storing various types of information.
• Retrieving page properties is essential for building customized solutions and leveraging AEM’s capabilities.
• AEM provides multiple ways to access page properties, including the PageManager API, Sling Models, and JSP/HTL scripts.
• Understanding the different methods and their use cases is crucial for efficient and maintainable development.
• Proper handling of page properties ensures data integrity, performance optimization, and a seamless user experience.

Understanding Page Properties

Before diving into the specifics of retrieving page properties, it’s essential to understand what they are and why they matter. Page properties in AEM are essentially key-value pairs that store various types of data associated with a particular page. These properties can be used for a wide range of purposes, such as storing metadata for SEO optimization, configuring components, or storing user-specific settings.

Page properties can be broadly categorized into two types: built-in properties and custom properties. Built-in properties are predefined by AEM and include common attributes like page titles, descriptions, and tags. Custom properties, on the other hand, are defined by developers or authors to store application-specific data.

Accessing Page Properties via PageManager API

One of the most common ways to retrieve page properties in AEM is through the PageManager API. This API provides a set of methods and classes that allow you to interact with pages and their associated properties. Here’s an example of how to retrieve a page property using the PageManager API:

import com.day.cq.wcm.api.Page;
import com.day.cq.wcm.api.PageManager;

Page currentPage = pageManager.getContainedPage(resourceResolver.getResource("/content/mysite/en"));
String pageTitle = currentPage.getPageTitle();

In this example, we first obtain a reference to the current page using the PageManager’s `getContainedPage` method. We then retrieve the page title by calling the `getPageTitle` method on the `Page` object.

Using Sling Models

Another popular approach to accessing page properties in AEM is through the use of Sling Models. Sling Models are Java classes that provide a convenient way to map page properties to Java objects, making it easier to work with and manipulate data. Here’s an example of how to use a Sling Model to retrieve page properties:

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

@Model(adaptables = Resource.class)
public class MyPageModel {
    @ValueMapValue
    private String pageTitle;

    public String getPageTitle() {
        return pageTitle;
    }
}

In this example, we define a Sling Model class `MyPageModel` that maps the `pageTitle` property to a Java field using the `@ValueMapValue` annotation. We can then retrieve the page title by instantiating the Sling Model and calling the `getPageTitle` method.

Working with JSP/HTL Scripts

If you’re working with JSP or HTL (HTML Template Language) scripts in AEM, you can directly access page properties within your templates. This approach is particularly useful when you need to display or manipulate page properties in the context of rendering components or templates. Here’s an example of how to retrieve a page property in a JSP script:

<%@ page import="com.day.cq.wcm.api.Page" %>
<%
    Page currentPage = (Page) request.getAttribute("currentPage");
    String pageTitle = currentPage.getPageTitle();
%>
<h1><%= pageTitle %></h1>

In this example, we first import the `Page` class from the AEM API. We then retrieve the current page object from the request and call the `getPageTitle` method to obtain the page title. Finally, we output the page title within an `

` tag.

Handling Complex Data Types

While the examples above demonstrate how to retrieve simple string properties, AEM also supports more complex data types for page properties. These can include lists, maps, and nested objects. Handling these complex data types requires a deeper understanding of the AEM API and data structures. Here’s an example of how to retrieve a list property:

import com.day.cq.wcm.api.Page;
import com.day.cq.wcm.api.PageManager;

Page currentPage = pageManager.getContainedPage(resourceResolver.getResource("/content/mysite/en"));
List<String> tags = currentPage.getProperties().get("cq:tags", Collections.<String>emptyList());

In this example, we retrieve a list of tags associated with the current page using the `getProperties` method and the `cq:tags` property key. If the property is not set or is null, we provide an empty list as a fallback value.

Performance Considerations

When working with page properties in AEM, it’s important to consider performance implications. Retrieving page properties can be an expensive operation, especially when dealing with large or deeply nested data structures. To optimize performance, it’s recommended to cache page properties whenever possible and avoid unnecessary retrieval operations.

Additionally, be mindful of the number of page property accesses you perform within a single request. Excessive property retrieval can lead to performance degradation and increased server load. Consider implementing caching strategies or optimizing your code to minimize the number of property accesses.

Best Practices and Recommendations

To ensure efficient and maintainable development when working with page properties in AEM, follow these best practices and recommendations:

• Clearly document the purpose and usage of each page property in your project.
• Establish naming conventions and guidelines for custom page properties to promote consistency and readability.
• Leverage AEM’s built-in properties whenever possible, and only introduce custom properties when necessary.
• Implement proper validation and error handling mechanisms to ensure data integrity and prevent runtime errors.
• Regularly review and optimize your page property usage to identify potential performance bottlenecks.
• Consider using Sling Models or other abstraction layers to encapsulate page property access and management.

By following these best practices, you can ensure that your AEM solutions are efficient, maintainable, and scalable, while leveraging the full potential of page properties.

Mastering the art of retrieving page properties in AEM is a crucial skill for any AEM developer. By understanding the various methods and techniques outlined in this article, you can build robust and customized solutions that leverage the power of AEM’s content management capabilities. Remember to continuously learn, experiment, and stay up-to-date with the latest AEM developments to enhance your skills and deliver exceptional digital experiences.