Sling Models Archives - Sourced Code

Handling Http Requests, HttpClient, in AEM

briankasingli — Sat, 24 Feb 2024 18:13:27 +0000

When integrating with external services or APIs from Adobe Experience Manager (AEM), utilizing the HttpClient for outbound HTTP requests is a common requirement. It’s crucial to handle these connections efficiently, securely, and in a way that is compatible with AEM’s architecture to ensure optimal performance and maintainability of your code.

AEM provides a specialized factory, HttpClientFactory, designed to streamline the creation and configuration of HttpClient instances. This factory not only simplifies the process of instantiating HttpClient objects but also ensures that the instances are optimized for use within the AEM environment.

By leveraging HttpClientFactory, developers can take advantage of built-in connection pooling and configuration optimizations that are specifically tailored for AEM applications. Furthermore, using AEM’s HttpClientFactory significantly facilitates the unit testing of code that makes HTTP requests, allowing for more maintainable and testable codebases.

Quick Links

1. Utilize AEM’s HttpClientFactory
1.1 OSGi Components & Sling Servlets
12 Sling Models & Workflows
2. Ensure Proper Resource Management
3. Configure HttpClient Securely
4. Reuse HttpClient Instances Wisely
5. Monitor and Log HttpClient Activity

1. Utilize AEM’s HttpClientFactory

Leverage AEM’s HttpClientFactory or the OSGi HttpClientBuilderFactory for creating instances of HttpClient. This ensures you benefit from connection pooling, proper configuration, and optimizations tailored for AEM. Avoid manually creating HttpClient instances as it bypasses these optimizations and can lead to resource leakage and scalability issues.

1.1 OSGi Components & Sling Servlets

OSGi Components: Custom services, event handlers, schedulers, and any other Java class defined as an OSGi component can use this code pattern below. OSGi components are the backbone for modular development in AEM, allowing for dynamic module management within the application.

Sling Servlets: Sling Servlets are another type of OSGi component that can use HttpClientBuilderFactory for making HTTP requests; using the code pattern below. Sling Servlets handle HTTP requests and can be used for various purposes, including interfacing with external systems.

1
2
3
4
5
6
7
8
9
10

@Reference
private HttpClientBuilderFactory httpClientBuilderFactory;

public void executeHttpRequest() {
try (CloseableHttpClient httpClient = httpClientBuilderFactory.newBuilder().build()) {
// Perform HTTP operations with httpClient
} catch (IOException e) {
// Handle exceptions
}
}

1.2 Sling Models & Workflows

Sling Models: While not typically using @Reference (as they are not OSGi components themselves), Sling Models can still access OSGi services like HttpClientBuilderFactory through the use of the @OSGiService annotation or by adapting from a Sling resource or request; using the code pattern below. This allows Sling Models to utilize services for fetching or sending data to external systems as part of their logic.

Workflows: Custom workflow steps can interact with OSGi services, including HttpClientBuilderFactory, to perform operations like sending data to external systems or integrating with RESTful services as part of the workflow process. These custom steps are developed as OSGi components and can use the @Reference annotation to inject necessary services.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Model(adaptables = Resource.class)
public class ExampleSlingModel {

@OSGiService
private HttpClientBuilderFactory httpClientBuilderFactory;

public void executeHttpRequest() {
try (CloseableHttpClient httpClient = httpClientBuilderFactory.newBuilder().build()) {
// Perform HTTP operations with httpClient
} catch (IOException e) {
// Handle exceptions
}
}
}

2. Ensure Proper Resource Management

Always close HttpClient, HttpResponse, and any InputStream or Entity objects to release system resources and avoid connection leaks. Utilize try-with-resources or finally blocks to ensure resources are closed even if exceptions occur.

1
2
3
4
5
6

try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
// Process the response
EntityUtils.consume(response.getEntity());
} catch (IOException e) {
// Handle exceptions
}

3. Configure HttpClient Securely

Pay attention to security configurations when setting up your HttpClient. This includes setting up SSL context correctly, enabling hostname verification, and configuring timeouts to prevent attacks that target resource consumption. Avoid disabling SSL verification or other security features unless absolutely necessary and understood.

1
2
3
4
5
6
7
8
9
10
11

RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(5000)
.setSocketTimeout(5000)
.build();
try (CloseableHttpClient httpClient = httpClientBuilderFactory.newBuilder()
.setDefaultRequestConfig(requestConfig)
.build()) {
// Securely configured HttpClient
} catch (IOException e) {
// Handle exceptions
}

4. Reuse HttpClient Instances Wisely

For efficiency, reuse HttpClient instances across requests whenever possible. This approach benefits from the HTTP connection pooling managed by AEM, reducing the overhead of establishing connections for each request. However, ensure that any client-specific configurations do not unintentionally affect subsequent requests.

5. Monitor and Log HttpClient Activity

Implement logging and monitoring around your HTTP requests to diagnose issues, track performance, and understand dependencies on external services. Use AEM’s logging capabilities to log request details, response times, and errors. This can aid in troubleshooting and optimizing the use of HttpClient in your application.

1
2
3
4
5
6

try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
// Log the status line
LOG.debug("HTTP response status: {}", response.getStatusLine());
} catch (IOException e) {
LOG.error("HTTP request execution failed", e);
}

By adhering to these five rules, developers can ensure their AEM projects make the most out of HttpClient for external communications, balancing efficiency with robust security practices. Utilizing AEM’s HttpClientFactory not only streamlines the development process but also enhances the ease of unit testing, making it an indispensable practice for AEM development.

The post Handling Http Requests, HttpClient, in AEM appeared first on Sourced Code.

AEM Style System Component Information with Code Sling Models

briankasingli — Thu, 13 Apr 2023 00:41:21 +0000

As an AEM full-stack web developer who frequently works with AEM components, it’s not uncommon to require access to the AEM Style System configuration of a specific component. This information can prove invaluable when writing conditional algorithms to manipulate data output. However, the question remains: how can one retrieve the necessary AEM Style System information from within the components themselves via the backend?

Thankfully, Adobe offers a useful tool in the form of the com.adobe.cq.wcm.style.ComponentStyleInfo Sling model utility class. This class provides a straightforward means of accessing vital information about the styles applied to a component via Style System. By utilizing the methods provided by ComponentStyleInfo, developers can quickly and easily obtain the style information necessary to enhance the functionality of their AEM components.

In this blog article you will find examples on how to get the AEM Component’s Style System configuration from the backend using sling models or just with the resource object itself.

A. Code Example of resource.adaptTo(ComponentStyleInfo.class)

In the examples below we will observe a targeted component as a “Resource” which we will adapt the ComponentStyleInfo.class.

1	ComponentStyleInfo componentStyleInfo = resource.adaptTo(ComponentStyleInfo.class);

Once the resource have been adapted, you can see all these available properties. Here you can access the entire component’s policies, like the ability to view:

appliedCssClasses: list of applied CSS classes (this is a String type).
styles: Which is a list of the AEM Style System items that has been selected, with all the meta data involved (this is a LinkedList type)
contentPolicyStyleInfo: this an object that exposes the entire AEM Style System, Style Groups, that is configured for this given component.

It’s common that developers would only want to retrieve the list of appliedCssClasses, and so, here’s an example below where only the appliedCssClasses will be returned to the backend developer. The appliedCssClasses is then used to validate if my class exists, and if so, execute some code… if not, do nothing.

B. Code Example of testing appliedCssClasses

1
2
3
4
5
6
7
8
9
10

String appliedCssClasses = Optional.ofNullable(this.resource.adaptTo(ComponentStyleInfo.class))
.map(ComponentStyleInfo::getAppliedCssClasses)
.filter(StringUtils::isNotBlank)
.orElse(null);

