–  This blog shows how to Integrate Groovy into Java

Java is powerful and it can do almost everything.

However, it feels tired sometimes to spend hours on the setting before seeing a ‘Hello World’ to print out.

On the contrast, Groovy is easy to use as a scripting language on top of Java.

Sometimes it gives me an idea if we can merge these 2 together to make the life easier.

This blog shows a way to run Groovy Scripts dynamically inside Java – just do some simple change, we can make it a simple and powerful tool that can be embedded into existing Java projects as a scripting addon.

Following codes uses 2 different kinds of Groovy scripting running method, please refer to Standard Groovy documentation “Integrating Groovy into applications” for the difference.

Transformer1 uses GroovyScriptEngine

Transformer2 uses GroovyShell

import groovy.lang.Binding;
import groovy.lang.GroovyShell;
import groovy.util.GroovyScriptEngine;
import java.io.File;
import java.nio.file.Files;
import org.apache.commons.io.FileUtils;

public class GroovyTransformer {

public static void main(String[] args) throws Exception {
groovyScriptTransformer1();
// groovyScriptTransformer2();
}

public static void groovyScriptTransformer1() throws Exception {
byte[] input = Files.readAllBytes(new File("c:/test/order_sample.csv").toPath());

Binding sharedData = new Binding();
sharedData.setVariable("input", input);

String[] roots = new String[] { "c:/test" };
GroovyScriptEngine gse = new GroovyScriptEngine(roots);
gse.run("csvParser.groovy", sharedData);

byte[] output = (byte[]) sharedData.getVariable("output");
System.out.println(new String(output));

}

public static void groovyScriptTransformer2() throws Exception {

// get the source file bytes
byte[] input = Files.readAllBytes(new File("c:/test/order_sample.csv").toPath());
Binding sharedData = new Binding();
sharedData.setVariable("input", input);

// get the groovy script as a String
String script = FileUtils.readFileToString(new File("c:/test/csvParser.groovy"), "UTF-8");
System.out.println(script);

// create a groovy shell and run the script
GroovyShell shell = new GroovyShell(sharedData);
shell.evaluate(script);

// get the output of the transformation
byte[] output = (byte[]) sharedData.getVariable("output");
System.out.println(new String(output));
}

}

Following is the sample file “order_sample.csv”

Order Number,Date,To Name,
10090,29/10/15,Sharen Shirley,
10091,29/10/15,Justina Jump,
10092,29/10/15,Macie Maxon,
10093,29/10/15,Shamika Solt,
10094,29/10/15,Marcos Mccabe,

Following is the sample Groovy script “csvParser.groovy”, it did nothing but parsed the csv file into lines, it can easily be changed to transform to other file formats – xml, json or marshaling to groovy/java objects.

import java.io.ByteArrayInputStream
import java.io.Reader
import java.io.InputStreamReader
import static com.xlson.groovycsv.CsvParser.parseCsv
def sb = StringBuilder.newInstance()

Reader inputReader = new InputStreamReader(new ByteArrayInputStream(input));
for(line in parseCsv(inputReader,separator:',')){
// println line
sb.append(line)
sb.append("\n")
}

output = sb.toString().getBytes()

Using the standard java XML library could be a little bit complex, especially when you just want a quick handling of XML files and don’t want to dive deep into the codes that parse it.

Following code provides a wrapped helper class which helps to do this.

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

import java.io.StringWriter;
import java.io.Writer;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class XmlUtil {
public static Document getXmlDocumentByString(String xmlString) {
Document doc = null;
try {
InputStream is = new ByteArrayInputStream(xmlString.getBytes());

DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
dbFactory.setNamespaceAware(false);
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
doc = dBuilder.parse(is);

} catch (Exception ex) {
ex.printStackTrace();
}
return doc;
}

public static Document getXmlDocumentByBytes(byte[] inputBytes) {
Document doc = null;
try {
InputStream is = new ByteArrayInputStream(inputBytes);

DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
dbFactory.setNamespaceAware(false);
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
doc = dBuilder.parse(is);

} catch (Exception ex) {
ex.printStackTrace();
}
return doc;
}

public static NodeList getXmlNodeListByXPath(Document doc, String xpath) throws Exception {
XPath xPath = XPathFactory.newInstance().newXPath();
return (NodeList) xPath.compile(xpath).evaluate(doc, XPathConstants.NODESET);
}

public static NodeList getXmlNodeListByXPath(Node node, String xpath) throws Exception {
XPath xPath = XPathFactory.newInstance().newXPath();
return (NodeList) xPath.compile(xpath).evaluate(node, XPathConstants.NODESET);
}

public static Node getXmlNodeByXPath(Node node, String xpath) throws Exception {
XPath xPath = XPathFactory.newInstance().newXPath();
return (Node) xPath.compile(xpath).evaluate(node, XPathConstants.NODE);
}

public static Document removeNodesByTag(Document xmlDoc, String nodeTag) {
NodeList nl = xmlDoc.getElementsByTagName(nodeTag);
for (int i = nl.getLength() - 1; i >= 0; i--) {
Node n = nl.item(i);
n.getParentNode().removeChild(n);
}

return xmlDoc;
}

public static String prettyPrint(Document xml) throws Exception {
Transformer tf = TransformerFactory.newInstance().newTransformer();
tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
tf.setOutputProperty(OutputKeys.INDENT, "yes");
Writer out = new StringWriter();
tf.transform(new DOMSource(xml), new StreamResult(out));
return out.toString();
}

// following file exscapes the xml specific chars inside the string.
public static String escapeXml(String s) {
return s.replaceAll("&", "&")
.replaceAll(">", ">")
.replaceAll("<", "<")
.replaceAll("\"", """)
.replaceAll("'", "'");
}

public static byte[] readBytesFromFile(String filePath) {

FileInputStream fileInputStream = null;
byte[] bytesArray = null;
try {

File file = new File(filePath);
bytesArray = new byte[(int) file.length()];

//read file into bytes[]
fileInputStream = new FileInputStream(file);
fileInputStream.read(bytesArray);

} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileInputStream != null) {
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return bytesArray;
}
}