What is contentObject in the constructor of JAXBSource

I have to create a program which reads (and writes) a person from (to) a file. The writing part worked fine. To read the person I'm using a tutorial which uses JAXBSource. In the constructor of JAXBSource:

JAXBSource(JAXBContext context, Object contentObject);

there is this Object contentObject, which I don't understand what datatype it should be and what it's used for. Maybe someone can help me.

Short Answer

The contentObject is whatever object you want to provide as input into your XML process. For example, this process could be a transformation process.

So, if you have a Person class, and you have created a person object, then you would have:

JAXBSource source = new JAXBSource(context, person);

However, I think there may be a couple misunderstandings in the question.

You mentioned you can successfully write a person object to a file (as XML, I assume). But now you want to read that data back from the file into a new person object.

But a JAXBSource starts with the object (as shown above) and then typically writes that object to some new target (e.g. a file). And, as I mentioned, it alows for a transformation of the data along the way.

If all you want to do is write an object to an XML file, and then read that XML data back into an object, then you can simplify the code by using javax.xml.bind.Marshaller and javax.xml.bind.Unarshaller.

Longer Answer - With Examples

To help clarify, here are some examples - starting with the simplest approach.

Assume we have the following Person class:

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Person {
    
    private String firstName;
    private String lastName;

    // getters and setters not shown here
}

Example 1 - Writing to a File

    public void writeObjectToFile() throws JAXBException {
        JAXBContext jc = JAXBContext.newInstance(Person.class);
        Person person = new Person();
        person.setFirstName("Jack");
        person.setLastName("Frost");
        File xmlFile2 = new File("C:/tmp/files/person2.xml");

        Marshaller marshaller = jc.createMarshaller();
        marshaller.marshal(person, xmlFile2);
    }

This writes the following basic XML to the file:

<person>
  <firstName>Jack</firstName>
  <lastName>Frost</lastName>
</person>

Example 2 - Reading From the File

This reads from the file we created in example 1:

    public void readObjectFromFile() throws JAXBException {
        JAXBContext jc = JAXBContext.newInstance(Person.class);
        Unmarshaller unmarshaller = jc.createUnmarshaller();
        File xmlFile = new File("C:/tmp/files/person2.xml");
        Person person = (Person) unmarshaller.unmarshal(xmlFile);
        System.out.println(person.getFirstName() + " " + person.getLastName());
    }

In both of the above examples, we did not perform any custom transformation of the data - and we did not need to use JAXBSource (or JAXBResult - see below).

Simple marshalling and unmarshalling was sufficient.

Example 3 - Transforming from Object to File

    public void transformObjectToFile() throws JAXBException,
            TransformerConfigurationException, TransformerException, IOException {
        JAXBContext jc = JAXBContext.newInstance(Person.class);
        Person person = new Person();
        person.setFirstName("John");
        person.setLastName("Smith");

        JAXBSource source = new JAXBSource(jc, person);
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer t = tf.newTransformer(new StreamSource("C:/tmp/files/person.xslt"));

        Writer writer = new FileWriter("C:/tmp/files/person.xml");
        t.transform(source, new StreamResult(writer));
    }

In example 3 there is more code - and a new XSLT file, which contains the transformation rules we want to apply to the XML generated from the Person object. This is where we use the JAXBSource constructor from your question.

In my test, I used a XSLT file which does not actually change the XML - it just passes it through unchanged from the Java object to the XML file:

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="node()|@*">
      <xsl:copy>
        <xsl:apply-templates select="node()|@*"/>
      </xsl:copy>
    </xsl:template>
</xsl:stylesheet>

But if I wanted to re-arrange the XML, this is where those instructions would be placed.

Example 4 - Transforming from File to Object

This final example is the reverse of example 3. It takes the example 3 file and creates a new Person object:

    public void transformFileToObject() throws JAXBException,
            TransformerConfigurationException, TransformerException {
        JAXBContext jc = JAXBContext.newInstance(Person.class);

        JAXBResult result = new JAXBResult(jc);
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer t = tf.newTransformer(new StreamSource("C:/tmp/files/person.xslt"));

        t.transform(new StreamSource("C:/tmp/files/person.xml"), result);

        Person person = (Person) result.getResult();
        System.out.println(person.getFirstName() + " " + person.getLastName());
    }

Again, the transformation I use is "no transformation at all", in my example.

Finally, here are all the related imports for the above:

import java.io.File;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.util.JAXBSource;
import javax.xml.bind.util.JAXBResult;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import java.io.Writer;
import java.io.FileWriter;
import java.io.IOException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;