CQ Community

Submitting Mobile Data to Adobe CQ using a Sling Post Servlet

Scott Macdonald — Thu, 30 May 2013 16:42:00 +0000

-Scott MacDonald

You can create an Adobe CQ mobile form using JQuery Mobile API and submit the data to Adobe CQ using a Sling Post Servlet. When a mobile user fills in the form and clicks the submit button, form data is submitted to Adobe CQ.

...

......

Read the full blog post at Adobe Digital Marketing Blog

Developing a Spring MVC project using Maven, JSTL tags, and data persistence

Scott Macdonald — Mon, 20 May 2013 00:30:00 +0000

This Scotts Digital Community article falls into a general programming discussion (as opposed to an Adobe Enterprise development article) and provides details on developing a Spring MVC application that persists data. You can create this Spring MVC project by using Maven and JSTL tags. For information about Spring MVC, see http://static.springsource.org/spring/docs/2.0.x/reference/mvc.html.

Assume, for example, that you want to create a Spring MVC project that saves, displays, and deletes customer data.

A Spring MVC application that supports saving, viewing, and deleting customer data

This development article guides you through how to create this Spring MVC project, including how to configure the Spring DispatcherServlet. Included in this article is the use of Spring annotations such as @Autowired. This annotation informs the Spring framework to use dependency injection on a constructor, class field, setter method or config method.

The JavaServer Pages Standard Tag Library (JSTL) is a collection of JSP tags which uses functionality common to JSP applications. For example, using a JSTL tag, you can iterate through a data collection and display the results within a web page.

To create a Spring MVC project using Maven, perform these tasks:

1. Setup Maven in your development environment.

2. Create a Maven project structure.

3. Convert the Maven project to a Spring MVC project.

4. Build the Maven project.

5. Deploy the Maven project to an application server (in this development environment, the project is ran on Tomcat).

SETUP MAVEN IN YOUR DEVELOPMENT ENVIRONMENT

You can use Maven to build and manage Java projects. One benefit of Maven is dependency management. What does this mean? Well -- it means that Maven manages required JAR files that a Java project needs in its class path. Therefore instead of hunting through the Internet trying to find and download third-party JAR files to include in your class path, Maven will manage these dependencies for you.

You can download Maven 3 from the following URL:

http://maven.apache.org/download.html

After you download and extract Maven, create an environment variable named M3_HOME. Assign the Maven install location to this environment variable. For example:

C:\Programs\Apache\apache-maven-3.0.4

You can test to determine if Maven is properly setup by entering the following command into a command prompt:

%M3_HOME%\bin\mvn -version

This command provides Maven and Java install details and resembles the following message:

Apache Maven 3.0.4 (r1232337; 2012-01-17 03:44:56-0500)

Maven home: C:\Programs\Apache\Maven\apache-maven-3.0.4

Java version: 1.6.0_31, vendor: Sun Microsystems Inc.

Java home: C:\Programs\Java64-6\jre

Default locale: en_US, platform encoding: Cp1252

OS name: “windows 7”, version: “6.1”, arch: “amd64”, family: “windows”

CREATE A MAVEN PROJECT STRUCTURE

You can use a Maven archetype plugin to create a project. To create a Java application, you can use the maven-archetype-quickstart plugin. The following example creates a Maven Java application project in the C:\apache-maven-3.0.4\ folder.

To create a Maven project structure:

1. Open the command prompt and go to the C:\apache-maven-3.0.4 directory.

2. Run the following Maven command:

mvn archetype:generate -DgroupId=com.sdc.controller -DartifactId=FirstController -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

You will see a Maven message similar to the following:

[INFO] Using following parameters for creating project from Old (1.x) Archetype:
maven-archetype-quickstart:1.0
[INFO]
[INFO] Parameter: groupId, Value: com.sdc.controller
[INFO] Parameter: packageName, Value: com.sdc.controller
[INFO] Parameter: package, Value: com.sdc.controller
[INFO] Parameter: artifactId, Value: FirstController
[INFO] Parameter: basedir, Value: C:\apache-maven-3.0.4
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\apache-maven-3.0.4\FirstController
[INFO] BUILD SUCCESS
[INFO] Total time: 3.347s
[INFO] Finished at: Sun Jan 20 16:49:18 EST 2013
[INFO] Final Memory: 8M/122M

