Java Fluent API - better method?

Question

Say I have an object that I've created to further simplify reading an XML document using the DOM parser. In order to "step into" a node or element, I'd like to use a single line to go from the start of the document to my target data, buried somewhere within the document, while bypassing the extra "fluff" of the DOM parser (such as doc.getElementsByTagName("data").item(0) when there is only one item inside the "data" element).

For the sake of this question, let's just assume there are no duplicate element tags and I know where I need to navigate to to get the data I need from the document, of which the data is a simple string. The idea is to set the simplified reader up so that it can be used for other data in other locations in the document, as well, without having to write new methods all the time. Below is some example code I've tried:

public class SimplifiedReader {
    Document doc;
    Element ele;
    public SimplifiedReader(Document doc) {
        this.doc = doc;
        ele = doc.getDocumentElement();
    }

    public SimplifiedReader fromRoot() {
        ele = doc.getDocumentElement();
        return this;
    }

    public SimplifiedReader withEle(String elementName) {
        ele = ele.getElementsByTagName(elementName).item(0);
        return this;
    }

    public String getTheData(String elementName) {
        return ele.getTextContent();
    }
}

Example XML File:

<?xml version="1.0" encoding="UTF-8"?>
<fileData>
    <subData>
        <targetData>Hello World!</targetData>
        <otherData>FooBar!</otherData>
    </subData>
</fileData>

This results in me being able to navigate the XML file, and retrieve the Strings "Hello World!" and "FooBar!" using this code:

SimplifiedReader sr = new SimplifiedReader(doc);
String hwData = sr.withEle("fileData").withEle("subData").getTheData("targetData");
String fbData = sr.getTheData("otherData");

Or, if I had to go to another thread to get the data "FooBar!", I would just do:

String fbData = sr.fromRoot().withEle("fileData2").withEle("subData2").getTheData("otherData");

Is there a better/more correct way to do this? Edit: Note: This question is more about the method of returning an object from a method inside of it (return this;) in order to reduce the amount of code written to access specific data stored within a tree format and not so much about how to read an XML file. (I originally thought this was the Singleton Pattern until William corrected me... thank you William).

Thanks in advance for any help.

Answer 1

1. I don't see any trace of the Singleton pattern here. It mostly resembles the Builder pattern, but isn't it, either. It just implements a fluent API.

2. Your approach seems very nice and practical.

3. I would perhaps advise not using fromRoot() but instead constructing a new instance each time. The instance is quite lightweight since all the heavyweight stuff resides in the Document instance it wraps.

4. You could even go immutable all the way, returning a new instance from withEle(). This buys you many cool properties, like the freedom to share the object around, each code path being free to use it as a starting point to fetch something specific relative to it, share it across threads, etc. The underlying Document is mutable, but usually this doesn't create real-life problems when the code is all about reading.

Answer 2

Is there a better/more correct way to do this?

Yes, there are many better ways to extract values from XML.

One would be to use XPath, for example with XMLBeam.

import java.io.IOException;
import org.xmlbeam.XBProjector;
import org.xmlbeam.annotation.XBDocURL;
import org.xmlbeam.annotation.XBRead;

public class App {

    public static void main(String[] args) throws IOException {
        FileDate fileDate = new XBProjector().io().fromURLAnnotation(FileDate.class);
        System.out.println(fileDate.getTargetDate());
        // Hello World!
        System.out.println(fileDate.getOtherDate());
        // FooBar!
    }

    @XBDocURL("resource://filedate.xml")
    public interface FileDate {

        @XBRead("/fileData/subData/targetData")
        String getTargetDate();

        @XBRead("/fileData/subData/otherData")
        String getOtherDate();
    }
}