Conversión simple entre java.util.Date y XMLGregorianCalendar

datetime jaxb

Question

Estoy buscando un método simple de conversión entre java.util.Date y javax.xml.datatype.XMLGregorianCalendar en ambas direcciones.

Aquí está el código que estoy usando ahora :

import java.util.GregorianCalendar;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;

/**
 * Utility class for converting between XMLGregorianCalendar and java.util.Date
 */
public class XMLGregorianCalendarConverter {  

    /**
     * Needed to create XMLGregorianCalendar instances
     */
    private static DatatypeFactory df = null;
    static {
        try {
            df = DatatypeFactory.newInstance();
        } catch (DatatypeConfigurationException dce) {
            throw new IllegalStateException(
                "Exception while obtaining DatatypeFactory instance", dce);
        }
    }  

    /**
     * Converts a java.util.Date into an instance of XMLGregorianCalendar
     *
     * @param date Instance of java.util.Date or a null reference
     * @return XMLGregorianCalendar instance whose value is based upon the
     *  value in the date parameter. If the date parameter is null then
     *  this method will simply return null.
     */
    public static XMLGregorianCalendar asXMLGregorianCalendar(java.util.Date date) {
        if (date == null) {
            return null;
        } else {
            GregorianCalendar gc = new GregorianCalendar();
            gc.setTimeInMillis(date.getTime());
            return df.newXMLGregorianCalendar(gc);
        }
    }

    /**
     * Converts an XMLGregorianCalendar to an instance of java.util.Date
     *
     * @param xgc Instance of XMLGregorianCalendar or a null reference
     * @return java.util.Date instance whose value is based upon the
     *  value in the xgc parameter. If the xgc parameter is null then
     *  this method will simply return null.
     */
    public static java.util.Date asDate(XMLGregorianCalendar xgc) {
        if (xgc == null) {
            return null;
        } else {
            return xgc.toGregorianCalendar().getTime();
        }
    }
}

¿Hay algo más simple, como alguna llamada API que he pasado por alto?

La conversión entre una fecha / hora XML estándar y un objeto de fecha de Java parece una tarea bastante rutinaria y me sorprende que tenga que escribir este código.

¿Alguna sugerencia?

NOTAS: Mis clases JAXB se autogeneran desde un esquema. El proceso de compilación en mi proyecto no me permite hacer cambios manuales en las clases generadas. XJC está generando los elementos xs: dateTime como XMLGregorianCalendar en las clases de JAXB. El esquema se amplía y modifica periódicamente, por lo que puedo realizar cambios limitados en el archivo XSD del esquema.

ACTUALIZACIÓN EN LA SOLUCIÓN: la solución propuesta por Blaise me ha permitido sacar XMLGregorianCalendar de la mezcla y tratar con objetos java.util.Calendar en su lugar. Al agregar una cláusula de enlace JAXB en la parte superior de mi archivo de esquema, XJC puede generar asignaciones más apropiadas para xs: dateTime en mis clases JAXB. Aquí hay algunos fragmentos que muestran las modificaciones en mi archivo XSD.

El elemento raíz en el archivo XSD:

<xs:schema xmlns:mydata="http://my.example.com/mydata" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:jaxb="http://java.sun.com/xml/ns/jaxb" targetNamespace="http://my.example.com/mydata" elementFormDefault="unqualified" attributeFormDefault="unqualified" version="0.2" xml:lang="en" jaxb:version="2.0">

Bloque de anotación de enlace JAXB, insertado inmediatamente después del elemento raíz en XSD:

<xs:annotation>
    <xs:appinfo>
        <jaxb:globalBindings>
            <jaxb:javaType name="java.util.Calendar" xmlType="xs:dateTime" parseMethod="javax.xml.bind.DatatypeConverter.parseDateTime" printMethod="javax.xml.bind.DatatypeConverter.printDateTime" />
        </jaxb:globalBindings>
    </xs:appinfo>
</xs:annotation>

Como el campo XML xs: dateTime también almacena la zona horaria, podría ser mejor para mí trabajar con Calendar en lugar de con Date, ya que los objetos Calendar tienen una API bastante buena para trabajar con configuraciones regionales y zonas horarias. En cualquier caso, estoy mucho más contento de lidiar con objetos de Calendar en lugar de XMLGregorianCalendar. Ya no es necesario que los métodos de conversión que mencioné anteriormente. No llegué a java.util.Date, pero lo suficientemente cerca!

Answer 1

¿Por qué no usar un archivo de enlace externo para decirle a XJC que genere campos java.util.Date en lugar de XMLGregorianCalendar?

Ver también: - http://weblogs.java.net/blog/kohsuke/archive/2006/03/how_do_i_map_xs.html

Answer 2

Desde XMLGregorianCalendar hasta java.util.Date puedes simplemente hacer:

java.util.Date dt = xmlGregorianCalendarInstance.toGregorianCalendar().getTime();  

Answer 3

Desde java.util.Date hasta XMLGregorianCalendar puedes simplemente hacer:

import javax.xml.datatype.XMLGregorianCalendar;
import javax.xml.datatype.DatatypeFactory;
import java.util.GregorianCalendar;
......
GregorianCalendar gcalendar = new GregorianCalendar();
gcalendar.setTime(yourDate);
XMLGregorianCalendar xmlDate = DatatypeFactory.newInstance().newXMLGregorianCalendar(gcalendar);

