Did you know you can create an RSS feed in AEM (Adobe Experience Manager) for external applications like Eloqua? While AEM provides out-of-the-box functionality for RSS feeds, customizing them may require additional steps. Below you’ll find several options for creating RSS feeds in AEM along with steps for creating one using HTL.
3 Options to Create an RSS Feed in AEM
- Override Default JSP Functionality (JSP Approach)
- Customize the JSP code to tailor the RSS feed according to your requirements
- This approach requires writing backend logic in Java and JSP
- Create a Servlet for RSS Feed
- Implement the logic within the servlet to fetch and format the necessary data into RSS feed XML
- Configure the servlet to respond to specific requests for the RSS feed endpoint
- This approach allows more control and flexibility over the RSS feed generation process
- Use HTL with Sling Model (HTL Approach)
- Write HTL templates combined with a Sling Model to generate the RSS feed
- Leverage Sling ****** to retrieve data from AEM and format it within the HTL template
- This approach utilizes AEM’s modern templating language and component ******
- HTL is preferred for templating tasks due to its simplicity and readability
Expected RSS Feed
Below is the feed response for an external source to integrate and send emails accordingly. Here the feed results can be filtered by category tag names (category) using query parameters in the feed URL.
- https://www.demoproject.com/products/aem.rss
<?xml version="1.0" encoding="UTF-8"?> <rss xmlns:atom=" version="2.0"> <channel> <atom:link rel="self" href=" /> <link> <title>AEM</title> <description /> <pubDate>Fri, 29 Sep 2023 02:08:26 +0000</pubDate> <item> <guid> <atom:link rel="self" href=" /> <link> <title>Aem Sites</title> <description><![CDATA[AEM Sites is the content management system within Adobe Experience Manager that gives you one place to create, manage and deliver remarkable digital experiences across websites, mobile sites and on-site screens.]]></description> <pubDate>Tue, 31 Oct 2023 02:23:04 +0000</pubDate> </item> <item> <guid> <atom:link rel="self" href=" /> <link> <title>Aem Assets</title> <description><![CDATA[Adobe Experience Manager (AEM) Assets is a digital asset management system (DAM) that is built into AEM. It stores and delivers a variety of assets (including images, videos, and documents) with their connected metadata in one secure location.]]></description> <pubDate>Thu, 26 Oct 2023 02:21:19 +0000</pubDate> <category>pdf,doc,image,web</category> </item> </channel> </rss>
Steps for Creating RSS Feed Using HTL
- Create a HTML file under the page component
- Create a PageFeed Sling Model that returns data for the RSS feed
- Add a rewrite rule in the dispatcher rewrite rules file
- Update the ignoreUrlParams for the required params
Page Component – RSS html
Create an HTML file with the name “rss.xml.html” under page component. Both ‘rss.html’ or ‘rss.xml.html’ work fine for this. Here, ‘rss.xml.html’ naming convention indicates that it is generating XML data. PageFeedModel provides the page JSON data for the expected feed.
- Category tag is rendered only when page properties are authored with tag values
- CDATA (character data) is a section of element content to render as only character data instead of markup
<?xml version="1.0" encoding="UTF-8"?>
<sly data-sly-use.model="com.demoproject.aem.core.******.PageFeedModel" />
<rss version="2.0" xmlns:atom=">
<channel>
<atom:link rel="self" href="
${model.linkTag @ context="unsafe"}
<title>${model.title}</title>
<description>${model.subTitle}</description>
<pubDate>${model.publishedDate}</pubDate>
<sly data-sly-list.childPage="${model.entries}">
<item>
<guid>${childPage.feedUrl}</guid>
<atom:link rel="self" href="${childPage.link}"/>
${childPage.linkTag @ context="unsafe"}
<title>${childPage.title}</title>
<description><![CDATA[${childPage.description}]]></description>
<pubDate>${childPage.publishedDate}</pubDate>
<sly data-sly-test="${childPage.tags}">
<category>${childPage.tags}</category>
</sly>
</item>
</sly>
</channel>
</rss>
Page Feed Model
This is a component model that takes the currentPage as the root and retrieves a list of its child pages. Subsequently, it dynamically constructs properties such as publish **** and categories based on the page’s tag field. These properties enable filtering of results based on query parameters. Once implemented, you can seamlessly integrate this model into your component to render the RSS feed.
- Using currentPage get the current page properties as a value map
- Retrieve title, description, pubDate, link for current page
- Retrieve title, description, pubDate, link, tags (categories) for child pages
- Filter the child pages list based on the query param value (category)
//PageFeedModel sample code
package com.demoproject.aem.core.******;
import com.adobe.cq.export.json.ExporterConstants;
import com.day.cq.commons.Externalizer;
import com.day.cq.commons.jcr.JcrConstants;
import com.day.cq.wcm.api.Page;
import com.day.cq.wcm.api.PageFilter;
import com.demoproject.aem.core.utility.RssFeedUtils;
import lombok.Getter;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.sling.api.SlingException;
import org.apache.sling.api.SlingHttpServletRequest;
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.******.annotations.DefaultInjectionStrategy;
import org.apache.sling.******.annotations.Exporter;
import org.apache.sling.******.annotations.Model;
import org.apache.sling.******.annotations.injectorspecific.SlingObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
@Model(adaptables = {
Resource.class,
SlingHttpServletRequest.class
}, resourceType = PageFeedModel.RESOURCE_TYPE, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
@Exporter(name = ExporterConstants.SLING_MODEL_EXPORTER_NAME, extensions = ExporterConstants.SLING_MODEL_EXTENSION)
public class PageFeedModel {
protected static final String RESOURCE_TYPE = "demoproject/components/page";
private static final Logger logger = LoggerFactory.getLogger(PageFeedModel.class);
@SlingObject
ResourceResolver resourceResolver;
@SlingObject
SlingHttpServletRequest request;
@Inject
private Page currentPage;
@Getter
private String title;
@Getter
private String link;
@Getter
private String linkTag;
@Getter
private String description;
@Getter
private List < ChildPageModel > entries;
@Inject
private Externalizer externalizer;
@Getter
private String feedUrl;
@Getter
private String publishedDate;
@PostConstruct
protected void init() {
try {
ValueMap properties = currentPage.getContentResource().adaptTo(ValueMap.class);
title = StringEscapeUtils.escapeXml(null != currentPage.getTitle() ? currentPage.getTitle() : properties.get(JcrConstants.JCR_TITLE, String.class));
description = StringEscapeUtils.escapeXml(properties.get(JcrConstants.JCR_DESCRIPTION, String.class));
link = RssFeedUtils.getExternaliseUrl(currentPage.getPath(), externalizer, resourceResolver);
feedUrl = link + ".rss.xml";
linkTag = RssFeedUtils.setLinkElements(link);
String category = request.getParameter("category") != null ? request.getParameter("category").toLowerCase().replaceAll("\\s", "") : StringUtils.EMPTY;
entries = new ArrayList < > ();
Iterator < Page > childPages = currentPage.listChildren(new PageFilter(false, false));
while (childPages.hasNext()) {
Page childPage = childPages.next();
ChildPageModel childPageModel = resourceResolver.getResource(childPage.getPath()).adaptTo(ChildPageModel.class);
if (null != childPageModel) {
if (StringUtils.isBlank(category)) entries.add(childPageModel);
else {
String tags = childPageModel.getTags();
if (StringUtils.isNotBlank(tags)) {
tags = tags.toLowerCase().replaceAll("\\s", "");
List tagsList = Arrays.asList(tags.split(","));
String[] categoryList = category.split(",");
boolean flag = true;
for (String categoryStr: categoryList) {
if (tagsList.contains(StringEscapeUtils.escapeXml(categoryStr)) && flag) {
entries.add(childPageModel);
flag = false;
}
}
}
}
}
}
publishedDate = RssFeedUtils.getPublishedDate(properties);
} catch (SlingException e) {
logger.error("Repository Exception {}", e);
}
}
}
//ChildPageModel
package com.demoproject.aem.core.******;
import com.adobe.cq.export.json.ExporterConstants;
import com.day.cq.commons.Externalizer;
import com.day.cq.commons.jcr.JcrConstants;
import com.demoproject.aem.core.utility.RssFeedUtils;
import lombok.Getter;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.sling.api.SlingException;
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.******.annotations.DefaultInjectionStrategy;
import org.apache.sling.******.annotations.Exporter;
import org.apache.sling.******.annotations.Model;
import org.apache.sling.******.annotations.injectorspecific.SlingObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
@Model(adaptables = {
Resource.class
}, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
@Exporter(name = ExporterConstants.SLING_MODEL_EXPORTER_NAME, extensions = ExporterConstants.SLING_MODEL_EXTENSION)
public class ChildPageModel {
private static final Logger logger = LoggerFactory.getLogger(ChildPageModel.class);
@SlingObject
Resource resource;
@Getter
private String title;
@Getter
private String link;
@Getter
private String linkTag;
@Getter
private String feedUrl;
@Getter
private String description;
@Getter
private String publishedDate;
@Getter
private String tags;
@Inject
private Externalizer externalizer;
@PostConstruct
protected void init() {
try {
if (null != resource) {
String url = resource.getPath();
ResourceResolver resourceResolver = resource.getResourceResolver();
link = RssFeedUtils.getExternaliseUrl(url, externalizer, resourceResolver);
feedUrl = link + ".rss.xml";
linkTag = RssFeedUtils.setLinkElements(link);
ValueMap properties = resource.getChild(JcrConstants.JCR_CONTENT).adaptTo(ValueMap.class);
title = StringEscapeUtils.escapeXml(properties.get(JcrConstants.JCR_TITLE, String.class));
description = StringEscapeUtils.escapeXml(properties.get(JcrConstants.JCR_DESCRIPTION, String.class));
publishedDate = RssFeedUtils.getPublishedDate(properties);
tags = StringEscapeUtils.escapeXml(RssFeedUtils.getPageTags(properties, resourceResolver));
}
} catch (SlingException e) {
logger.error("Error: " + e.getMessage());
}
}
}
//RSS Feed Utils
package com.demoproject.aem.core.utility;
import com.day.cq.commons.Externalizer;
import com.day.cq.commons.jcr.JcrConstants;
import com.day.cq.tagging.Tag;
import com.day.cq.tagging.TagManager;
import com.day.cq.wcm.api.NameConstants;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ValueMap;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.****;
import java.util.List;
/**
* @desc RSS Feed Utils
*/
@Slf4j
public class RssFeedUtils {
public static final String FORMAT_DATE = "E, dd MMM yyyy hh:mm:ss Z";
public static final String CONTENT_PATH = "/content/demoproject/us/en";
public static String getPublishedDate(ValueMap pageProperties) {
String publishedDate = StringUtils.EMPTY;
SimpleDateFormat dateFormat = new SimpleDateFormat(FORMAT_DATE);
**** updatedDateVal = pageProperties.get(JcrConstants.JCR_LASTMODIFIED, pageProperties.get(JcrConstants.JCR_CREATED, ****.class));
if (null != updatedDateVal) {
**** replicatedDate = pageProperties.get(NameConstants.PN_PAGE_LAST_REPLICATED, updatedDateVal);
publishedDate = dateFormat.format(replicatedDate);
}
return publishedDate;
}
public static String getExternaliseUrl(String pagePath, Externalizer externalizer, ResourceResolver resourceResolver) {
String url = StringUtils.EMPTY;
if (StringUtils.isNotBlank(pagePath) && null != externalizer && null != resourceResolver)
url = externalizer.publishLink(resourceResolver, resourceResolver.map(pagePath)).replace(CONTENT_PATH, "");
return url;
}
public static String setLinkElements(String link) {
String url = StringUtils.EMPTY;
if (StringUtils.isNotBlank(link)) {
url = "<link>" + link + "</link>";
}
return url;
}
public static String getPageTags(ValueMap properties, ResourceResolver resourceResolver) {
String tags = StringUtils.EMPTY;
String[] pageTags = properties.get(NameConstants.PN_TAGS, String[].class);
if (pageTags != null) {
List < String > tagList = new ArrayList < > ();
TagManager tagManager = resourceResolver.adaptTo(TagManager.class);
for (String tagStr: pageTags) {
Tag tag = tagManager.resolve(tagStr);
if (tag != null) {
tagList.add(tag.getName());
}
}
if (!tagList.isEmpty()) tags = String.join(",", tagList);
}
return tags;
}
}
Dispatcher Changes
demoproject_rewrites.rules
In the client project rewrites.rules (/src/conf.d/rewrites) file add a rewrite rule for .rss extension. This rewrite rule takes a URL ending with .rss and rewrites it to point to a corresponding rss.xml file in the page component, effectively changing the file extension from .rss to .rss.xml
#feed rewrite rule RewriteRule ^/(.*).rss$ /content/demoproject/us/en/$1.rss.xml [PT,L]
100_demoproject_dispatcher_farm.any
Set the URL parameters that should not be cached for the rss feed. It is recommended that you configure the ignoreUrlParams setting in an allowlist manner. As such, all query parameters are ignored and only known or expected query parameters are exempt (denied) from being ignored.
When a parameter is ignored for a page, the page is cached upon its initial request. As a result, the system subsequently serves requests for the page using the cached version, irrespective of the parameter’s value in the request. Here, we add URL parameters below to serve the content live as required by an external application.
/ignoreUrlParams {
/0001 { /glob "*" /type "allow" }
/0002 { /glob "category" /type "deny" }
/0003 { /glob "pubdate_gt" /type "deny" }
/0004 { /glob "pubdate_lt" /type "deny" }
}
Why is HTL Better?
We can utilize this approach to produce any XML feed, extending beyond RSS feeds. We have the flexibility to add custom properties to tailor the feed to our specific needs. Plus, we can easily apply filters using query parameters.
Big thanks to my director, Grace Siwicki, for her invaluable assistance in brainstorming the implementation and completing this blog work.
