How would you create xml files in java

Question

I am creating software that creates documents, (Bayesian network graphs to be exact), and these documents need to be saved in an XML format.

I know how to create XML files, but I have yet to decide how to organise the code.

At the moment, I plan on having each object (i.e. a Vertex or an Edge) have a function called getXML() (they will probably implement an interface so that it can be expanded later on). getXML() will return a string containing the XML for that object.

There will be another object which will collect all these XML strings and put them together, and output an XML file.

For some reason, I think this seems a bit messy, how would you recommend doing it?

Answer 1

That doesn't seem unreasonable. I would have your Bayesian network graph object iterate through each vertex/edge and either

1. ask each component for its XML and add it to the XML object being populated, or
2. pass the to-be-populated XML object (say, a DOM) into the component, and let each component write in its XML

If you have an object representing your complete chart, and you don't need to conform to a particular XML format, you could do worse than look at XStream, which may save you a lot of work. It will serialise a complete Java object graph to XML out-of-the-box.

Answer 2

The Model (vertex/edge) should not depend on representation (XML):

Model model = new Model();
View view = model.getView(); // wrong

the correct way is to decouple model from view (with something like XStream or whatever) or just make the view coupled with the model:

Model model = new Model();
View view = new XMLView(model); // ok

Answer 3

What you are suggesting breaks the single responsibility principle - in short your model should be just that and should not know about XML serialization.

Far better to perform the XML serialization in another object(s).

Answer 4

I recommend using XMLBeans.
It's a tool/framework that can generate a Jar file with parser and formatter beans. You don't need to touch a single w3c class.
But that's not why i recommend it.

The problem with XML formats is, that if your format changes you need to change your code. So, what if you miss a change? You won't know until runtime.

XMLBeans shifts the format changes to where you will see problems at compile time. Meaning you define a contract for the format (an XSD), use XMLBeans to build the parser/formatter/verifier. And the rest is up to your IDE.

And basically what you think of designing sounds like what XMLBeans does.

Answer 5

Another suggestion: Use XMLEncoder and write the necessary PersistenceDelegate classes for non-bean style objects; e.g.

static class FilePersistenceDelegate extends PersistenceDelegate {
    protected Expression instantiate(Object oldInstance, Encoder out) {
        File file = (File)oldInstance;
        return new Expression(oldInstance, oldInstance.getClass(), "new", new Object[]{ file.getPath() });
    }
}

The my code to perform the actual encoding would do something like:

    XMLEncoder encoder = new XMLEncoder(new BufferedOutputStream(new GZIPOutputStream(new FileOutputStream(file))));

    for (Map.Entry<Class<?>, PersistenceDelegate> entry : MY_DELEGATES.entrySet()) {
        // Add any custom persistence delegates written.
        encoder.setPersistenceDelegate(entry.getKey(), entry.getValue());
    }

    encoder.writeObject(object);
    encoder.close();

    if (encoder.getException() != null) {
      // Encoding failed.
    }

I'd typically use this approach for lightweight applications where I don't want to create dependencies on 3rd party libraries and where my domain model is relatively simple.

Answer 6

Do you have to use Java? Scala contains implicit type conversions which allow you to implicitly convert your model object to a view representation of your choice. It's also completely compatible with Java. For example:

def printData(obj: DataObject, os: OutputStream) = {

   val view: ViewRepresentation = obj //note implicit conversion
   view.printTo(os)
}

Where you have a trait (i.e. an interface)

trait ViewRepresentation { 
  def printTo(os: OutputStream)
}

And an implicit conversion:

implicit def dataobj2xmlviewrep(obj: DataObject): ViewRepresentation = {
  new XmlViewRepresentation(obj)   
}

You just have to code the bespoke XML representation. Oh yes - and it has native XML support in the language

Answer 7

In addition to the options given by others, you can try JAXB and StAX:

• You can use JAXB to map objects to XML schema in order to magically input and output XML documents.
• You can use StAX to read and write XML documents in a more basic fashion that suits your low-level needs

The beauty with those two options is that they ship as part of Java(JAXP) and they seem to work fine, unless of course, better options exist!