@ScriptVariable in AEM

-




In Apache Sling, @ScriptVariable is an annotation used in Sling Models to inject objects from the HTL (HTML Templating Language) script context into the model class. It is part of the Sling Models API and helps bridge the gap between the templating layer and backend logic by allowing developers to access various predefined or custom variables.

Key Features of @ScriptVariable:

  1. Source Context:

    • It pulls variables that are typically available in the HTL script context, such as currentPage, resource, or request.

  2. Type-Safe Access:

    • The variable injected by @ScriptVariable is strongly typed, meaning the developer defines the type of the object to be injected.

  3. Simplifies Code:

    • Reduces the need to manually retrieve these variables from the script context, leading to cleaner and more maintainable code.

How It Works:

  1. HTL Context:

    • Variables like currentPage are typically defined automatically in the HTL context when rendering a component or page.
    • Example in HTL:
      <h1>${currentPage.title}</h1>

  2. Sling Model Binding:

    • With @ScriptVariable, you bind these HTL-provided variables to backend logic.
    • The framework automatically resolves the variable name (currentPage, etc.) and injects it into the model.

Common Script Variables in AEM:

  • currentPage: Represents the current page being rendered as a Page object.
  • resource: The current Sling Resource being processed.
  • currentDesign: Represents the current design object used in the context of the page.
  • wcmmode: Provides the current WCM mode (e.g., edit, preview, disabled).
  • request: The current HTTP request object (SlingHttpServletRequest).
  • response: The current HTTP response object (SlingHttpServletResponse).
  • slingRequest: Alias for request, specific to Sling context.
  • slingResponse: Alias for response, specific to Sling context.
  • component: The current component object.
  • currentStyle: Represents the current design style (used for editable templates and policies).
  • properties: Accesses the properties of the current resource.
  • log: Provides a logging utility for debugging.
  • componentContext: Context information for the component being processed.
  • editContext: Contains information for the current edit session in the authoring environment.
  • resourceResolver: The ResourceResolver associated with the current request.

Key Points to Remember:

  • @ScriptVariable can only inject variables that are available in the rendering context.
  • It works in conjunction with the Sling Models API and requires the proper Sling Models dependencies in your project.
  • If the variable is not available in the script context, it will inject null, unless default values or optional strategies are configured.

This feature is particularly powerful in AEM to simplify development by avoiding redundant lookups for objects that are already available in the rendering layer.

Comments

Post a Comment

Popular posts from this blog

Debugging Javascript Memory Leaks

-
     Let’s dive into debugging memory leaks step-by-step using tools like Chrome DevTools  and best practices for Angular. We’ll focus on identifying and fixing issues effectively. 1. Understanding the Tools Browser DevTools: Performance Tab : Monitor memory usage over time. Memory Tab : Analyze heap snapshots and memory retention. Console : Observe memory usage using the window.performance.memory object (not in all browsers). Augury Extension : Provides Angular-specific insights such as component hierarchies and bindings. Can highlight improper use of change detection or subscriptions. RxJS Spy : Helps track Observables and their subscriptions in real time. 2. Step-by-Step Debugging Step 1: Record Memory Usage Use the Performance Tab in Chrome DevTools: Open DevTools ( Ctrl + Shift + I or F12 ). Go to the Performance tab. Click Record and interact with your application (e.g., navigate between components). Stop recording and review: Look for steady memory incre...
Read more

Memory Leaks in Javascripts

-
     A memory leak occurs when an application consumes memory that it no longer needs but fails to release. Over time, this unneeded memory builds up, reducing the available memory for the application or other processes. This can lead to performance degradation, crashes, or application instability. In the context of Angular (or any JavaScript application), memory leaks often happen when objects or references remain in memory longer than necessary because: The garbage collector cannot reclaim them. They are inadvertently kept alive by event listeners , subscriptions , or references . How Memory Management Works in JavaScript JavaScript uses automatic garbage collection : When an object or value is no longer reachable, it is eligible for garbage collection. The garbage collector identifies and removes these unreachable objects to free up memory. However, if objects are still referenced (even unintentionally), the garbage collector cannot reclaim them, causing a memory le...
Read more

Apache Jackrabbit FileVault (VLT)

-
  Apache Jackrabbit FileVault (commonly known as VLT) is a content synchronization tool and file system-based content repository management system for Apache Jackrabbit and Adobe Experience Manager (AEM) . It enables developers to work with JCR (Java Content Repository) content as regular files and folders on the local file system, facilitating version control, content packaging, and easy deployment of repository content. Key Features of FileVault File System View of JCR Content FileVault provides a way to map the content repository (JCR nodes and properties) into a local file system structure. Developers can view and manage JCR content using standard file system tools like text editors, IDEs, and version control systems (e.g., Git). Content Packaging It allows creating content packages (ZIP files) that can be deployed to other AEM instances. These packages can include: JCR content (e.g., pages, components, templates). OSGi configurations. Code (Java, client-side libraries). Vers...
Read more