XMLBeans (http://xmlbeans.apache.org): XMLBeans uses XML Schema to compile to Java interfaces and classes that allow modification of XML instance data. XMLBeans provides setter and getter methods like JavaBeans. XMLBeans distinguishes itself by fully supporting XML Schema. During demarshalling an XML instance the full XML infoset is kept and is available to the developer. This is critical because a subset of XML is not easily represented in Java, e.g., the order of elements or comments might be needed in an application.
JAXB (www.java.sun.com/xml/jaxb): JAXB is a standard for XML binding and consists of two parts. First, JAXB contains a compiler that reads a schema and produces the equivalent Java object model. This generated object model captures the structure of XML better than general-purpose APIs like DOM or SAX, making it a lot easier to manipulate XML content.
The second part is an API, through which applications communicate with generated code. The JAXB implementation from SUN JWSDP1.5 is used.
Quantitative Evaluation of the Frameworks
We have quantitatively evaluated the XML binding frameworks on the following parameters.
- Marshalling Time - Marshalling is the process of generating an XML representation for an object in memory. As with Java object serialization, the representation needs to include all dependent objects: objects referenced by our main object, objects referenced by those objects, and so on.
- Demarshalling Time - Demarshalling is the reverse process of marshalling; it builds an object (and potentially a graph of linked objects) in memory from an XML representation.
- Memory Load - JVM Heap memory used for the whole process of marshalling and demarshalling using the respective XML binding frameworks.
Performance Tests
The test run used three samples of XML varied by its nature (segmentation factor). The test cases had to execute the selected binding frameworks on the sample XML files serially some x number of times. In addition to these, x number of threads have been executed concurrently. The combination of these test scenarios is an indicator of the memory load on a platform and time statistics of each of these utilities (
see Table 1).
Test Suite
The JProbe profiler and Memory Debugger have been used to capture the performance, memory, and threading coverage issues of the respective binding frameworks. Each test case is run as a stand-alone session to have snapshots of the performance captured for each program execution. The tests are performed on a system with the following configuration:
- Pentium IV 1.8 GHz
- 512 MB RAM
- Virtual Memory: 768 MB
Quantitative Results
Marshalling Time
The graphs in Figures 4.1-4.4 represent the marshalling performance for simple and complex XML respectively. Higher performance from JiBX is due to the byte code enhancement done at the compile time. It avoids introspection at runtime.
As seen from Figures 4.3 and 4.4, for multiple concurrent threads the results for XMLBeans worsen, whereas JiBX on the other hand has the same pattern.
Demarshalling Time
Refer to Figures 4.5 and Fig 4.6. Castor provides good support for data binding using code generation, but demarshalling performance is weak compared to others. The graph pattern is similar in the case of concurrent runs.
Castor uses the SAX2 parser and parses the XML file in an event-driven manner, thus reducing its speed and performance as compared to JiBX.
JiBX uses XMLPull parsing technique, unlike the push parsing techniques such as SAX. Instead of the parser calling methods in the handler to report document components, one calls the parser to get each component in turn.
Memory Load
Memory load over the entire run (composed of demarshalling marshalling) is low for JiBX as it uses the XMLPull parsing technique during demarshalling, which doesn't require the parser to maintain the state in the document. Castor uses the SAX2 parser, which requires the parser to maintain the state in the document. JAXB is relatively inefficient in terms of memory usage.
Inferences
From the performance analysis of the four data-binding frameworks, a SWOT analysis is presented in Figure 5. Based on information from Figure 5 and from the performance charts seen earlier, JiBX outperforms all of the other binding frameworks by a wide margin on both time and memory usage. JAXB scores well on marshalling and demarshalling time, but its memory usage is higher than the others. XMLBeans has a major performance hit but is more memory-efficient than Castor and JAXB. Depending on the specific requirement of an application, a suitable XML binding framework can be chosen.
Summary
We have illustrated in this article the pivotal role XML binding frameworks can play in context of SOA. To enable practitioners to make an informed choice about the appropriate XML binding platform, we have carried out a detailed quantitative analysis of some of the popular XML binding frameworks in the J2EE context, and presented the results.
References
Cloud computing is a game changer. The cloud ...
Subscribe to SOA World Magazine Email News Alerts
Subscribe via RSS