This Maven command produces a basic project structure that contains a POM file and basic Java class.

The generated Maven POM file is located in the FirstController folder. Change this folder name to Customer and modify the folder structure under Customer to reflect the folder structure shown in the following illustration. Next, delete the folders under the java folder. New Java files are added in the following sections.

Under the java folder, create the following folder structure: java\com\springapp\mvc. These child folders correspond to the Java package named com.springapp.mvc that is used in this development article.

CONVERT THE MAVEN GENERATED PROJECT TO A SPRING MVC PROJECT

The next step is to convert the generated Maven project into a Spring MVC project. This involves performing the following tasks:

1. Add the Java classes to the com.springapp.mvc package.

2. Modify the POM file to include Spring MVC dependencies.

3. Add a data persistence XML configuration file to the resources folder.

3. Add a new folder named webapp to the src/main folder. This folder contains the WEB-INF folder.

Add the User class

Add a Customer class to the java\com\springapp\mvc folder that represents a Spring bean. This class uses the following annotations:

@Entity - indicates that this Spring bean is a persistent entity.
@GeneratedValue - indicates a primary key property or field of an entity or mapped superclass in conjunction with the Id annotation.
@Basic - can be applied to a persistent property. In this example, first name, last name, and email fields are persisted.

The following Java code represents the User class.

package com.springapp.mvc;

import javax.persistence.*;

@Entity(name = "account")

