This sample code shows how to:
▸ Use the JAXB API to marshal java objects into XML data.
▸ Use the JAXB API to unmarshal XML data into java objects.

The test examples (TestMarshaller.java, TestUnmarshaller.java) are based on the sample code of this page: [Sample] JAXB Maven Plugin

|+ ${project.basedir}
   |+ src
      |+ main
         |+ java
            |+ TestMarshaller.java
            |+ TestUnmarshaller.java
            |+ mtitek.jaxb.samples.utils
               |+ ResourceUtils.java
               |+ JAXBContextUtils.java
               |+ SchemaUtils.java
               |+ MarshallerUtils.java
               |+ UnmarshallerUtils.java

<dependencies>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.4</version>
    </dependency>

    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.5</version>
    </dependency>
</dependencies>

package mtitek.jaxb.samples.utils;

import java.io.IOException;
import java.io.InputStream;

import org.apache.commons.io.IOUtils;

public class ResourceUtils {
    private ResourceUtils() {
    }

    public static InputStream getResourceAsStream(final String fileName) {
        return Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName);
    }

    public static String getResourceAsString(final String fileName) throws IOException {
        try (final InputStream inputStream = ResourceUtils.getResourceAsStream(fileName)) {
            return IOUtils.toString(inputStream, "UTF-8");
        }
    }
}

package mtitek.jaxb.samples.utils;

import java.util.Optional;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;

import org.apache.commons.lang3.ArrayUtils;

public class JAXBContextUtils {
    private JAXBContextUtils() {
    }

    public static <T> Optional<JAXBContext> getJAXBContext(final Class<T> mainClassToBeBound, final Class<?>... classesToBeBound) throws JAXBException {
        return Optional.ofNullable(JAXBContext.newInstance(ArrayUtils.add(classesToBeBound, mainClassToBeBound)));
    }
}

package mtitek.jaxb.samples.utils;

import java.io.IOException;
import java.util.Optional;
import java.util.stream.Stream;

import javax.xml.XMLConstants;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;

import org.apache.commons.lang3.ArrayUtils;
import org.xml.sax.SAXException;

public class SchemaUtils {
    private SchemaUtils() {
    }

    public static Optional<Schema> getSchema(final String... filesNames) throws SAXException, IOException {
        Schema schema = null;
        StreamSource[] streamSources = null;

        if (!ArrayUtils.isEmpty(filesNames)) {
            try {
                streamSources = Stream.of(filesNames)
                        .map(fileName -> ResourceUtils.getResourceAsStream(fileName))
                        .filter(inputStream -> inputStream != null)
                        .map(inputStream -> new StreamSource(inputStream))
                        .toArray(StreamSource[]::new);

                if (!ArrayUtils.isEmpty(streamSources)) {
                    final SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);

                    schema = schemaFactory.newSchema(streamSources);
                }
            } finally {
                if (!ArrayUtils.isEmpty(streamSources)) {
                    Stream.of(streamSources).forEach(streamSource -> {
                        try {
                            streamSource.getInputStream().close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    });
                }
            }
        }

        return Optional.ofNullable(schema);
    }
}

package mtitek.jaxb.samples.utils;

import java.io.OutputStream;
import java.util.Optional;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.namespace.QName;

public class MarshallerUtils {
    private MarshallerUtils() {
    }

    public static <T> void marshal(final OutputStream outputStream, final T object, final Class<T> mainClassToBeBound, final Class<?>... classesToBeBound) throws JAXBException {
        final Optional<Marshaller> optionalMarshaller = MarshallerUtils.createMarshaller(mainClassToBeBound, classesToBeBound);

        if (optionalMarshaller.isPresent()) {
            Marshaller marshaller = optionalMarshaller.get();

            marshaller.marshal(object, outputStream);
        } else {
            System.out.println("Failed to create the marshaller!");
        }
    }

    private static <T> Optional<Marshaller> createMarshaller(final Class<T> mainClassToBeBound, final Class<?>... classesToBeBound) throws JAXBException {
        final Optional<JAXBContext> jaxbContext = JAXBContextUtils.getJAXBContext(mainClassToBeBound, classesToBeBound);

        Marshaller marshaller = null;

        if (jaxbContext.isPresent()) {
            marshaller = jaxbContext.get().createMarshaller();

            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
        }

        return Optional.ofNullable(marshaller);
    }
}

package mtitek.jaxb.samples.utils;

import java.io.InputStream;
import java.util.Optional;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.helpers.DefaultValidationEventHandler;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;

public class UnmarshallerUtils {
    private UnmarshallerUtils() {
    }