if (appliedCssClasses.contains("my-class") {
// execute
} else {
// do nothing
}

The post AEM Style System Component Information with Code Sling Models appeared first on Sourced Code.

WCM Core Components Sling Models Interfaces Design

briankasingli — Sat, 05 Nov 2022 20:18:16 +0000

While reviewing Adobe’s WCM Core components you may realize that the Sling model all have JAVA interfaces. Why do they follow this design pattern, and what benefits does it help to the overall design of their Sling models? In this article, I will share my understanding of why Adobe designed its Sling models like this.

The simple answer is backward compatibility and versioning for implementing v1,v2,v3… of the AEM Core Components.

In this article, we will target the https://github.com/adobe/aem-core-wcm-components/blob/main/bundles/core/src/main/java/com/adobe/cq/wcm/core/components/models/Title.java Sling Model interface, to see what Adobe’s design pattern is with the Sling Models.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

@ConsumerType
public interface Title extends Component {
String PN_DESIGN_DEFAULT_TYPE = "type";
String PN_TITLE_LINK_DISABLED = "linkDisabled";
default String getText() {
return null;
}
default String getType() {
return null;
}
@Nullable
default Link getLink() {
return null;
}
@Deprecated
default String getLinkURL() {
return null;
}
default boolean isLinkDisabled() {
return false;
}
}

Why Interfaces

One of the fundamental concepts of Java is Java Interface. Java Interface is a fundamental component of all programming languages and are extensively used in software engineering design patterns. The majority of frameworks strongly rely on the interface.

Java’s interfaces offer a means of achieving abstraction. Additionally, the contract for the subclasses to implement is defined by the Java interface. Let’s imagine, for instance, that we wish to make a creation using a variety of animals. Here, we can design the interface for the Animal object type and specify all the methods that it will support. For the sake of simplicity, we can limit ourselves to just two methods: walk(), which will make our animal walk, and talk(), which will make the animal talk.

Benefits of Java Interfaces

It is wise to code in terms of interfaces since implementation classes cannot remove the methods we are using. Interfaces offer a contract for all implementation classes.
Interfaces are a great place to start when defining Types and building top-level hierarchies in our programs.
Since a Java class can implement many interfaces, it’s usually preferable to utilize an interface as a superclass.

Adobe’s Approach

From what I can see, Adobe’s approach to their Sling Model designs is highly prioritized on backward compatibility. When version 1 of the WCM Core Title component was released, the Title interface was created for it. The sling model backend is implemented via com.adobe.cq.wcm.core.components.internal.models.v1.TitleImpl. The Sightly code is tightly coupled with the getters() for the backend Sling Models.

As we move on in time, Adobe identifies bad performance their com.adobe.cq.wcm.core.components.internal.models.v1.TitleImpl Sling Model backend logic, so they introduced the v3 Title (skipped a version). For v3 implementation of the Title interface, they introduced com.adobe.cq.wcm.core.components.internal.models.v3.TitleImpl, and it extends from v1 Title and implements the Title interface.

Expected, customers are supposed to benefit from the performance improvements from the version upgrades, so AEM developers would update their organization’s proxied components to reference to the WCM Core Component’s latest version For the sake of the example, WCM Core Title Component, the latest Adobe backend Sling Model version updates are required to implement the Title interface, getters are still available, so this guarantees that our proxied components are still working as expected.

After updating our proxied components to reference the latest WCM Core Components, our components will benefit from the latest performance fixes. Simply to utilize the latest v3 of the title component’s performance enhanced BE execution, change your proxy component’s sling:resourceSuperType to “core/wcm/components/title/v3/title”, and it would take effect. Now v3 of the title component, “core/wcm/components/title/v3/title”, will be referenced to the correct backend Sling Model implementation, and invokes the correct version. The Sling Model is mapped via resourceType = TitleImpl.RESOURCE_TYPE, and that’s how the proxied component will select the correct v3 implementation of the title component, and execute the backend to produce the data model back to the front end (via Sightly);

Example of Adobe’s WCM Core Component’s v3 Title Component’s implementation. Take a look at line 15, where the implementation of the title v3 is registered with the resourceType. This component’s implementation also extends from com.adobe.cq.wcm.core.components.internal.models.v1.TitleImpl and implements Title interface.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package com.adobe.cq.wcm.core.components.internal.models.v3;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.models.annotations.Exporter;
import org.apache.sling.models.annotations.Model;

import com.adobe.cq.export.json.ComponentExporter;
import com.adobe.cq.export.json.ExporterConstants;
import com.adobe.cq.wcm.core.components.commons.link.Link;
import com.adobe.cq.wcm.core.components.models.Title;
import com.fasterxml.jackson.annotation.JsonIgnore;

@Model(adaptables = SlingHttpServletRequest.class,
adapters = {Title.class, ComponentExporter.class},
resourceType = TitleImpl.RESOURCE_TYPE)
@Exporter(name = ExporterConstants.SLING_MODEL_EXPORTER_NAME,
extensions = ExporterConstants.SLING_MODEL_EXTENSION)
public class TitleImpl extends com.adobe.cq.wcm.core.components.internal.models.v1.TitleImpl implements Title {

protected static final String RESOURCE_TYPE = "core/wcm/components/title/v3/title";

@Override
public Link getLink() {
return link.isValid() ? link : null;
}

@Override
@JsonIgnore
@Deprecated
public String getLinkURL() {
return super.getLinkURL();
}

}

Adobe’s Github: https://github.com/adobe/aem-core-wcm-components/blob/main/bundles/core/src/main/java/com/adobe/cq/wcm/core/components/internal/models/v3/TitleImpl.java

Lesson here

The lesson here is, if you are planning to create your own versioned components for your organization, creating interfaces for Sling Models is actually a great design pattern. It allows your organization to be future proof, to fix performance issues, and extend new concepts. Most of all, the latest versions will still be backwards compatible.

The post WCM Core Components Sling Models Interfaces Design appeared first on Sourced Code.

Checking run mode from Sightly HTL in AEM

briankasingli — Mon, 23 May 2022 04:10:08 +0000

Sometimes during development, we would need to check the run mode in our AEM environment, so we can show different content based on the context. From the Sightly HTL API, it’s possible to check for the wcmmode, but not the runmode.

In this article, we will set up a sling model helper which will be a sling model, and then use Sightly HTL, data-sly-use, API, to access which run mode we are in. How to check runmode in AEM Sightly HTL can never be this easy.

slingSettingsService is a deprecated service
We understand that the slingSettingsService is a deprecated service, and you would still like to find a way to retrieve the run mode where it equals to “development”, “staging”, or “production”, I wrote a new article that can solve this issue, https://sourcedcode.com/blog/aem/checking-run-mode-from-sightly-htl-in-aem-in-2023. Take a look!

Sightly Code

1
2
3
4
5
6
7
8
9
10
11

<h1>In Development</h1>

<h1>In Staging</h1>

<h1>In Production</h1>

Java Sling Model

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package com.sourcedcode.core.models.utils;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.models.annotations.Default;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.OSGiService;
import org.apache.sling.models.annotations.injectorspecific.RequestAttribute;
import org.apache.sling.settings.SlingSettingsService;

import javax.annotation.PostConstruct;

@Model(adaptables = SlingHttpServletRequest.class)
public class RunModeHelper {

@OSGiService
private SlingSettingsService slingSettingsService;

@RequestAttribute
@Default(values = "null")
private String runmode;

private boolean hasRunMode = false;

@PostConstruct
public void init() {
String runModes = slingSettingsService.getRunModes().toString();
hasRunMode = runModes.contains(runmode);
}

public boolean getHasRunMode() {
return hasRunMode;
}
}

The post Checking run mode from Sightly HTL in AEM appeared first on Sourced Code.

How to Generate Unique AEM Component ID with Confidence

briankasingli — Sun, 03 Apr 2022 04:24:28 +0000

You frequently require a special ID for the AEM component. Either a backend server-side call or a custom JS action trigger are required. If the component is dragged and placed on the page more than once, the hard-coded field ID is not guaranteed to be unique.

When considering ID, you might consider directly using the global HTL objects and getters, such as ${currentNode.name}. If the component is used in other containers on the same page, this will not, however, fix the issue. Despite the fact that the JCR node level API produces a distinct id for the current node, the id also includes the node path and forward slashes, exposing the internal content structure and making it challenging to utilize in CSS and JS without escaping.

The id element is made simple to use by CSS and JS by the hash code, which also encapsulates and hides internal path information from the end-user. The developer passes in the ID prefix to make the ID property easier for humans to read. Example code of a Java Sling Model class is provided below.

Note: Please note that this blog article was created in 2022, and so, preferred to create the id is via extending the AbstractComponentImpl object, which provides you the getId method. This method will be the best practice while trying to generate an id for your component. Example code can be found here -> https://github.com/adobe/aem-core-wcm-components/blob/main/bundles/core/src/main/java/com/adobe/cq/wcm/core/components/internal/models/v1/TitleImpl.java#L21

Sightly

1
2
3
4
5
6

="com.sourcedcode.core.models.utils.ComponentId"></sly>
<div id="${componentId.id}" class="cmp-header">
</div>

// this produces
<div id="cmpheader3901793341" class="cmp-header"></div>

Java Sling Model

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package com.sourcedcode.core.models.utils;

import com.day.cq.wcm.api.components.Component;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.ScriptVariable;
import org.apache.sling.models.annotations.injectorspecific.SlingObject;

@Model(adaptables = {SlingHttpServletRequest.class, Resource.class}, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ComponentId {

@ScriptVariable
private Component component;

@SlingObject
private Resource resource;

public String getId() {
return component.getName() + "-" + String.valueOf(Math.abs(resource.getPath().hashCode() - 1));
}
}

Last Thoughts

You can improve this setup by adding an “advanced” tab in the component’s Touch UI dialog to have authors insert their own custom component ID. If the author’s configuration is empty, this mechanism will be kicked in to use the ComponentId Sling Model to generate the Ids.

1
2
3
4
5
6

="com.sourcedcode.core.models.utils.ComponentId"></sly>
<div id="${properties.customComponentId || componentId.id}" class="cmp-header">
</div>

// this produces
<div id="cmpheader3901793341" class="cmp-header"></div>

The post How to Generate Unique AEM Component ID with Confidence appeared first on Sourced Code.

JUnit 4: AEM How to Mock @RequestAttribute value in Sling Model

briankasingli — Thu, 20 Jan 2022 03:28:56 +0000

This blog article will show code an example for JUnit 4, for how the Request Attribute is being mocked. This example will only cover mocking the @RequestAttribute with the use of @PostConstruct runtime phase, When you are in the code runtime phase of the constructor injection, this will not work (I spent a bit of time on this).

Attention
This article will not cover how to setup JUnit 4 for AEM, but however, more information can be found on this blog article.

Sling Model Class : ExampleSlingModel.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package com.sourcedcode.core.models;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.RequestAttribute;

import javax.annotation.PostConstruct;

@Model(adaptables = SlingHttpServletRequest.class,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleSlingModel {

@RequestAttribute(name = "websitename")
private String websiteName;

@RequestAttribute
private int version;

@PostConstruct
public void init() {
websiteName = websiteName.concat(":websitename");
version = version * 2;
}

public String getWebsiteName() {
return websiteName;
}

public int getVersion() {
return version;
}
}

Sling Model Test Class : ExampleSlingModelTest.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package com.sourcedcode.core.models;

import io.wcm.testing.mock.aem.junit.AemContext;
import org.apache.sling.testing.mock.sling.ResourceResolverType;
import org.apache.sling.testing.mock.sling.servlet.MockSlingHttpServletRequest;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;

public class ExampleSlingModelTest {

@Rule
public final AemContext aemContext = new AemContext(ResourceResolverType.JCR_MOCK);

private MockSlingHttpServletRequest request;

private ExampleSlingModel underTest;

@Before
public void setUp() throws Exception {
aemContext.addModelsForPackage("com.sourcedcode.utils");
request = aemContext.request();
request.setAttribute("websitename", "sourcedcode");
request.setAttribute("version", 5);
}

@Test
public void test_getWebsiteName() {
underTest = request.adaptTo(ExampleSlingModel.class);
Assert.assertEquals("sourcedcode:websitename", underTest.getWebsiteName());
}

@Test
public void test_getVersion() {
underTest = request.adaptTo(ExampleSlingModel.class);
Assert.assertEquals(10, underTest.getVersion());
}
}

The post JUnit 4: AEM How to Mock @RequestAttribute value in Sling Model appeared first on Sourced Code.

Get Cookie Example of AEM Servlet and Sling Model

briankasingli — Wed, 19 Jan 2022 04:58:31 +0000

In this short article, we will show two code examples; for example, one will be showcasing how cookies values can be accessed for an AEM Servlet, and for example two, Sling Model.

1. AEM Servlet Get Cookie Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

package com.sourcedcode.core.servlet;

import com.cat.wcm.core.util.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.osgi.service.component.annotations.Component;

import javax.servlet.Servlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

import static org.apache.sling.api.servlets.ServletResolverConstants.SLING_SERVLET_PATHS;

@Component(
service = { Servlet.class },
property = {
SLING_SERVLET_PATHS + "=/bin/getCookieExample"
}
)
public class GetCookieServletExample extends SlingAllMethodsServlet {

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
Cookie myCookie = getCookie(request, "myCookie");
String myCookieValue = "";
if (myCookie != null && !myCookie.getValue().isBlank()) {
myCookieValue = myCookie.getValue();
}

// server response
response.setStatus(200);
response.setContentType("application/json");

JSONObject jsonResponse = new JSONObject();
jsonResponse.put("myCookie", myCookieValue);
response.getWriter().write(jsonResponse.toString());
}

// extracted helper method
private Cookie getCookie(HttpServletRequest request, String cookieName) {
if (StringUtils.isBlank(cookieName)) {
return null;
} else {
Cookie[] cookies = request.getCookies();
if (cookies == null) {
return null;
} else {
if (cookies.length > 0) {
Cookie[] var3 = cookies;
int var4 = cookies.length;
for(int var5 = 0; var5 < var4; ++var5) {
Cookie cookie = var3[var5];
if (StringUtils.equals(cookieName, cookie.getName())) {
return cookie;
}
}
}
return null;
}
}
}
}

2. Sling Model Get Cookie Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

package com.sourcedcode.models.pages.page;

import org.apache.commons.lang.StringUtils;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.SlingObject;

import javax.annotation.PostConstruct;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;

@Model(
adaptables = {SlingHttpServletRequest.class, Resource.class},
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleModel {

@SlingObject
protected SlingHttpServletRequest request;

@PostConstruct
private void init() {
Cookie myCookie = getCookie(request, "myCookie");
String myCookieValue = "";
if (myCookie != null && !myCookie.getValue().isBlank()) {
myCookieValue = myCookie.getValue();
}
}

// extracted helper method
private Cookie getCookie(HttpServletRequest request, String cookieName) {
if (StringUtils.isBlank(cookieName)) {
return null;
} else {
Cookie[] cookies = request.getCookies();
if (cookies == null) {
return null;
} else {
if (cookies.length > 0) {
Cookie[] var3 = cookies;
int var4 = cookies.length;
for(int var5 = 0; var5 < var4; ++var5) {
Cookie cookie = var3[var5];
if (StringUtils.equals(cookieName, cookie.getName())) {
return cookie;
}
}
}
return null;
}
}
}
}

The post Get Cookie Example of AEM Servlet and Sling Model appeared first on Sourced Code.

Set Cookie Example of AEM Servlet and Sling Model

briankasingli — Wed, 19 Jan 2022 04:28:30 +0000

In this short article, we will show two code examples; for example, one will be showcasing how cookies values can be set for an AEM Servlet, and for example two, Sling Model.

1. AEM Servlet Set Cookie Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package com.sourcedcode.core.servlets;

import com.cat.wcm.core.util.JSONObject;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.osgi.service.component.annotations.Component;

import javax.servlet.Servlet;
import javax.servlet.http.Cookie;
import java.io.IOException;

import static org.apache.sling.api.servlets.ServletResolverConstants.SLING_SERVLET_PATHS;

@Component(
service = { Servlet.class },
property = {
SLING_SERVLET_PATHS + "=/bin/setCookieExample"
}
)
public class SetCookieServletExample extends SlingAllMethodsServlet {

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
Cookie cookie = new Cookie("visitedCookieServletExample", "true");
cookie.setMaxAge(86400); // in seconds, 86400 = 24 hours.
response.addCookie(cookie);

// server response
response.setStatus(200);
response.setContentType("application/json");

JSONObject jsonResponse = new JSONObject();
jsonResponse.put("success", "true");
response.getWriter().write(jsonResponse.toString());
}
}

2. Sling Model Set Cookie Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package com.sourcedcode.models.pages.page;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.SlingObject;

import javax.annotation.PostConstruct;
import javax.servlet.http.Cookie;

@Model(
adaptables = {SlingHttpServletRequest.class, Resource.class},
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleModel {

@SlingObject
protected SlingHttpServletResponse response;

@PostConstruct
private void init() {
Cookie cookie = new Cookie("visitedExampleModel", "true");
cookie.setMaxAge(86400); // in seconds, 86400 = 24 hours.
response.addCookie(cookie);
}
}

The post Set Cookie Example of AEM Servlet and Sling Model appeared first on Sourced Code.

How to Pass Data Parameters to Sling Modal from Sightly HTL Component

briankasingli — Sat, 23 Oct 2021 04:52:31 +0000

You can pass data parameters from Sightly HTL component to the Sling Model backend by request attributes. For implementation, utilising the org.apache.sling.models.annotations.Model, we will add required options parameter, adaptable, with the value of SlingHttpServletRequest.class. Next, we can utilize the annotation, org.apache.sling.models.annotations.injectorspecific.RequestAttribute (@RequestAttribute), which will find the matching name of the attribute that is being passed from the Sightly HTL component.

As developers. We learn best by example, See the example below of an example of Sightly HTL component referencing to the Sling Model backend.

I created the code below to showcase a real production scenario. After a selection from the TouchUI pathfinder, we are given a path of /content/sourcedcode/en/home. From sightly, we must append a .html, but when the path was not chosen with the TouchUI pathfinder with the value set manually to https://sourcedcode.com, no .html extensions should be added.

This example below showcases how we can logically insert the .html extensions based on conditions.

Sightly HTL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// expect /content/sourcedcode/home.html
<a class="title-text" data-sly-use.linkResolve="${'com.sourcedcode.core.utils.use.LinkResolve' @ href='/content/sourcedcode/home'}" href="${linkResolve.href}" target="${linkResolve.target}" rel="noopener">
${linkResolve.href}
</a>
<br/>
// expect https://sourcedcode.com
<a class="title-text" data-sly-use.linkResolve="${'com.sourcedcode.core.utils.use.LinkResolve' @ href='https://sourcedcode.com'}" href="${linkResolve.href}" target="${linkResolve.target}" rel="noopener">
${linkResolve.href}
</a>
// expect https://sourcedcode.com
<a data-sly-use.linkResolve="${'com.sourcedcode.core.models.LinkResolve' @
href=properties.href,
target=properties.target}" href="${linkResolve.href}" target="${linkResolve.target}" rel="noopener">
${linkResolve.href}
</a>

Sling Model Class : LinkResolve.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

package com.sourcedcode.core.models;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.models.annotations.Default;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.Optional;
import org.apache.sling.models.annotations.injectorspecific.RequestAttribute;

import javax.annotation.PostConstruct;
import java.util.regex.Pattern;

@Model(adaptables = SlingHttpServletRequest.class)
public class LinkResolve {

@RequestAttribute
private String href;

@Optional
@Default(values="_self")
@RequestAttribute
private String target;

@PostConstruct
public void init() {
if (href == null || href.isEmpty())
return;

boolean isLinkExternal = Pattern.compile("^https?://.*").matcher(href).matches();
boolean isLinkInternalAsset = Pattern.compile(".*\\.(\\w){1,5}$").matcher(href).matches();

if (!isLinkExternal && !isLinkInternalAsset) {
href = (href.endsWith(".html") || href.contains("?")) ? href : href + ".html";
}
}

public String getHref() {
return href;
}

public String getTarget() {
return target;
}
}

The post How to Pass Data Parameters to Sling Modal from Sightly HTL Component appeared first on Sourced Code.

JUnit 4: AEM Sling Models Unit Test Constructor Injection Example

briankasingli — Sun, 05 Jul 2020 11:14:23 +0000

In this example, we will take a look at how we can mock Sling Model Constructor Injection dependencies for a JUnit 4 Unit test.

Scenario:
The Sling Model must expose either the PROD_URL or the DEAFULT_URL endpoint based on the run mode or request parameters; this is the requirement. The example below will demonstrate the implementation of logic utilising Sling Model Constructor injection, show Unit test examples, and how mocked dependencies can be Sling Model Constructor injected during the test phase. This completes the example.

Technologies here used are:

AEM project archetype 19 (link)
Mockito 2.27.0 (link)
AEM Mocks JUnit 4 2.7.2 (link)

This example uses the AEM project archetype 19 to generate a new AEM project, Junit 4 will be used as the testing framework, Mockito 2.27.0 will be used as the mocking framework, and AEM Mocks will be used to mock AEM objects and AEM objects.

What’s really great about the latest versions of AEM mocks, is that the setup is very minimal. After spinning up a new AEM project from the AEM project archetype 19, you simply need to include the AEM Mocks dependency, and you are ready to go!

Dependencies

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// pom.xml

<plugin>
<groupId>org.apache.maven.pluginsgroupId>
<artifactId>maven-surefire-pluginartifactId>
<version>2.20version>
<configuration>
<junitArtifactName>junit:junit:4junitArtifactName>
configuration>
plugin>
...
<dependencies>
...
<dependency>
<groupId>io.wcmgroupId>
<artifactId>io.wcm.testing.aem-mockartifactId>
<version>2.7.2version>
<scope>testscope>
dependency>
...
dependencies>

// core/pom.xml
<dependencies>
...
<dependency>
<groupId>io.wcmgroupId>
<artifactId>io.wcm.testing.aem-mockartifactId>
dependency>
...
dependencies>

Sling Model Test Class : ConstructorInjection.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package com.sourcedcode.core.models;

import com.adobe.cq.export.json.ExporterConstants;
import lombok.Getter;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Exporter;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.OSGiService;
import org.apache.sling.models.annotations.injectorspecific.SlingObject;
import org.apache.sling.settings.SlingSettingsService;

import javax.inject.Inject;
import javax.inject.Named;

import static org.apache.commons.lang3.StringUtils.EMPTY;
import static org.apache.commons.lang3.StringUtils.isNotEmpty;

@Model(adaptables = {SlingHttpServletRequest.class, Resource.class}, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
@Exporter(name = ExporterConstants.SLING_MODEL_EXPORTER_NAME, extensions = ExporterConstants.SLING_MODEL_EXTENSION)
public class ConstructorInjection {

protected static final String API_URL_PROD = "https://api.sourcedcode.com/v1/constructors";
protected static final String API_URL_DEFAULT = "https://uat-api.sourcedcode.com/v1/constructors";

@Getter
private String apiUrl = EMPTY;

@Inject
public ConstructorInjection(@OSGiService @Named("slingSettingsService") final SlingSettingsService slingSettingsService,
@SlingObject @Named("slingHttpServletRequest") final SlingHttpServletRequest request) {
boolean isProd = slingSettingsService.getRunModes().contains("prod");
boolean isParamProd = isNotEmpty(request.getParameter("prod")) && request.getParameter("prod").equals("true");
if (isProd || isParamProd) {
apiUrl = API_URL_PROD;
} else {
apiUrl = API_URL_DEFAULT;
}
}
}

Sling Model Test Class : ConstructorInjectionTest.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

package com.sourcedcode.core.models;

import io.wcm.testing.mock.aem.junit.AemContext;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.settings.SlingSettingsService;
import org.apache.sling.testing.mock.sling.ResourceResolverType;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import java.util.Collections;

import static org.junit.Assert.assertEquals;
import static uk.co.whitbread.wlrestaurants.core.models.ConstructorInjection.API_URL_DEFAULT;
import static uk.co.whitbread.wlrestaurants.core.models.ConstructorInjection.API_URL_PROD;

@RunWith(MockitoJUnitRunner.class)
public class ConstructorInjectionTest {

@Rule
public final AemContext context = new AemContext(ResourceResolverType.JCR_MOCK);

@Mock
private SlingSettingsService slingSettingsService;

@Mock
SlingHttpServletRequest request;

@InjectMocks
private ConstructorInjection underTest;

@Test
public void apiUrl_should_return_PROD_url_when_runmode_prod() {
context.runMode("prod");
underTest = context.request().adaptTo(ConstructorInjection.class);
assert underTest != null;
assertEquals(API_URL_PROD, underTest.getApiUrl());
}

@Test
public void apiUrl_should_return_DEFAULT_url_when_runmode_not_prod() {
context.runMode("staging");
underTest = context.request().adaptTo(ConstructorInjection.class);
assert underTest != null;
assertEquals(API_URL_DEFAULT, underTest.getApiUrl());
}

@Test
public void apiUrl_should_return_PROD_url_when_param_prod_equals_true() {
context.request().setParameterMap(Collections.singletonMap("prod", "true"));
underTest = context.request().adaptTo(ConstructorInjection.class);
assert underTest != null;
assertEquals(API_URL_PROD, underTest.getApiUrl());
}

@Test
public void apiUrl_should_return_DEFAULT_url_when_param_prod_equals_not_true() {
context.request().setParameterMap(Collections.singletonMap("prod", "test"));
underTest = context.request().adaptTo(ConstructorInjection.class);
assert underTest != null;
assertEquals(API_URL_DEFAULT, underTest.getApiUrl());

}
}

More…
Click here to view more examples of AEM JUnit 4 Unit Test Examples.

The post JUnit 4: AEM Sling Models Unit Test Constructor Injection Example appeared first on Sourced Code.

AEM Sling Model Constructor Injection

briankasingli — Sat, 23 May 2020 19:47:44 +0000

Sling Models field injection, @inject, are used to support injection of AEM Library-specific context objects. However, there is an alternative way to inject AEM objects into Sling Models, and its called Constructor Injection.

The benefits of Sling Model Constructor Injection:

Does not store the injection references to the adaptable.
Since it does not store injection references to the adapted object, the result of the adapted object has a smaller memory byte size.
Reducing AEM application consumption

1. Sling Model using Field Injection Example:

The example below illustrates a Sling Model field injection of 35 different AEM objects to be available for the adapted object. This example displays how specific Sling Model annotations are being used, references are stored to the adapted object.
MyModel.class:

package com.sourcedcode.core.models;

import com.adobe.cq.sightly.SightlyWCMMode;
import com.adobe.cq.sightly.WCMScriptHelper;
import com.day.cq.wcm.api.PageManager;
import com.day.cq.wcm.api.components.Component;
import com.day.cq.wcm.api.components.ComponentContext;
import com.day.cq.wcm.api.components.EditContext;
import com.day.cq.wcm.api.designer.Design;
import com.day.cq.wcm.api.designer.Designer;
import com.day.cq.wcm.api.designer.Style;
import org.apache.log4j.Logger;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ValueMap;
import org.apache.sling.api.scripting.SlingScriptHelper;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.*;
import org.apache.sling.settings.SlingSettingsService;
import org.apache.sling.xss.XSSAPI;

import javax.annotation.PostConstruct;
import javax.jcr.Node;
import javax.servlet.http.HttpSession;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.util.List;

@Model(adaptables = {SlingHttpServletRequest.class, Resource.class}, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class MyModel {

@ScriptVariable
private Component component;

@ScriptVariable
private ComponentContext componentContext;

@ScriptVariable
private Design currentDesign;

@ScriptVariable
private Node currentNode;

@ScriptVariable
private com.day.cq.wcm.api.Page currentPage;

@ScriptVariable
private HttpSession currentSession;

@ScriptVariable
private Style currentStyle;

@ScriptVariable
private Style currentStyleCustomScriptVarName;

@ScriptVariable
private Designer designer;

@ScriptVariable
private EditContext editContext;

@ScriptVariable
private Logger log;

@ScriptVariable
private PrintWriter out;

@ScriptVariable
private PageManager pageManager;

@ScriptVariable
private ValueMap pageProperties;

@ScriptVariable
private BufferedReader reader;

@ScriptVariable
private SlingHttpServletRequest request;

@ScriptVariable
private ResourceResolver resolver;

@ScriptVariable
private Resource resource;

@ScriptVariable
private Design resourceDesign;

@ScriptVariable
private Page resourcePage;

@ScriptVariable
private SlingHttpServletResponse response;

@ScriptVariable
private SlingScriptHelper sling;

@ScriptVariable
private WCMScriptHelper slyWcmHelper;

@ScriptVariable
private SightlyWCMMode wcmmode;

@ScriptVariable
private XSSAPI xssAPI;

@ValueMapValue
private String linkPath;

@ValueMapValue
private String homePagePath;

@ChildResource
private List<Resource> navLinks;

@RequestAttribute
private String socialParam;

@OSGiService
private SlingSettingsService slingSettingsService;

@Self
private Node node;

@SlingObject
private SlingHttpServletRequest slingHttpServletRequest;

@SlingObject
private SlingHttpServletResponse slingHttpServletResponse;

@SlingObject
private Resource currentResource;

@SlingObject
private ResourceResolver resourceResolver;

@PostConstruct
protected void initModel() {
// logic goes here
}
}

2. Sling Model Constructor Injection Example:

Let’s convert the field injection example to use constructor injection from the above example.

This example below shows a Sling Model which injects 35 different AEM objects with Constructor Injection to be available for the adapted object. Once the Sling Model has been adapted, the adapted object does not store injection references. The result of the adapted object has a smaller memory byte size.

The name of a constructor argument parameter cannot be detected via the Java Reflection API, so the @Named annotation is mandatory for injectors that require a name for resolving the injection.

MyModelConstructor.class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

package com.sourcedcode.core.models;

import com.adobe.cq.sightly.SightlyWCMMode;
import com.adobe.cq.sightly.WCMScriptHelper;
import com.day.cq.wcm.api.PageManager;
import com.day.cq.wcm.api.components.Component;
import com.day.cq.wcm.api.components.ComponentContext;
import com.day.cq.wcm.api.components.EditContext;
import com.day.cq.wcm.api.designer.Design;
import com.day.cq.wcm.api.designer.Designer;
import com.day.cq.wcm.api.designer.Style;
import org.apache.log4j.Logger;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ValueMap;
import org.apache.sling.api.scripting.SlingScriptHelper;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.*;
import org.apache.sling.settings.SlingSettingsService;
import org.apache.sling.xss.XSSAPI;

import javax.inject.Inject;
import javax.inject.Named;
import javax.jcr.Node;
import javax.servlet.http.HttpSession;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.List;

@Model(adaptables = {SlingHttpServletRequest.class, Resource.class}, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class MyModelConstructor implements Serializable {

@Inject
public MyModelConstructor(
@ScriptVariable @Named("component") final Component component,
@ScriptVariable @Named("componentContext") final ComponentContext componentContext,
@ScriptVariable @Named("currentDesign") final Design currentDesign,
@ScriptVariable @Named("currentNode") final Node currentNode,
@ScriptVariable @Named("currentPage") final com.day.cq.wcm.api.Page currentPage,
@ScriptVariable @Named("currentSession") final HttpSession currentSession,
@ScriptVariable @Named("currentStyle") final Style currentStyle,
@ScriptVariable @Named("currentStyle") final Style currentStyleCustomScriptVarName,
@ScriptVariable @Named("designer") final Designer designer,
@ScriptVariable @Named("editContext") final EditContext editContext,
@ScriptVariable @Named("log") final Logger log,
@ScriptVariable @Named("out") final PrintWriter out,
@ScriptVariable @Named("pageManager") final PageManager pageManager,
@ScriptVariable @Named("pageProperties") final ValueMap pageProperties,
@ScriptVariable @Named("reader") final BufferedReader reader,
@ScriptVariable @Named("request") final SlingHttpServletRequest request,
@ScriptVariable @Named("resolver") final ResourceResolver resolver,
@ScriptVariable @Named("resource") final Resource resource,
@ScriptVariable @Named("resourceDesign") final Design resourceDesign,
@ScriptVariable @Named("resourcePage") final Page resourcePage,
@ScriptVariable @Named("response") final SlingHttpServletResponse response,
@ScriptVariable @Named("sling") final SlingScriptHelper sling,
@ScriptVariable @Named("slyWcmHelper") final WCMScriptHelper slyWcmHelper,
@ScriptVariable @Named("wcmmode") final SightlyWCMMode wcmmode,
@ScriptVariable @Named("xssAPI") final XSSAPI xssAPI,
@ValueMapValue @Named("locationsMenusDefaultLinkPath") final String customLocationsMenusDefaultLinkPath,
@ValueMapValue @Named("homePagePath") final String homePagePath,
@ChildResource @Named("navLinks") final List<Resource> navLinks,
@RequestAttribute @Named("socialParam") final String socialParam,
@OSGiService @Named("slingSettingsService") final SlingSettingsService slingSettingsService,
@Self @Named("node") final Node node,
@SlingObject @Named("slingHttpServletRequest") final SlingHttpServletRequest slingHttpServletRequest,
@SlingObject @Named("slingHttpServletResponse") SlingHttpServletResponse slingHttpServletResponse,
@SlingObject @Named("currentResource") final Resource currentResource,
@SlingObject @Named("resourceResolver") final ResourceResolver resourceResolver
) {
// logic goes here
}
}

Note
Using the constructor injection strategy can also reduce memory consumption of your application. Click here to learn about Sling Model Injection vs Constructor Injection Memory Consumption

The post AEM Sling Model Constructor Injection appeared first on Sourced Code.

AEM Sling Model Field Injection vs Constructor Injection Memory Consumption

briankasingli — Thu, 23 Apr 2020 15:47:02 +0000

Article was last updated on June 7th, 2020.

Sling Models field injectors are used to support injection of AEM Library-specific context objects. For example, @ScriptVariable SightlyWCMMode will inject the WCMMode object, @ScriptVariable Resource will inject the current resource object, and @ScriptVariable Style will inject the Style object. These objects are typically stored within the object, so it can be later used to construct the Sling Model’s properties to make available to the context who’s calling it.

With the Apache Sling Model’s injector specific annotations, we are able to inject Sling Objects, AEM Services, OSGI Components, etc… directly into the context of the Sling Model easily without much hassle.

What is the catch? Whenever we are injecting objects into our Sling Models via field injection for later use, an instantiated Sling Model adaptable stores a reference of those object in memory; stored injected objects in the Sling Model instance will consume memory.

The Sling Model constructor injection is also supported (as of Sling Models 1.1.0), and its documented that it does not store the reference to the adaptable, lets test this out.

In this article, we will test the Sling Model memory consumption with two scenarios:

Test 1: Sling Model Field Injection
Test 2: Sling Model Constructor Injection
Conclusion

Test 1: Sling Model Field Injectors

I have 3 injected AEM objects to be stored in my class variables into my Sling Model via field injection; another 3 variables used to expose data to the calling context. Each AEM objects will then be used in the @PostConstruct method, where data would be extracted from each object, and set in the class variables for exposure to the calling context.

I then ran a test for getting the bytes in size for a specific object using the Lucene’s until RamUsageEstimator.

The memory byte size of the Sling Model adaptable object is 40.

MyModel.class : RamUsageEstimator Results:

1
2
3

import org.apache.lucene.util.RamUsageEstimator;
...
System.out.println("MyModel.class + shallowSizeOf:" + org.apache.lucene.util.RamUsageEstimator.shallowSizeOf(req.adaptTo(MyModel.class)));

MyModel.class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

package com.sourcedcode.core.models;

import lombok.Getter;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.ScriptVariable;
import org.apache.sling.models.annotations.injectorspecific.SlingObject;

import javax.annotation.PostConstruct;

@Model(adaptables = {SlingHttpServletRequest.class,
Resource.class}, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class MyModel {

@ScriptVariable
private Resource resource;

@ScriptVariable
private com.day.cq.wcm.api.Page currentPage;

@SlingObject
private SlingHttpServletRequest slingHttpServletRequest;

@Getter
private String currentResourcePath;

@Getter
private String currentPagePagePath;

@Getter
private String requestParam;

@PostConstruct
protected void initModel() {
currentResourcePath = resource.getPath();
currentPagePagePath = currentPage.getPath();
requestParam = slingHttpServletRequest.getParameter("myParam");
}
}

Test 2: Sling Model Constructor Injection

I have 3 injected AEM objects via Constructor Injection; another 3 variables used to expose data to the calling context. This time, I am not storing the AEM objects in as class variables. We can definitely see a change in byes size here.

The memory byte size of the Sling Model adaptable object is 24.

MyModelConstructor.class : RamUsageEstimator Results:

1
2
3

import org.apache.lucene.util.RamUsageEstimator;
...
System.out.println("MyModelConstructor.class + shallowSizeOf:" + org.apache.lucene.util.RamUsageEstimator.shallowSizeOf(req.adaptTo(MyModelConstructor.class)));

MyModelConstructor.class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

package com.sourcedcode.core.models;

import lombok.Getter;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.ScriptVariable;
import org.apache.sling.models.annotations.injectorspecific.SlingObject;

import javax.inject.Inject;
import javax.inject.Named;

@Model(adaptables = {SlingHttpServletRequest.class, Resource.class}, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class MyModelConstructor {

@Getter
private String currentResourcePath;

@Getter
private String currentPagePagePath;

@Getter
private String requestParam;

@Inject
public MyModelConstructor(
@ScriptVariable @Named("currentPage") final com.day.cq.wcm.api.Page currentPage,
@ScriptVariable @Named("resource") final Resource resource,
@SlingObject @Named("slingHttpServletRequest") final SlingHttpServletRequest slingHttpServletRequest
) {
currentResourcePath = resource.getPath();
currentPagePagePath = currentPage.getPath();
requestParam = slingHttpServletRequest.getParameter("myParam");
}
}

Conclusion

An AEM object that has been field injected into a variable that is only being minimally used holds onto memory which will/can be be wasting resources. If AEM objects are not needed, then the Constructor Injection method can be appropriately used.

It’s not rocket science. We see the results! Test 2 has less instance variables than Test 1; of course Test 2 will have a smaller Object (in byte size) than Test 1.

My only recommendation is this. When you are using AEM Objects, ask yourself, how is this Object being used?

This article highlights why Sling Model Constructor Injection via constructor is useful in our AEM development.

The post AEM Sling Model Field Injection vs Constructor Injection Memory Consumption appeared first on Sourced Code.

AEM Sling Model Injectors Annotations Cheat Sheet Reference Guide

briankasingli — Sat, 04 Jan 2020 15:20:37 +0000

The Apache Sling Model enables injector specific annotations which aggregate the standard annotations for each of the available injector, which are: Script Bindings, Value Map, Resource Path, Child Resources, Request Attributes, OSGI Services, Self, and the Sling Object.

Sure we can invoke injectors by the @inject, followed by the @source annotation (with an injector name) as so, @Inject @Source(“script-bindings”), but invoking such injectors introduces many more lines of code which is tedious and repetitive. Using the @inject annotation freely may cause injector collisions.

Thankfully Apache’s Sling Model library delivered the injector specific annotations!
The injector specific annotations enable us, developers, to write less code, enables stability with injectors to demise injector collisions, and enables better IDE support.

This article will provide examples (used in practice) which will include both ways to invoke injectors in Sling Models, using the @Inject & @Source annotations, and also the Apache Sling Model injector specific annotations approach.

1. Script Bindings (name=”script-bindings”) Injector

Service Ranking: 1000
Annotation: @ScriptVariable
Description: Injects objects via script variable defined from Sling Bindings; Lookup objects in the script bindings object by name.

As you can see, the example below indicated that there are many ways to inject within the POJO:

Without the injector specific annotations:

1. @Inject @Source(“script-bindings”) @Named(“component”)
2. @Inject @Source(“script-bindings”)

With the injector specific annotations:

3. @ScriptVariable(name = “component”)
4. @ScriptVariable

Note: If the name is not set (using the @Named annotation or name property), then the name is derived from the method/property/variable/field name.

A full list of the scripting variables can be found here.

@Model(adaptables = {Resource.class, SlingHttpServletRequest.class},
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleComponent {

// @Inject @Source("script-bindings") @Named("component")
// @Inject @Source("script-bindings")
// @ScriptVariable(name = "component")
@ScriptVariable
private Component component;

// @Inject @Source("script-bindings") @Named("componentContext")
// @Inject @Source("script-bindings")
@ScriptVariable
private ComponentContext componentContext;

// @Inject @Source("script-bindings") @Named("currentDesign")
// @Inject @Source("script-bindings")
@ScriptVariable
private Design currentDesign;

// @Inject @Source("script-bindings") @Named("currentNode")
// @Inject @Source("script-bindings")
@ScriptVariable
private Node currentNode;

// @Inject @Source("script-bindings") @Named("currentPage")
// @Inject @Source("script-bindings")
@ScriptVariable
private Page currentPage;

// @Inject @Source("script-bindings") @Named("currentSession")
// @Inject @Source("script-bindings")
@ScriptVariable
private HttpSession currentSession;

// @Inject @Source("script-bindings") @Named("currentStyle")
// @Inject @Source("script-bindings")
@ScriptVariable
private Style currentStyle;

// @Inject @Source("script-bindings") @Named("designer")
// @Inject @Source("script-bindings")
@ScriptVariable
private Designer designer;

// @Inject @Source("script-bindings") @Named("editContext")
// @Inject @Source("script-bindings")
@ScriptVariable
private EditContext editContext;

// @Inject @Source("script-bindings") @Named("log")
// @Inject @Source("script-bindings")
@ScriptVariable
private Logger log;

// @Inject @Source("script-bindings") @Named("out")
// @Inject @Source("script-bindings")
@ScriptVariable
private PrintWriter out;

// @Inject @Source("script-bindings") @Named("pageManager")
// @Inject @Source("script-bindings")
@ScriptVariable
private PageManager pageManager;

// @Inject @Source("script-bindings") @Named("pageProperties")
// @Inject @Source("script-bindings")
@ScriptVariable
private ValueMap pageProperties;

// @Inject @Source("script-bindings") @Named("reader")
// @Inject @Source("script-bindings")
@ScriptVariable
private BufferedReader reader;

// @Inject @Source("script-bindings") @Named("request")
// @Inject @Source("script-bindings")
@ScriptVariable
private SlingHttpServletRequest request;

// @Inject @Source("script-bindings") @Named("resolver")
// @Inject @Source("script-bindings")
@ScriptVariable
private ResourceResolver resolver;

// @Inject @Source("script-bindings") @Named("resource")
// @Inject @Source("script-bindings")
@ScriptVariable
private Resource resource;

// @Inject @Source("script-bindings") @Named("resourceDesign")
// @Inject @Source("script-bindings")
@ScriptVariable
private Design resourceDesign;

// @Inject @Source("script-bindings") @Named("resourcePage")
// @Inject @Source("script-bindings")
@ScriptVariable
private Page resourcePage;

// @Inject @Source("script-bindings") @Named("response")
// @Inject @Source("script-bindings")
@ScriptVariable
private SlingHttpServletResponse response;

// @Inject @Source("script-bindings") @Named("sling")
// @Inject @Source("script-bindings")
@ScriptVariable
private SlingScriptHelper sling;

// @Inject @Source("script-bindings") @Named("slyWcmHelper")
// @Inject @Source("script-bindings")
@ScriptVariable
private WCMScriptHelper slyWcmHelper;

// @Inject @Source("script-bindings") @Named("wcmmode")
// @Inject @Source("script-bindings")
@ScriptVariable
private SightlyWCMMode wcmmode;

// @Inject @Source("script-bindings") @Named("xssAPI")
// @Inject @Source("script-bindings")
@ScriptVariable
private XSSAPI xssAPI;
}

2. Value Map (name=”valuemap”) Injector

Service Ranking: 2000
Annotation: @ValueMapValue
Description: Gets a property from a ValueMap by name; If @Via is not set, it will automatically take resource if the adaptable is the SlingHttpServletRequest. If name is not set the name is derived from the method/field name.

1
2
3
4
5
6
7
8
9
10
11
12

@Model(adaptables = SlingHttpServletRequest.class,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleComponent {

// @Inject @Source("valuemap") @Named("jcr:title")
@ValueMapValue(name = "jcr:title")
private String titleText;

// @Inject @Source("valuemap")
@ValueMapValue
private String titleDescription;
}

3. Resource Path (name=”resource-path”) Injector

Service Ranking: 2500
Annotation: @ResourcePath
Description: Injects one or multiple resources. The resource paths are either given by @Path annotations, the element path or paths of the annotation @ResourcePath or by paths given through a resource property being referenced by either @Named or element name of the annotation @ResourcePath.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Model(adaptables = Resource.class,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleComponent {

// @Inject @Source("resource-path") @Path("/content/sourcedcode/en/home")
@ResourcePath(path = "/content/sourcedcode/en/home")
Resource sourcedCodePageResource;

// @Inject @Source("resource-path") @Path("/content/we-retail/language-masters/en")
@ResourcePath(name = "/content/we-retail/language-masters/en")
Resource weRetailPageResource;

// @Inject @Source("resource-path") @Path(paths = {"/content/sourcedcode/en/home","/content/we-retail/language-masters/en"})
@ResourcePath(paths = {"/content/sourcedcode/en/home","/content/we-retail/language-masters/en"})
Resource[] resources;
}

4. Child Resources (name=”child-resources”) Injector

Service Ranking: 3000
Annotation: @ChildResource
Description: Gets a child resource by name.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

@Model(adaptables = Resource.class,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleComponent {

// @Inject @Source("child-resources") @Named("links")
// @ChildResource(name="links")
@ChildResource
private Resource links;

// @Inject @Source("child-resources") @Named("links")
// @ChildResource(name="links")
@ChildResource
private List<Resource> links;

// @Inject @Source("child-resources") @Named("social")
// @ChildResource(name="social")
@ChildResource
private Resource social;
}

5. Request Attributes (name=”request-attributes”) Injector

Service Ranking: 4000
Annotation: @RequestAttribute
Description: Injects a request attribute by name. If name is not set the name is derived from the method/field name.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@Model(adaptables = SlingHttpServletRequest.class,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleComponent {

// @Inject @Source("request-attributes") @Named("social")
@RequestAttribute(name = "social")
private String socialParam;

// @Inject @Source("request-attributes") @Named("link")
// @RequestAttribute(name = "link")
@RequestAttribute
private String link;

public String getSocialParam() {
return socialParam;
}

public String getLink() {
return link;
}
}

The example below calls the Sling Model using input parameter:

1
2
3
4

="${'com.sourcedcode.core.models.ExampleComponent' @ social=currentPage.title,link=currentPage.path}">
${example.socialParam}
${example.link}
</sly>

A really great example of the use of this annotation can be found in this article.

6. OSGi Services (name=”osgi-services”) Injector

Service Ranking: 5000
Annotation: @OSGiService
Description: Injects an OSGi service by type; Lookup services based on class name. Since Sling Models Impl 1.2.8 (SLING-5664) the service with the highest service ranking is returned. In case multiple services are returned, they are ordered descending by their service ranking (i.e. the one with the highest ranking first).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Model(adaptables = Resource.class,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleComponent {

// @Inject @Source("osgi-services")
@OSGiService
private SlingSettingsService slingSettingsService;

// @Inject @Source("osgi-services")
@OSGiService
private MyCustomOSGIService myCustomOSGIService;

// @Inject @Source("osgi-services")
@OSGiService
private MyCustomOSGISConfigurationervice myCustomOSGISConfigurationervice;
}

7. Self (name=”self”) Injector

Service Ranking: Integer.MAX_VALUE
Annotation: @Self
Description: Injects the adaptable object itself (if the class of the field matches or is a supertype). If the @Self annotation is present it is tried to adapt the adaptable to the field type.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

@Model(adaptables = Resource.class,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleComponent {

// @Inject @Source("self")
@Self
private Node node;

// @Inject @Source("self")
@Self
private MyCustomSlingModel myCustomSlingModel;
}

///////
///////
/////// Example below highlights that the @self annotation can minimize the lines of code that needs to be written.
///////
///////
@Model(adaptables = Resource.class,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleComponent {

@SlingObject
private Resource currentResource;

Node node;

@PostConstruct
public void init() {
// adapts the current resource to a node class
node = currentResource.adaptTo(Node.class);
}
}

8. Sling Object (name=”sling-object”) Injector

Service Ranking: Integer.MAX_VALUE
Annotation: @SlingObject
Description: Injects commonly used sling objects if the field matches with the class: request, response, resource resolver, current resource, SlingScriptHelper. This works only if the adaptable can get the according information, i.e. all objects are available via SlingHttpServletRequest while ResourceResolver can only resolve the ResourceResolver object and nothing else. A discussion around this limitation can be found at SLING-4083. Also Resources can only be injected if the according injector specific annotation is used (@SlingObject).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@Model(adaptables = Resource.class,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleComponent {

// @Inject @Source("sling-object")
@SlingObject
private SlingHttpServletRequest slingHttpServletRequest;

// @Inject @Source("sling-object")
@SlingObject
private SlingHttpServletResponse slingHttpServletResponse;

// @Inject @Source("sling-object")
@SlingObject
private Resource currentResource;

// @Inject @Source("sling-object")
@SlingObject
private ResourceResolver resourceResolver;

}

Note:
If the name is not set (using the @Named annotation or name property), then the name is derived from the method/property/variable/field name. An example for setting the @Named annotation would time you as a developer encounter a clash between the method/property/variable/field name or when developer not wanting to use the scripting variable names as the variables in the POJO.

As you can see, using the Apache Sling Model’s injector specific annotations during implementation will help you stay organised, write less code, and speed up the development process.

The post AEM Sling Model Injectors Annotations Cheat Sheet Reference Guide appeared first on Sourced Code.

AEM Sling Models Injectors Service Ranking

briankasingli — Thu, 02 Jan 2020 14:01:20 +0000

When working on an AEM project, Sling Models provides several custom Sling Models injectors to aid injection of Sling objects, Sling object values, OSGI services, etc…

While using the injectors within in Sling Models, how do injectors invoke in order? Injectors are invoked in order, of their service ranking, from lowest to highest. If you are writing a custom injector, it is good practice to include service ranking.

Examples of the common injectors and their service ranking from the Apache Sling Models availiable injectors, injector-specific annotations, list (since version 1.1.0):

@ScriptVariable, 1000
@ValueMapValue, 2000
@ChildResource, 3000
@RequestAttribute, 4000
@ResourcePath, 2500
@OSGiService, 5000
@Self, 2147483647 (Integer.MAX_VALUE)
@SlingObject, 2147483647 (Integer.MAX_VALUE)

Example of the @OSGIService, injector:

An example below illustrates the @OSGIService, injector specific annotation, which here we understand that the Service Ranking is set to 5000.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information...
*/
package org.apache.sling.models.impl.injectors;

import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Array;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.apache.sling.models.annotations.Filter;
import org.apache.sling.models.annotations.injectorspecific.InjectionStrategy;
import org.apache.sling.models.annotations.injectorspecific.OSGiService;
import org.apache.sling.models.spi.AcceptsNullName;
import org.apache.sling.models.spi.DisposalCallback;
import org.apache.sling.models.spi.DisposalCallbackRegistry;
import org.apache.sling.models.spi.Injector;
import org.apache.sling.models.spi.injectorspecific.AbstractInjectAnnotationProcessor2;
import org.apache.sling.models.spi.injectorspecific.InjectAnnotationProcessor2;
import org.apache.sling.models.spi.injectorspecific.StaticInjectAnnotationProcessorFactory;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component(property=Constants.SERVICE_RANKING+":Integer=5000", service={Injector.class, StaticInjectAnnotationProcessorFactory.class, AcceptsNullName.class})
public class OSGiServiceInjector implements Injector, StaticInjectAnnotationProcessorFactory, AcceptsNullName {

private static final Logger log = LoggerFactory.getLogger(OSGiServiceInjector.class);

private BundleContext bundleContext;

@Override
public @NotNull String getName() {
return "osgi-services";
}

@Activate
public void activate(BundleContext ctx) {
this.bundleContext = ctx;
}

@Override
public Object getValue(@NotNull Object adaptable, String name, @NotNull Type type, @NotNull AnnotatedElement element,
@NotNull DisposalCallbackRegistry callbackRegistry) {
return getValue(adaptable, name, type, element, callbackRegistry, bundleContext);
}

/**
*
* @param adaptable
* @param name
* @param type
* @param element
* @param callbackRegistry
* @param modelContext
* @return
*/
public Object getValue(@NotNull Object adaptable, String name, @NotNull Type type, @NotNull AnnotatedElement element,
@NotNull DisposalCallbackRegistry callbackRegistry, @Nullable BundleContext modelContext) {
OSGiService annotation = element.getAnnotation(OSGiService.class);
String filterString = null;
if (annotation != null) {
if (StringUtils.isNotBlank(annotation.filter())) {
filterString = annotation.filter();
}
} else {
Filter filter = element.getAnnotation(Filter.class);
if (filter != null) {
filterString = filter.value();
}
}
return getValue(adaptable, type, filterString, callbackRegistry, modelContext == null ? bundleContext : modelContext);
}

private <T> Object getService(Object adaptable, Class<T> type, String filter,
DisposalCallbackRegistry callbackRegistry, BundleContext modelContext) {
// cannot use SlingScriptHelper since it does not support ordering by service ranking due to https://issues.apache.org/jira/browse/SLING-5665
try {
ServiceReference[] refs = modelContext.getServiceReferences(type.getName(), filter);
if (refs == null || refs.length == 0) {
return null;
} else {
// sort by service ranking (lowest first) (see ServiceReference.compareTo)
List<ServiceReference> references = Arrays.asList(refs);
Collections.sort(references);
callbackRegistry.addDisposalCallback(new Callback(refs, modelContext));
return modelContext.getService(references.get(references.size() - 1));
}
} catch (InvalidSyntaxException e) {
log.error("invalid filter expression", e);
return null;
}
}

private <T> Object[] getServices(Object adaptable, Class<T> type, String filter,
DisposalCallbackRegistry callbackRegistry, BundleContext modelContext) {
// cannot use SlingScriptHelper since it does not support ordering by service ranking due to https://issues.apache.org/jira/browse/SLING-5665
try {
ServiceReference[] refs = modelContext.getServiceReferences(type.getName(), filter);
if (refs == null || refs.length == 0) {
return null;
} else {
// sort by service ranking (lowest first) (see ServiceReference.compareTo)
List<ServiceReference> references = Arrays.asList(refs);
Collections.sort(references);
// make highest service ranking being returned first
Collections.reverse(references);
callbackRegistry.addDisposalCallback(new Callback(refs, modelContext));
List<Object> services = new ArrayList<>();
for (ServiceReference ref : references) {
Object service = modelContext.getService(ref);
if (service != null) {
services.add(service);
}
}
return services.toArray();
}
} catch (InvalidSyntaxException e) {
log.error("invalid filter expression", e);
return null;
}
}

private Object getValue(Object adaptable, Type type, String filterString, DisposalCallbackRegistry callbackRegistry,
BundleContext modelContext) {
if (type instanceof Class) {
Class injectedClass = (Class) type;
if (injectedClass.isArray()) {
Object[] services = getServices(adaptable, injectedClass.getComponentType(), filterString,
callbackRegistry, modelContext);
if (services == null) {
return null;
}
Object arr = Array.newInstance(injectedClass.getComponentType(), services.length);
for (int i = 0; i < services.length; i++) {
Array.set(arr, i, services[i]);
}
return arr;
} else {
return getService(adaptable, injectedClass, filterString, callbackRegistry, modelContext);
}
} else if (type instanceof ParameterizedType) {
ParameterizedType ptype = (ParameterizedType) type;
if (ptype.getActualTypeArguments().length != 1) {
return null;
}
Class collectionType = (Class) ptype.getRawType();
if (!(collectionType.equals(Collection.class) || collectionType.equals(List.class))) {
return null;
}

Class serviceType = (Class) ptype.getActualTypeArguments()[0];
Object[] services = getServices(adaptable, serviceType, filterString, callbackRegistry, modelContext);
if (services == null) {
return null;
}
return Arrays.asList(services);
} else {
log.warn("Cannot handle type {}", type);
return null;
}
}

private static class Callback implements DisposalCallback {
private final ServiceReference[] refs;
private final BundleContext context;

public Callback(ServiceReference[] refs, BundleContext context) {
this.refs = refs;
this.context = context;
}

@Override
public void onDisposed() {
if (refs != null) {
for (ServiceReference ref : refs) {
context.ungetService(ref);
}
}
}
}

@Override
public InjectAnnotationProcessor2 createAnnotationProcessor(AnnotatedElement element) {
// check if the element has the expected annotation
OSGiService annotation = element.getAnnotation(OSGiService.class);
if (annotation != null) {
return new OSGiServiceAnnotationProcessor(annotation);
}
return null;
}

private static class OSGiServiceAnnotationProcessor extends AbstractInjectAnnotationProcessor2 {

private final OSGiService annotation;

public OSGiServiceAnnotationProcessor(OSGiService annotation) {
this.annotation = annotation;
}

@Override
public InjectionStrategy getInjectionStrategy() {
return annotation.injectionStrategy();
}

@Override
@SuppressWarnings("deprecation")
public Boolean isOptional() {
return annotation.optional();
}
}
}

The source code can be found from the Github repository, Apache Sling Models Implementation, here.
The official documentation for the Sling Models available injector’s service ranking status can be found here.

The post AEM Sling Models Injectors Service Ranking appeared first on Sourced Code.

JUnit 4: AEM Sling Servlet Unit Test Example Using wcm.io AEM Mocks, Servlet by Resource Type

briankasingli — Sat, 21 Dec 2019 17:34:23 +0000

This article will demonstrate how to write AEM Unit tests for @SlingServletResourceTypes (OSGi DS 1.4 (R7) component property type annotations) using the Junit4 testing framework. With developers being more visual, the source code is posted below.

Technologies here used are:

AEM project archetype 19 (link)
Mockito 2.27.0 (link)
AEM Mocks JUnit 4 2.7.2 (link)

Using OSGI R7 annotations for your AEM project requires some additional dependencies. Check out Adobe’s guide to enable OSGI R7 annotations.

Test Framework Dependencies

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Sling Servlet Resource Types Class : SlingServletResourceTypes.class

package com.sourcedcode.core.servlets;

import com.day.cq.wcm.api.Page;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.servlets.SlingSafeMethodsServlet;
import org.apache.sling.servlets.annotations.SlingServletResourceTypes;
import org.osgi.service.component.annotations.Component;

import javax.servlet.Servlet;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import static com.day.crx.packaging.JSONResponse.APPLICATION_JSON_UTF8;
import static org.apache.sling.api.servlets.HttpConstants.METHOD_GET;

/**
* A demonstration sling servlet resource type class to demonstrate unit testing.
* Appending ".example.json" on any resource will activate the doGet() method below, and return Json data.
* Json Data returned is data from the immediate children of the "/content/we-retail', parent resource node.
*/
@Component(service = Servlet.class)
@SlingServletResourceTypes(
resourceTypes = "sling/servlet/default",
methods = METHOD_GET,
extensions = "json",
selectors = "example")
public class SlingServletResourceTypesExampleDS14Servlet extends SlingSafeMethodsServlet {

@Override
protected void doGet(SlingHttpServletRequest req, SlingHttpServletResponse res) throws IOException {
res.setContentType(APPLICATION_JSON_UTF8);
res.setStatus(SlingHttpServletResponse.SC_OK);
List<PageItem> pageItems = getPageItems(req);
String json = new ObjectMapper().writeValueAsString(pageItems);
res.getWriter().write(json);
}

private List<PageItem> getPageItems(SlingHttpServletRequest req) {
List<PageItem> pageItems = new ArrayList<>();
ResourceResolver resolver = req.getResourceResolver();
Resource weRetail = resolver.getResource("/content/we-retail");
if (weRetail != null) {
Iterator<Resource> it = weRetail.listChildren();
while (it.hasNext()) {
Resource resource = it.next();
if (resource.getResourceType().equalsIgnoreCase(com.day.cq.wcm.api.NameConstants.NT_PAGE)) {
Page page = resource.adaptTo(Page.class);
if (page != null) {
pageItems.add((new PageItem(page.getTitle(), resource.getPath())));
}
}
}
}
return pageItems;
}

/**
* Inner class PageItem, for creating PageItem objects.
*/
public class PageItem {

private String pageTitle;

private String pagePath;

PageItem(String pageTitle, String pagePath) {
this.pageTitle = pageTitle;
this.pagePath = pagePath;
}

public String getPageTitle() {
return pageTitle;
}

public String getPagePath() {
return pagePath;
}
}
}

Results of the output from the working as expected SlingServletResourceTypesTest.class.

Sling Servlet Resource Types Test Class : SlingServletResourceTypesTest.class

package com.sourcedcode.core.servlets;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.wcm.testing.mock.aem.junit.AemContext;
import org.apache.sling.testing.mock.sling.ResourceResolverType;
import org.apache.sling.testing.mock.sling.servlet.MockSlingHttpServletRequest;
import org.apache.sling.testing.mock.sling.servlet.MockSlingHttpServletResponse;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import java.io.IOException;

import static com.day.crx.packaging.JSONResponse.APPLICATION_JSON_UTF8;
import static junitx.framework.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

@RunWith(MockitoJUnitRunner.class)
public class SlingServletResourceTypesExampleDS14ServletTest {

@Rule
public final AemContext context = new AemContext(ResourceResolverType.JCR_MOCK);

@Mock
private MockSlingHttpServletRequest req;

@Mock
private MockSlingHttpServletResponse res;

@InjectMocks
private SlingServletResourceTypesExampleDS14Servlet underTest;

@Before
public void setup() {
underTest = new SlingServletResourceTypesExampleDS14Servlet();
req = context.request();
res = context.response();
}

@Test
public void doGet_shouldReturnHeaderAsExpected() throws IOException {
underTest.doGet(req, res);
assertEquals(res.getContentType(), APPLICATION_JSON_UTF8);
}

@Test
public void doGet_shouldReturnPageItemListJsonAsExpected_0() throws IOException {
underTest.doGet(req, res);
String jsonString = res.getOutputAsString();
ObjectMapper mapper = new ObjectMapper();
JsonNode actualObj = mapper.readTree(jsonString);
assertEquals(0, actualObj.size());
}

@Test
public void doGet_shouldReturnPageItemJsonAsExpected_properties_values() throws IOException {
createPagesInJcrMock();
underTest.doGet(req, res);
String jsonString = res.getOutputAsString();
ObjectMapper mapper = new ObjectMapper();
JsonNode actualObj = mapper.readTree(jsonString);
JsonNode firstItem = actualObj.get(0);
assertTrue(firstItem.has("pageTitle"));
assertTrue(firstItem.has("pagePath"));
assertEquals( "United states", firstItem.get("pageTitle").textValue());
assertEquals("/content/we-retail/us", firstItem.get("pagePath").textValue());
}

/**
* Test helper method to create 3 pages in the on-memory JCR Mock instance.
*/
private void createPagesInJcrMock() {
context.create().page("/content/we-retail", "/", "We Retail");
context.create().page("/content/we-retail/us", "/", "United states");
context.create().page("/content/we-retail/ca", "/", "Canada");
}
}

Last Thoughts:
Though the endpoint path is ugly (because it consists of extensions, selectors, and etc…), it is recomended to register servlet by resource types rather than by path (click here to learn why @SlingServletPaths, register by path, are not recommended).

If there is a requirement to mask or to sugarcoat the ugly URI paths, a common strategy used is the Apache webserver. Click here to learn to sugar coat registered AEM servlet scripts and paths endpoint.

The post JUnit 4: AEM Sling Servlet Unit Test Example Using wcm.io AEM Mocks, Servlet by Resource Type appeared first on Sourced Code.

JUnit 4: AEM Sling Models Unit Test Example Using wcm.io AEM Mocks

briankasingli — Mon, 27 May 2019 12:31:40 +0000

Creating new AEM components, we sometimes need backend logic to compute user requests with business logic. There are multiple ways of doing so, like using the Java-Use API or Javascript-Use API, but the most popular and best practice of writing business logic for an AEM component will be using Sling Models.

This article will demonstrate how to write AEM Unit tests for sling models using the Junit4 testing framework. With developers being more visual, the source code is posted below.

Technologies here used are:

AEM project archetype 19 (link)
Mockito 2.27.0 (link)
AEM Mocks JUnit 4 2.7.2 (link)

Dependencies

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Sling Model Class : Header.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

package com.sourcedcode.core.models;

import com.day.cq.wcm.api.Page;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.ChildResource;
import org.apache.sling.models.annotations.injectorspecific.ScriptVariable;
import org.apache.sling.models.annotations.injectorspecific.ValueMapValue;

import javax.annotation.PostConstruct;
import javax.inject.Inject;

@Model(adaptables = Resource.class,
resourceType = Header.RESOURCE_TYPE,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class Header {

protected static final String RESOURCE_TYPE = "sourcedcode/components/structure/header";

@ValueMapValue
private String contactUsPath;

@ScriptVariable(name="currentPage")
private Page currentPage;

@ChildResource(name="link")
Resource childResource;

@SlingObject
private ResourceResolver resolver;

private String contactUsPageSecretChar;

@PostConstruct
public void init() {
setContactUsPageSecretChar();
}

private void setContactUsPageSecretChar() {
Resource resource = resolver.getResource(contactUsPath);
if (resource != null) {
Page contactUsPage = resource.adaptTo(Page.class);
contactUsPageSecretChar = contactUsPage.getTitle();
}
}

public String getContactUsPageSecretChar() {
return contactUsPageSecretChar.substring(contactUsPageSecretChar.length() - 1);
}

// demo of testing the @ScriptVariable("currentPage") annotation
public String getPageTitle() {
return currentPage.getPageTitle();
}

// demo of testing the @ChildResource annotation
public String getChildLinkPropFlag() {
return childResource.getValueMap().get("flag", "");
}
}

Sling Model Test Class : HeaderTest.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

package com.sourcedcode.core.models;

import com.adobe.cq.commerce.common.ValueMapDecorator;
import com.day.cq.wcm.api.Page;
import com.google.common.collect.ImmutableMap;
import io.wcm.testing.mock.aem.junit.AemContext;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.testing.mock.sling.ResourceResolverType;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import static junitx.framework.Assert.assertEquals;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class HeaderTest {

@Rule
public final AemContext context = new AemContext(ResourceResolverType.JCR_MOCK);

// the context.resourceResolver() is auto injected by the AemContext, cannot be mocked.
// ResourceResolver resolver;

// mocking the global AEM object "currentPage".
// variable does not need to match the variables in the underTest.class
@Mock
private Page currentPage;

// injects all the mocks into the tested object.
@InjectMocks
private Header underTest;

@Test
public void itShouldReturnTheCorrectSecretCharWhenResourceExist() {
// using the AEM context to create an AEM resource in the context, to set properties for the resource.
// the resource path can be anything made up.
Resource headerResourceContext = context.create().resource("/content/sourcedcode/home/jcr:content/header", new ValueMapDecorator(ImmutableMap.<String, Object> of(
"contactUsPath", "/content/sourcedcode/contact",
"anotherProperty", "example")));

// create mock page, resolved by the resolver.
context.create().page("/content/sourcedcode/contact", "", ImmutableMap.<String, Object>builder()
.put("jcr:title", "Contact Us Page")
.build());

underTest = headerResourceContext.adaptTo(Header.class);
assertEquals("e", underTest.getContactUsPageSecretChar());
}

@Test
public void itShouldReturnTheCorrectCurrentPageTitle() {
when(currentPage.getPageTitle()).thenReturn("Home Page");
assertEquals("Home Page", underTest.getPageTitle());
}

@Test
public void itShouldReturnTheCorrectChildLinkProperty() {
context.build().resource("/content/sourcedcode/home/jcr:content/header")
.siblingsMode()
.resource("link", "flag", "newPage");
underTest = context.resourceResolver().getResource("/content/sourcedcode/home/jcr:content/header").adaptTo(Header.class);
assertEquals("newPage", underTest.getChildLinkPropFlag());
}

}

Common Questions for Writing Test Code for Sling Models

How do I initial properties in my sling model object? First, ensure that your sling model allows a resource.class to be adaptable, then in your sling model test class, create a mockResource object, setup up the mockResource object, and adapt to the sling model class that you are trying to test.
Which Context should I be used when testing for sling models? You should use the JCR_MOCK context.

For AEM Sling Servlet by Resource Type, Unit Test Example Using wcm.io AEM Mocks, click here.

The post JUnit 4: AEM Sling Models Unit Test Example Using wcm.io AEM Mocks appeared first on Sourced Code.