Use Groovy has Spring bean in a JSF web application

Using Groovy as a Spring Bean in a JSF Web Application

Using Groovy in your Java web application with the Spring Framework is both easy and powerful. This tutorial will guide you through the process.

Background

In my last project, I needed to parse a complex XML file and transfer the information to a database. Initially, I used a Java class with org.w3c.dom.* and DocumentBuilder, but the resulting code was long, complex, and difficult to maintain.

Example

DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance(); 
DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder(); 
doc = docBuilder.parse(fileName); 
doc.getDocumentElement().normalize(); 
NodeList listOfEntries = doc.getElementsByTagName("entry"); 
for (int s = 0; s < listOfEntries.getLength(); s++) { 
  Node firstEntityNode = listOfEntries.item(s); 
  if (firstEntityNode.getNodeType() == Node.ELEMENT_NODE) { 
    ListEntry entry = new ListEntry(); 
    Element firstEntityElement = (Element) firstEntityNode; 
    NodeList uidList = firstEntityElement.getElementsByTagName("uid"); 
    ... 
  } 
} 

To simplify the process, I integrated Groovy into my Spring-JSF application. Groovy’s XmlSlurper class allows for easy XML parsing, treating XML as a collection of objects.

A useful tutorial on XmlSlurper can be found here.

Groovy’s Role in the Application

The first Groovy class in my application had the following responsibilities:

• Accept two parameters from a Java class (XML file address and an integer parameter)
• Process the XML file
• Use two existing Java classes
• Return an ArrayList of custom objects containing parsed values

Steps to Integrate Groovy with Spring

1. Add the Groovy JAR to Your Application

Ensure that your application includes the Groovy library.

2. Create a Traditional Java Interface

package ch.genidea.checknames.importer; 
 
import java.util.List; 
import ch.genidea.checknames.model.ListEntry; 
import ch.genidea.checknames.model.SourceList; 
 
public interface Parser { 
    List<ListEntry> parse(); 
    void setFilename(String filename); 
    void setSourceList(SourceList sourceList); 
} 

We declare setter methods for the two required variables that will be used in the Groovy class.

3. Create the Groovy Class in the Classpath

If using Maven, place it in src/main/resources.

package ch.genidea.checknames.importer 
 
import java.util.List; 
import ch.genidea.checknames.model.ListEntry; 
import ch.genidea.checknames.model.SourceList; 
 
def class ParserImpl implements ch.genidea.checknames.importer.Parser { 
    String filename 
    List<ListEntry> result 
    SourceList sourceList 
 
    List<ListEntry> parse() { 
        def pers = new XmlSlurper().parse(new File(filename)) 
        List<ListEntry> result = new ArrayList<>() 
         
        pers.Entry.each { 
            result.add(addEntry(it)) 
            it.akaList.aka.each { result.add(addEntry(it)) } 
        } 
        return result 
    } 
 
    ListEntry addEntry(def it) { 
        ListEntry entity = new ListEntry() 
        entity.uid = (it.uid.text() as Integer) 
        entity.sourceList = sourceList 
        entity.familyName = it.lastName.text() 
        entity.firstName = it.firstName.text() 
        return entity 
    } 
 
    void setFilename(String filename) { this.filename = filename } 
    void setSourceList(SourceList sourceList) { this.sourceList = sourceList } 
} 

With just a few lines, this Groovy class performs the same work as the original lengthy Java implementation.

4. Declare the Groovy Bean in Spring

<beans xmlns="https://www.springframework.org/schema/beans" 
       xmlns:lang="https://www.springframework.org/schema/lang" 
       ...> 
 
    <lang:groovy id="parser" script-source="classpath:ch/genidea/checknames/importer/ParserImpl.groovy" /> 
 
    <bean name="listImportService" class="ch.genidea.checknames.lists.service.ListImportServiceImpl"> 
        <property name="parser" ref="parser" /> 
    </bean> 
</beans> 

5. Use the Groovy Class in Your Code

parser.setFilename(fileSource); 
parser.setSourceList(sl); 
List<ListEntry> list = parser.parse(); 

Drawbacks

While integrating Groovy brought significant advantages, I encountered a couple of minor drawbacks:

• Debugging Groovy in Eclipse is not straightforward. However, I used groovyConsole to quickly test changes.
• The Groovy JAR (groovy-all.jar) added approximately 4MB to the project.

Despite these small issues, the benefits of cleaner, more readable, and maintainable code made it well worth the effort! 😊