    public static <T> Optional<T> unmarshal(final InputStream inputStream, final Schema schema, final Class<T> mainClassToBeBound, final Class<?>... classesToBeBound) throws JAXBException {
        final Optional<Unmarshaller> optionalUnmarshaller = UnmarshallerUtils.createUnmarshaller(mainClassToBeBound, classesToBeBound);

        T instance = null;

        if (optionalUnmarshaller.isPresent()) {
            Unmarshaller unmarshaller = optionalUnmarshaller.get();

            if (schema != null) {
                unmarshaller.setSchema(schema);
                unmarshaller.setEventHandler(new DefaultValidationEventHandler());
            }

            final StreamSource streamSource = new StreamSource(inputStream);

            final JAXBElement<T> jaxBElement = unmarshaller.unmarshal(streamSource, mainClassToBeBound);

            if (jaxBElement != null) {
                instance = jaxBElement.getValue();
            }
        } else {
            System.out.println("Failed to create the unmarshaller!");
        }

        return Optional.ofNullable(instance);
    }

    private static <T> Optional<Unmarshaller> createUnmarshaller(final Class<T> mainClassToBeBound, final Class<?>... classesToBeBound) throws JAXBException {
        final Optional<JAXBContext> jaxbContext = JAXBContextUtils.getJAXBContext(mainClassToBeBound, classesToBeBound);

        Unmarshaller unmarshaller = null;

        if (jaxbContext.isPresent()) {
            unmarshaller = jaxbContext.get().createUnmarshaller();
        }

        return Optional.ofNullable(unmarshaller);
    }
}

import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.TimeZone;

import javax.xml.bind.JAXBException;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;

import mtitek.jaxb.samples.payload.ParameterType;
import mtitek.jaxb.samples.payload.Payload;
import mtitek.jaxb.samples.payload.PayloadDataType;
import mtitek.jaxb.samples.payload.data.DataType;
import mtitek.jaxb.samples.payload.data.DateDataType;
import mtitek.jaxb.samples.payload.data.TextDataType;
import mtitek.jaxb.samples.utils.MarshallerUtils;

public class TestMarshaller {
    public static void main(String[] args) throws Exception {
        final Payload payload = initPayload();

        try (final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
            MarshallerUtils.marshal(byteArrayOutputStream, payload, Payload.class, PayloadDataType.class, DataType.class, TextDataType.class, DateDataType.class);

            System.out.println(byteArrayOutputStream.toString("UTF-8"));
        }
    }

    private static Payload initPayload() throws JAXBException, DatatypeConfigurationException {
        final Payload payload = new Payload();

        payload.setId("1");
        payload.setCode("111");

        final List<ParameterType> parameters = new ArrayList<>();
        {
            final ParameterType parameter = new ParameterType();
            parameter.setId("2");
            parameter.setName("nnnn");
            parameter.setValue("vvvv");
            parameters.add(parameter);
        }

        payload.setParameters(parameters);

        final PayloadDataType payloadData = new PayloadDataType();
        payload.setPayloadData(payloadData);

        final List<Object> values = new ArrayList<>();

        {
            final GregorianCalendar gregorianCalendar = new GregorianCalendar(2015, Calendar.SEPTEMBER, 2, 21, 49, 30);
            gregorianCalendar.setTimeZone(TimeZone.getTimeZone("GMT"));

            final XMLGregorianCalendar xmlGregorianCalendar = DatatypeFactory.newInstance().newXMLGregorianCalendar(gregorianCalendar);

            final DateDataType dateData = new DateDataType();
            dateData.setId("31");
            dateData.setValue(xmlGregorianCalendar);

            final DataType data = new DataType();
            data.setId("3");
            data.setValue(dateData);

            values.add(data);
        }

        {
            final TextDataType textData = new TextDataType();
            textData.setId("41");
            textData.setValue("aaaa");

            final DataType data = new DataType();
            data.setId("4");
            data.setValue(textData);

            values.add(data);
        }

        payloadData.setValues(values);

        return payload;
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.util.Optional;

import javax.xml.bind.JAXBException;
import javax.xml.validation.Schema;

import org.xml.sax.SAXException;

import mtitek.jaxb.samples.payload.Payload;
import mtitek.jaxb.samples.payload.PayloadDataType;
import mtitek.jaxb.samples.payload.data.DataType;
import mtitek.jaxb.samples.payload.data.DateDataType;
import mtitek.jaxb.samples.payload.data.TextDataType;
import mtitek.jaxb.samples.utils.ResourceUtils;
import mtitek.jaxb.samples.utils.SchemaUtils;
import mtitek.jaxb.samples.utils.UnmarshallerUtils;

public class TestUnmarshaller {
    public static void main(String[] args) throws SAXException, IOException, JAXBException {
        final Optional<Schema> schema = SchemaUtils.getSchema("payload.xsd", "payloadData.xsd");

        if (schema.isPresent()) {
            try (final InputStream inputStream = ResourceUtils.getResourceAsStream("payload.xml")) {

                final Optional<Payload> optionalPayload = UnmarshallerUtils.unmarshal(inputStream, schema.get(), Payload.class, PayloadDataType.class, DataType.class, TextDataType.class, DateDataType.class);

                if (optionalPayload.isPresent()) {
                    final Payload payload = optionalPayload.get();

                    System.out.println(payload);
                }
            }
        }
    }
}