Question

I’m developing an application which uses different components to create an XHTML document, I used StringTemplate for creating the document data of the components and then combined them into a one large document. This is an example of a component:

public class BoxImpl extends AbstractContainerImpl implements Box {

    private static final StringTemplate template;

    static {
        template = new StringTemplate(
        "<div id=$id$>$content$</div>");
    }

    public BoxImpl(String id) {
        this.setId(id);
    }

    @Override
    public CharBuffer generate() {
        // Get a local instance
        StringTemplate template = BoxImpl.template.getInstanceOf();
        // Set ID attribute of box
        template.setAttribute("id", this.getId());
        // Generate view for controls inside this container
        CharBuffer inner = this.generateInner();
        // Add inner data as content attribute
        template.setAttribute("content", inner == null ? "" : inner.array());
        // Return the result
        return CharBuffer.wrap(BoxImpl.template.toString());
    }

}

My question is, is it more efficient to implement this kind of document building using XML DOM or a StringBuilder, compared to the StringTemplate?

EDIT: I do not need XML validation.

Answer 1

From a perfomance point of view I’m pretty sure DOM would be worse than your usage of StringTemplate. Using StringBuilder might be a bit faster and maybe even cleaner looking (if used implicitly):

public CharBuffer generate() {
    String content = inner == null ? "" : inner.array();
    return CharBuffer.wrap( "<div id=\"" + this.getId() + "\">" + content + "</div>" );
}

The fastest way to do this would probably be to avoid the creation of temporary strings entirely, i.e. to write directly into a BufferedOutputWriter or PrintWriter.

But in general I’d suggest to use one of the dedicated Stream Writer APIs for the creation of XML documents. There are several non obvious pitfalls when you put vanilla strings directly into a XML documents without awareness for proper escaping of special characters. These APIs usually offer also a failry efficient implementation that beats most naive approaches. Examples for such APIs are: StAX, Apache XMLIO and SAX Transformer.