cuando hace JAXB unmarshaller.unmarshal devuelve un JAXBElement o un MySchemaObject?

Depende de la presencia de anotación XmlRootElement en la clase de su elemento raíz.

Si genera sus clases JAXB desde un XSD, se aplican las siguientes reglas:

• si el tipo del elemento raíz es un tipo anónimo - > Se añade una anotación XmlRootElement a la clase generada
• si el tipo del elemento raíz es un tipo de nivel superior - > la anotación XmlRootElement se omite de la clase generada

Por eso a menudo elija tipos anónimos para los elementos raíz.

Puede personalizar el nombre de clase de este tipo anónimo con un archivo de personalización. Por ejemplo, crear enlaces.archivo xjc como este:

<jxb:bindings version="1.0"
              xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
              xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <jxb:bindings schemaLocation="yourXsd.xsd" node="/xs:schema">
        <jxb:bindings  node="//xs:element[@name='yourRootElement']">
            <jxb:class name="YourRootElementType"/>
        </jxb:bindings> 
    </jxb:bindings>
</jxb:bindings>

Necesita agregar a su clase generada por JAXB @XMLRootElement- debe tener un espacio de nombres:

@XmlRootElement(namespace="http://your.namespace.com/", name="yourRootElement")

Eche un vistazo a la pregunta relacionada (hay muchos buenos consejos): Excepción de conversión de clase al intentar desmarcar xml?

Modificando las clases java generadas, no estoy de acuerdo. No permitir todo el formato xsd posible, no estoy de acuerdo.

Gracias a todas sus explicaciones y enlaces, este es el código que he escrito para cuidar de ambos casos, utilizando la Introspección de Anotación. Funciona tanto para la salida como para la entrada, y es (a mi gusto) más genérico:

public class JaxbWrapper {

    private static boolean isXmlRootElement(Class classT){

        Annotation[] annotations = classT.getAnnotations();

        for(Annotation annotation : annotations){
            if(annotation instanceof XmlRootElement){
                return true;
            }
        }       

        return false;
    }

    public static Object unmarshall(Class classObjectFactory, Class classObject, XMLStreamReader xmlStreamReader){

        Package pack = classObjectFactory.getPackage();
        String strPackageName = pack.getName();

        Object returnObject = null;

        try {
            JAXBContext jc = JAXBContext.newInstance(strPackageName, classObjectFactory.getClassLoader());

            Unmarshaller unmarshaller = jc.createUnmarshaller();

            returnObject = unmarshaller.unmarshal( xmlStreamReader );

            boolean bIsRootedElement = isXmlRootElement(classObject);
            if(!bIsRootedElement)
            {
                JAXBElement jaxbElement = (JAXBElement) returnObject;
                returnObject = jaxbElement.getValue();              
            }
        }
        catch (JAXBException e) {
            /*...*/
        }   

        return returnObject;
    }

    private static void writeToXml(Class classObjectFactory, Object obj, XMLStreamWriter xmlStreamWriter){

        Package pack = classObjectFactory.getPackage();
        String strPackageName = pack.getName();

        try {       
            JAXBContext jc = JAXBContext.newInstance(strPackageName, classObjectFactory.getClassLoader());
            Marshaller marshaller = jc.createMarshaller();
            marshaller.marshal(obj, xmlStreamWriter);
        }
        catch(JAXBException e) {
            /*...*/
        }       
    }

    public static String marshall(Class classObjectFactory, Class classObject, Object obj){

        Object objectToMarshall = obj; 

        boolean bIsRootedElement = isXmlRootElement(classObject);
        if(!bIsRootedElement)
        {
            Package pack = classObjectFactory.getPackage();
            String strPackageName = pack.getName();

            String strClassName = classObject.getName();

            QName qName = new QName(strPackageName, strClassName);

            JAXBElement jaxbElement = new JAXBElement(qName, classObject, null, obj);

            objectToMarshall = jaxbElement; 
        }

        StringWriter sw = new StringWriter();
        XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();
        XMLStreamWriter xmlStreamWriter = null;

        try {
            xmlStreamWriter = xmlOutputFactory.createXMLStreamWriter(sw);

            writeToXml(classObjectFactory, objectToMarshall, xmlStreamWriter);

            xmlStreamWriter.flush();
            xmlStreamWriter.close();
        } 
        catch (XMLStreamException e) {
            /*...*/
        }

        return sw.toString();
    }
}

Tengo el mismo problema. JAXB unmarshaller.unmarshal devuelve un JAXBElement<MyObject> en lugar del MyObject deseado.

Encontré y eliminé @XmlElementDecl. El problema está resuelto.