AEM From The Middle of the World

Maven Plugin Changes

1. Setup POM properties to include Description and URL properties. This properties will be used later by a maven plugin.

2. Setup the maven-bundle-plugin to the taglib project POM file.

The plugin will contain information like the export package (com.myproject.taglib.*).

3. Setup the maven jsptld-maven-plugin to the taglib project POM file. This will allow the plugin to look for tag annotations and it will automatically generate the TLD information based on that.

Maven dependencies

Now let’s review the maven dependencies I've used to setup tag libraries.

The libraries that I normally include are:

squeakysand-jcr-taglib :  A JSP taglib for working with JCR resources in a Servlet environment.

squeakysand-jsp :  Classes and annotations for working with JSP technologies.

squeakysand-sling-taglib :  Resources for working with Apache Sling from a Java Servlet environment.

Our project is ready, now we can start coding our classes that will become on custom tags and part of our custom tag library.

First you will have to create a Java project that later will be deployed into OSGI as a bundle. This bundle will have the Sling Model packages.

The POM of this project needs to have the maven-bundle-plugin declaration like in the following screenshot.

The <Sling-Model-Packages>section is very important. This will let OSGI know that the package path described there contains Sling Models classes/interfaces, and it will scan through it looking for the annotations. PLEASE don’t skip these plugin lines otherwise your models might not be mapped correctly.

SLING Model Interface or Class

Now you are ready to create models either using classes or interfaces. There are several annotations that will help you on this setup. The most common annotations are:

@Model Used to specify that the class represents a Sling Model.

@Inject Used to specify that a property represents a resource property.

Note: There are several others annotations and variations for Sling Models that might suite for different needs.

On my test case I've declared a UserInfo interface with two properties. The properties will be injected using the getter declarations.

import org.apache.sling.models.annotations.Model; import org.apache.sling.api.resource.Resource; import javax.inject.Inject; @Model(adaptables=Resource.class) public interface IUserInfo { @Inject String getFirstName(); @Inject String getLastName(); }

Testing Servlet

Now that we have our Sling Model ready, we just need to test it, for this I've created a simple servlet that pulls the resource and adapts it to our Sling Model.

The test Servlet will pull the resource by using the resource resolver:

Resource resource = resourceResolver.getResource("/content/myrpoject/en/test-sling/jcr:content/par/slingmodel");

Then you just need to adaptTo the resource to the specific Sling Model.

IUserInfo userInfo = resource.adaptTo(IUserInfo.class);

Then you can just print the different properties using the userInfo object.

Same thing you can do in an AEM component JSP, you just need to adapt the resource to the Sling Model.

The feature that I used at first was the “Multi Field Panel”. This feature is inside the “Custom Widgets and Validators” section.

I am pretty sure you as a developer have faced the need to create a multifield property that contains more than one type of fields.

The traditional way to workaround this requirement is to create a custom widget. This for sure take some time, plus it might very complex to maintain it and reuse it for multiple purposes.

Now, with the AEM Commons tools, this requirement and necessity is covered. The field to be used is multifieldpanel. It will store the content in a json string. The tools also offer a custom tag to read this property.

“The multifieldpanel widget is a widget which enables the management of complex items in a traditional multifield. These complex items are composed of multiple widgets.“

JSON:

{"term":"term","definition":"a word or phrase used to describe a thing"}

Custom tag:

<%@ taglib prefix="widgets" uri="http://www.adobe.com/consulting/acs-aem-commons/widgets" %><c:set var="definitions" value="${widgets:getMultiFieldPanelValues(resource, 'definitions')}"/>

Iteration:

The value stored in definitions is a List of Maps. List<Map<String, String>>.

<c:forEach items="${definitions}" var="definition">     <dt>${definition['term']}</dt>     <dd>${definition['definition']}</dt> </c:forEach>

According to me, the hardware requirements to run AEM on a local development environment without feeling slowness and issues are:

8+ RAM

30GB+ HD available space

Java 1.6+

For default the AEM installation folder is the folder where the jar and license files are placed. This is why I recommend placing the jar on a structure similar to the following:

\..\..\cq\author\   for the author instance

\..\..\cq\publish\   for the publish instance

Naming the .jar file:

The name of the jar file is very important, the name contains information as the type of instance (author or publish) plus the port on which the instance will run.

The convention sets the following:

Default author port: 4502

Default publish port: 4503

If there is a cluster all author instances should start from 4502 and up skipping one. i.e. 4502, 4504, 4506, 4508, etc. Author instances are on even ports.

If there is a cluster all publish instances should start from 4503 and up skipping one. i.e. 4503, 4505, 4507, 4509, etc. Author instances are on odd ports.

With this said lets check an example of the jar file for an author instance.

cq56-author-4502.jar

cq56: the version of the instance.

author: the instance type.

4502: the port the instance will be running on. 

Running the instance:

To start AEM open up a command window/terminal and run the next command:

java -XX:MaxPermSize=512m -Xmx2048m -jar cq56-author-4502.jar -gui

The -gui param starts up a GUI interface. The GUI interface will let you know through a progress bar the status of the start up, and using the interface you will be able to stop the instance later.

Folder Structure:

After the instance has started up you will notice that a new folder has been created at the same level as the jar file. The folder name is 'crx-quickstart' and this folder contains the complete instance setup and instance content.

If you have followed this post, after starting up your local author instance, you will find your instance control panel at:

Anyway with some information from here and from there I was able to get a better general idea on how AEM works. This for sure helped me on the training days.

This is why a couple of years later, and some knowledge I've gain on AEM, I decided to start this blog and perhaps help developers go inside the AEM world.

If you are a developer who is starting on AEM, this post is for you.

These ideas might give you a better understanding on the CMS:

Adobe its the company that owns AEM.

AEM stands for Adobe Experience Manager.

AEM former name is CQ.

AEM is a Java based CMS.

It is an enterprise CMS.

Current version as of today, is AEM 6.

Perhaps for now the most popular version has been CQ 5.6.

AEM doesn't need a database to run. It uses a Java Content Repository (JCR).

The installer is a jar file. (I got it on my official training, not sure if there is some other way to get it as a developer).

AEM key principles: 

"Everything is content".

Data first, structure later (maybe).

Content hierarchy has to be really well thought.

Names should have a meaning. IDs are not for AEM ("IDs are evil").

References are not for AEM either. Referencial Integrity is the base principle for a relational database. And remember that AEM doesn't use a Database, it uses a Java Content Repository.

AEM rocks!

Before I finish this post I would like to give you a tip:

When I started on this CMS I always used to compare, on functionality terms, how things work between Sitecore and AEM. This really didn't help to make concepts clearer and cleaner. They are, or better said, AEM has very different concepts and approaches for templates, content, designs, etc. Please clear your mind in CMS concepts before starting to learn AEM.