Código editado después del primer comentario de @ f-puras, por causa que cometo un error.

Answer 4

Personalizar el calendario y la fecha mientras Marshaling

Paso 1: prepare jaxb binding xml para las propiedades personalizadas, en este caso preparé la fecha y el calendario

<jaxb:bindings version="2.1" xmlns:jaxb="http://java.sun.com/xml/ns/jaxb"
xmlns:xjc="http://java.sun.com/xml/ns/jaxb/xjc" 
xmlns:xs="http://www.w3.org/2001/XMLSchema">
<jaxb:globalBindings generateElementProperty="false">
<jaxb:serializable uid="1" />
<jaxb:javaType name="java.util.Date" xmlType="xs:date"
    parseMethod="org.apache.cxf.tools.common.DataTypeAdapter.parseDate"
    printMethod="com.stech.jaxb.util.CalendarTypeConverter.printDate" />
<jaxb:javaType name="java.util.Calendar" xmlType="xs:dateTime"
    parseMethod="javax.xml.bind.DatatypeConverter.parseDateTime"
    printMethod="com.stech.jaxb.util.CalendarTypeConverter.printCalendar" />

Setp 2: Agregue el archivo de enlace jaxb personalizado a Apache o cualquier complemento relacionado en la opción xsd como se menciona a continuación

<xsdOption>
  <xsd>${project.basedir}/src/main/resources/tutorial/xsd/yourxsdfile.xsd</xsd>
  <packagename>com.tutorial.xml.packagename</packagename>
  <bindingFile>${project.basedir}/src/main/resources/xsd/jaxbbindings.xml</bindingFile>
</xsdOption>

Setp 3: escribe el código para la clase CalendarConverter

package com.stech.jaxb.util;

import java.text.SimpleDateFormat;

/**
 * To convert the calendar to JaxB customer format.
 * 
 */

public final class CalendarTypeConverter {

    /**
     * Calendar to custom format print to XML.
     * 
     * @param val
     * @return
     */
    public static String printCalendar(java.util.Calendar val) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd''T''hh:mm:ss");
        return simpleDateFormat.format(val.getTime());
    }

    /**
     * Date to custom format print to XML.
     * 
     * @param val
     * @return
     */
    public static String printDate(java.util.Date val) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        return simpleDateFormat.format(val);
    }
}

Setp 4: Salida

  <xmlHeader>
   <creationTime>2014-09-25T07:23:05</creationTime> Calendar class formatted

   <fileDate>2014-09-25</fileDate> - Date class formatted
</xmlHeader>

Answer 5

Puede usar esta personalización para cambiar la asignación predeterminada a java.util.Date

<xsd:annotation>
<xsd:appinfo>
    <jaxb:globalBindings>
        <jaxb:javaType name="java.util.Date" xmlType="xsd:dateTime"
                 parseMethod="org.apache.cxf.xjc.runtime.DataTypeAdapter.parseDateTime"
                 printMethod="org.apache.cxf.xjc.runtime.DataTypeAdapter.printDateTime"/>
    </jaxb:globalBindings>
</xsd:appinfo>

Answer 6

Tuve que hacer algunos cambios para que funcione, ya que algunas cosas parecen haber cambiado mientras tanto:

• xjc se quejaría de que mi adaptador no extiende XmlAdapter
• se incluyeron algunas importaciones extrañas e innecesarias (org.w3._2001.xmlschema)
• los métodos de análisis no deben ser estáticos al extender XmlAdapter, obviamente

Aquí hay un ejemplo de trabajo, espero que esto ayude (estoy usando JodaTime, pero en este caso SimpleDate sería suficiente):

import java.util.Date;
import javax.xml.bind.DatatypeConverter;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import org.joda.time.DateTime;

public class DateAdapter extends XmlAdapter<Object, Object> {
    @Override
    public Object marshal(Object dt) throws Exception {
        return new DateTime((Date) dt).toString("YYYY-MM-dd");
    }

    @Override
        public Object unmarshal(Object s) throws Exception {
        return DatatypeConverter.parseDate((String) s).getTime();
    }
}

En el xsd, he seguido las excelentes referencias dadas anteriormente, así que he incluido esta anotación xml:

<xsd:appinfo>
    <jaxb:schemaBindings>
        <jaxb:package name="at.mycomp.xml" />
    </jaxb:schemaBindings>
    <jaxb:globalBindings>
        <jaxb:javaType name="java.util.Date" xmlType="xsd:date"
              parseMethod="at.mycomp.xml.DateAdapter.unmarshal"
          printMethod="at.mycomp.xml.DateAdapter.marshal" />
    </jaxb:globalBindings>
</xsd:appinfo>

Answer 7

Yo también tuve este tipo de dolor de cabeza. Me deshice de él simplemente representando los campos de tiempo como primitivos largos en mi POJO. Ahora la generación de mi código de cliente de WS maneja todo correctamente y no más basura de XML a Java. Y, por supuesto, tratar con millis en el lado de Java es simple e indolora. KISS principio rocas!