public class User{

@Id

@GeneratedValue(strategy = GenerationType.AUTO)

private Long id;

@Basic

private String firstName;

@Basic

private String lastName;

@Basic

private String email;

public Long getId() {

return id;

}

public void setId(Long id) {

this.id = id;

}

public String getFirstName() {

return firstName;

}

public void setFirstName(String name) {

this.firstName = name;

}

public String getLastName() {

return lastName;

}

public void setLastName(String lastName) {

this.lastName = lastName;

}

public String getEmail() {

return email;

}

public void setEmail(String email) {

this.email = email;

}

Add the UserController class

Add a UserController class to the java\com\springapp\mvc folder that represents a Spring MVC controller. A controller is responsible for receiving requests from users and invoking services for business processing. This class contains the following annotations:

@Controller - indicates that this class is a MVC controller.
@Autowired- informs the Spring framework to use dependency injection
@RequestMapping - specifies that the corresponding method is a controller handler method.

The following Java code represents the UserController class.

package com.springapp.mvc;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.ui.ModelMap;

import org.springframework.validation.BindingResult;

import org.springframework.web.bind.annotation.ModelAttribute;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

@Controller

public class UserController {

@Autowired

private UserRepository userRepository;

@RequestMapping(value = "/", method = RequestMethod.GET)

public String listUsers(ModelMap model) {

model.addAttribute("user", new User());

model.addAttribute("users", userRepository.findAll());

return "users";

}

@RequestMapping(value = "/add", method = RequestMethod.POST)

public String addUser(@ModelAttribute("user") User user, BindingResult result) {

userRepository.save(user);

return "redirect:/";

}

@RequestMapping("/delete/{userId}")

public String deleteUser(@PathVariable("userId") Long userId) {

userRepository.delete(userRepository.findOne(userId));

return "redirect:/";

}

Add the UserRepository class

Add the UserRepository class that extends org.springframework.data.jpa.repository.JpaRepository. The JpaRepository class lets a bean of this type modify data stored in the database.

The following Java code represents the UserRepository class.

package com.springapp.mvc;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {

}

Modify the POM file to include Spring MVC dependencies

Replace the POM that the Maven plug-in created with the following POM file. This new POM includes Spring dependencies that are required to use Spring MVC functionality. In addition, the dependency to use Hibernate functionality is also included.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

<groupId>com.springapp.mvc</groupId>

<artifactId>Customer</artifactId>

<version>1.0-SNAPSHOT</version>

<name>SpringMVC Maven Webapp</name>

<url>http://maven.apache.org</url>

<spring.version>3.2.0.RELEASE</spring.version>

</properties>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-web</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>javax.servlet</groupId>

<artifactId>servlet-api</artifactId>

</dependency>

<groupId>javax.servlet.jsp</groupId>

<scope>provided</scope>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependency>

<groupId>org.springframework.data</groupId>

<artifactId>spring-data-jpa</artifactId>

<version>1.2.0.RELEASE</version>

</dependency>

<groupId>org.hibernate.javax.persistence</groupId>

<artifactId>hibernate-jpa-2.0-api</artifactId>

<version>1.0.0.Final</version>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-entitymanager</artifactId>

<version>3.6.10.Final</version>

</dependency>

<groupId>org.hsqldb</groupId>

<artifactId>hsqldb</artifactId>

</dependency>

</dependency>

</dependencies>

</project>

Add a data persistence XML configuration file to the resources folder

Add a data persistence XML configuration file that lets the Spring MVC application persist data into a database. In the resources folder, create a sub folder named META-INF. Add an XML file named persistence.xml in the META-INF folder.

The following XML represents the persistence.xml configuration file. In this example, a HSQL database is used. Notice that values such as user name and password are specified using property elements.

<?xml version="1.0" encoding="UTF-8"?>

<persistence-unit name="defaultPersistenceUnit" transaction-type="RESOURCE_LOCAL">

<provider>org.hibernate.ejb.HibernatePersistence</provider>

</properties>

</persistence-unit>

</persistence>

Add the webapp folder to the Maven project structure

Add a new folder named webapp to the main folder. Add a subfolder named WEB-INF to the webapp folder. You add the following three files to this WEB-INF folder: web.xml, mvc-dispatcher-servlet.xml, and users.jsp (this file is located in a sub folder named pages). The users.jsp file calls the Java application logic defined within the UserController class.

The web.xml file defines servlets for the web application (after all, a Spring MVC project is a web application). Within the web.xml file, you specify a Spring MVC servlet. A Spring MVC servlet is based on org.springframework.web.servlet.DispatcherServlet. In the following example, the name of the Spring dispatcher servlet is mvc-dispatcher.

The following XML code represents the web.xml file.

<web-app version="2.4"

xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee

http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

<display-name>Spring MVC Application</display-name>

<servlet-name>mvc-dispatcher</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>mvc-dispatcher</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

</web-app>

Notice the servlet-name element specifies mvc-dispatcher. This specifies the location of the mvc-dispatcher-servlet.xml. In this example, the name of the dispatcher servlet is mvc-dispatcher (this is the file that is created next).

The mvc-dispatcher-servlet.xml informs the Spring framework where to find the controller (in this article, the controller is the UserController class. The dispatcher configuration uses the following element to specify the location of the controller:

<context:component-scan base-package="com.springapp.mvc"/>

This XML element informs the Spring framework to search the com.springapp.mvc package for a controller. The following XML represents the mvc-dispatcher-servlet.xml file.

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:jpa="http://www.springframework.org/schema/data/jpa"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

<context:component-scan base-package="com.springapp.mvc"/>

</bean>

<jpa:repositories base-package="com.springapp.mvc"/>

</bean>

</bean>

<tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

The last file to create is the user.jsp file. In this example, place the JSP file in a folder named pages (this is a sub-folder to WEB-INF). This JSP invokes Java methods defined in the UserController.

<!doctype html>

<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>

<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>

<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<html>

<head>

<title>Spring MVC Application</title>

</head>

<body>

<h1>Users</h1>

<form:form method="post" action="add" commandName="user" class="form-horizontal">

<form:label cssClass="control-label" path="firstName">First Name:</form:label>

<form:input path="firstName"/>

</div>

<form:label cssClass="control-label" path="lastName">Last Name:</form:label>

<form:input path="lastName"/>

</div>

<form:label cssClass="control-label" path="email">Email:</form:label>

<form:input path="email"/>

</div>

</form:form>

</div>

<c:if test="${!empty users}">

<h3>Users</h3>

<thead>

<tr>

<th>Email</th>

</tr>

</thead>

<tbody>

<c:forEach items="${users}" var="user">

<tr>

<td>${user.lastName}, ${user.firstName}</td>

<td>${user.email}</td>

<td>

</td>

</tr>

</c:forEach>

</tbody>

</table>

</c:if>

</div>

</body>

</html>

In this example, notice that JSTL tags are used. In this example, for each user in the database, a new table HTML table row is created and the user.lastName and user.FirstName methods (defined in the User class) are invoked.

Each row also has a button defined by this HTML tag: input type="submit". When clicked, notice that the delete method defined in the UserController class is invoked. This deletes the user record from the database.

Finally a new user is added to the database by clicking the Add User button. When the Add User button is clicked, the addUser method located in the UserController is invoked.

@RequestMapping(value = "/add", method = RequestMethod.POST)

public String addUser(@ModelAttribute("user") User user, BindingResult result) {

userRepository.save(user);

return "redirect:/";

}

BUILD THE MAVEN PROJECT

After you convert the generated Maven project to a Spring MVC project, you can build the artifact by using Maven. The artifact that is built is a WAR file, as specified in the POM file. In this example, the packaging element in the POM file specifies war:

<groupId>com.springapp.mvc</groupId>

<artifactId>Customer</artifactId>

<version>1.0-SNAPSHOT</version>

<name>SpringMVC Maven Webapp</name>

<url>http://maven.apache.org</url>

To create the artifact by running Maven, perform these steps:
1.Start the Command Prompt.
2. Change the directory to the location of POM file.
3. Enter the following command: %M3_HOME%\bin\mvn clean package.
4. The WAR file is placed in the target directory. In this example, the WAR file is named Customer-1.0-SNAPSHOT.war.

DEPLOY THE WAR FILE TO TOMCAT

Deploy the WAR file that was built in the previous step by placing it in the Tomcat\webapps folder. Restart Tomcat. Once Tomcat is started, you can view the Spring MVC application by entering the following URL:

http://[server name]:[port]/Customer-1.0-SNAPSHOT/

The following illustration shows the Spring MVC application in a web browser.

CONCLUSION

This article walked you through how to set-up a Spring MVC project using Maven and highlighted how the dispatcher, controller and view work together. Once you understand this, you can start to work on more complex Spring MVC applications.

ABOUT THE AUTHOR

I (Scott Macdonald) am a Senior Digital Marketing Content and Community lead at Adobe Systems with over 16 years in the high tech industry. I am also a programmer with knowledge in Java, JavaScript, C#,C++, HTML, XML and ActionScript. If you would like to see more CQ or other Adobe Digital Marketing end to end walkthroughs like this, then leave a comment and let me know what content you would like to see.

AEM5.6: Socoadmin: reply button and refresh issues in moderation UI

dmcmahon — Mon, 13 May 2013 00:15:35 +0000

- David McMahon

Issue

If you are using the classic UI (/socoadmin) for social moderation in AEM5.6, you may notice some strange behaviour as follows

Reply button disabled
1) Go to http://localhost:4502/socoadmin
2) Select a blog comment from Geometrixx

...

........

Read the full blog post at Adobe Digital Marketing Blog

Custom CQ5 workflow step that integrates Twitter and Jabber

Michael Marth — Wed, 08 May 2013 00:00:01 +0000

-Michael Marth

As part of the IKS project each CMS vendor completes a couple of benchmarks in order to establish a baseline against which future semantic improvements can be measured. For benchmark 3 "Workflow Service" Bertrand and I chose to implement the task "Create a multi-channel (email, SMS, instant messaging, Twitter,...) notification service for workflow transitions". We have created an automated workflow step that can be inserted into a custom workflow and either send an e-mail, send a direct message on Twitter or send a chat message on GTalk/Jabber. The corresponding message's payload is the path to the content node in the workflow plus an optional custom text.

...

........

Read the full blog post at Adobe Digital Marketing Blog

Creating gallery components that display digital assets stored in the CQ DAM

Scott Macdonald — Fri, 03 May 2013 14:30:00 +0000

-Scott MacDonald

You can create an interactive visual component that lets your AEM users engage with your Adobe CQ web site by viewing and clicking on images. When a user clicks on a thumbnail version of an image, a larger view of the image appears. In this workflow, the component retrieves images from the Adobe CQ Digital Asset Management (DAM) repository.

...

......

Read the full blog post at Adobe Digital Marketing Blog

Submitting Mobile Form Data to Adobe CQ

Scott Macdonald — Sat, 27 Apr 2013 00:00:00 +0000
-Scott MacDonald
You can create an Adobe CQ mobile form using JQuery Mobile API. When a mobile user fills in the form and clicks the submit button, form data is submitted to Adobe CQ. You can develop an OSGi bundle operation to process the submitted form data to meet your business requirements.

...

.......

Read the full blog post at Adobe Digital Marketing Blog

Adobe CQ/AEM support tools available

dmcmahon — Thu, 25 Apr 2013 07:00:53 +0000
-David McMahon
We have recently published a package with support tools that can be useful to help diagnose issues encountered with Adobe Experience Manager. As the tools project continues to mature, additional tools will be provided to ease the overall diagnosis and maintenance of CQ.

...

......

Read the full blog post at Adobe Digital Marketing Blog

Ways to access your content with JCR (part 1)

moderator — Mon, 10 Dec 2012 09:02:51 +0000

- Jörg Hoh

If you are a developer and need to work with databases, you often relay on the features your framework offers you to get your work done easily. Working directly with JDBC and SQL is not really comfortable, writing “SELECT something FROM table” with lots of constraints can be tedious …

The SQL language offers only the “select” statement to retrieve data from the database. JCR offers multiple ways to actually get access to a node:

session.getNode(path)

node.getNodes()

JCR search

Each of these methods serve for different purposes.

session.getNode(path) is used, when you know exactly the path of a node. That’s comparable to a “select * from table where path = “/content/geometrixx/en” in SQL, which is a direct lookup of a well-known node/row.

node.getNodes() returns all child nodes below the node. This method has no equivalent in the SQL world, because in JCR there are not only distinct and independent nodes, but nodes might have a hierarchical relation.

The JCR search is the equivalent of the SQL query, it can return a set of nodes. Yes, ANSI SQL 92 is much more powerful, but let’s ignore that for this article, okay?

...

----------

Read the complete post on the Things on a content management system blog.

CQ coding patterns: Sling vs JCR (part 2)

moderator — Thu, 22 Nov 2012 06:04:30 +0000
- Jörg Hoh

In the last posting I showed the benefits of Sling regarding resource access over plain JCR. But not only in resource access both frameworks offer similar functionality, but also in the important area of listening to changes in the repository. So today I want to compare JCR observation to Sling eventing.

JCR observation is a part of the JCR specification and is a very easy way to listen for changes in the repository.

@component (immediate=true, metatype=false) @service class Listener implements ObservationListener { @Reference SlingRepository repo; Session session; Logger log = LoggerFactory.getLogger (Listener.class); @activate protected void activate () { try { Session adminSession = repo.loginAdministrative(null); session = adminSession.impersonate (new SimpleCredentials("author",new char[0])); adminSession.logout(); adminSession = null; session.getObservationManager.addEventListener( this, // listener NODE_CREATED|NODE_DELETED|NODE_MOVED, // eventTypes "/", // absPath true, // isDeep null, // uuid null, //nodeTypeNames true // noLocal ); } catch (RepositoryException e) { log.error ("Error while registering observation", e); } } @deactivate protected void deactivate() { session.getObservationManager.removeListener(this); session.logout(); session = null: } private handleEvents (Events events) { while (events.hasNext()) { Event e = events.next(); … // do here your event handling } } }

In JCR the creation of an observation listener is straight forward, also the event listening. The observation process is tied to the lifetime of the session, which is started and stopped at activation/deactivation of this sling service. This kind of implementation is a common pattern.

...

------

Read the complete blog post at http://cqdump.wordpress.com/2012/11/13/cq-coding-patterns-sling-vs-jcr-part-2/

CQ5 coding patterns: Sling vs JCR (part 1)

moderator — Wed, 21 Nov 2012 09:04:16 +0000

- Jörg Hoh

CQ5 as a complex framework is built on top of various other frameworks, on the server-side the most notably ones are JCR (with its implementation Apache Jackrabbit) and Apache Sling. Both are very powerful frameworks, but both of them have some overlap in functionality:

reading data from the repository (Sling Resources vs JCR nodes/properties)

notification on repository events (Sling Eventing vs JCR observation)

In these 2 areas you can work with both frameworks, and achieve good results with both. So, the question is, in what situation should you prefer Sling and in what situation pure JCR.

First, and I hope you agree here, in 99% of all cases use the an abstracted framework is recommended over the use of concrete technology (everybody uses JDBC and noone a direct database interface for e.g. MySQL) . It usually offers more flexibility and an easier learning cure. Same here. While on pure JCR you only work with raw repository structures (nodes and properties), the Sling resource abstraction offers you easier handling (no need to deal with the repository exceptions any more) and much more options to interact with you business objects and services.

...

-----------

Read the complete blog post at http://cqdump.wordpress.com/2012/11/06/cq5-coding-patterns-sling-vs-jcr-part-1/