JAXB creando contexto y costos de ordenadores

La pregunta es un poco teórica, ¿cuál es el costo de crear un contexto JAXB, marshaller y unmarshaller?

Descubrí que mi código podría beneficiarse de mantener el mismo contexto JAXB y posiblemente el mismo marshaller para todas las operaciones de clasificación en lugar de crear contexto y marshaller en cada clasificación.

Entonces, ¿cuál es el costo de crear contexto JAXB y marshaller / unmarshaller? ¿Está bien crear context + marshaller para cada operación de ordenación o es mejor evitarlo?

Nota: Soy el líder de EclipseLink JAXB (MOXy) y miembro del grupo de expertos JAXB 2 ( JSR-222 ).

JAXBContextes seguro para subprocesos y solo debe crearse una vez y reutilizarse para evitar el costo de inicializar los metadatos varias veces. Marshallery Unmarshallerno son seguros para subprocesos, pero son livianos de crear y podrían crearse por operación.

Idealmente, debería tener un singleton JAXBContexte instancias locales de Marshallery Unmarshaller.

JAXBContextinstancias son thread-safe mientras Marshallery Unmarshallercasos son no thread-safe y nunca deben ser compartidos a través de las roscas.

Es una pena que esto no se describa específicamente en el javadoc. Lo que puedo decir es que Spring usa un JAXBContext global, compartido entre subprocesos, mientras que crea un nuevo marshaller para cada operación de marshalling, con un comentario javadoc en el código que dice que los marshallers de JAXB no son necesariamente seguros para subprocesos.

Lo mismo se dice en esta página: https://javaee.github.io/jaxb-v2/doc/user-guide/ch03.html#other-mistionary-topics-performance-and-thread-safety .

Supongo que crear un JAXBContext es una operación costosa, porque implica escanear clases y paquetes en busca de anotaciones. Pero medirlo es la mejor manera de saberlo.

JAXB 2.2 ( JSR-222 ) tiene esto que decir, en la sección "4.2 JAXBContext":

Para evitar la sobrecarga que implica la creación de una JAXBContextinstancia, se recomienda a una aplicación JAXB que reutilice una instancia JAXBContext . Se requiere una implementación de la clase abstracta JAXBContext para ser segura para subprocesos , por lo tanto, varios subprocesos en una aplicación pueden compartir la misma instancia de JAXBContext.

[..]

La clase JAXBContext está diseñada para ser inmutable y, por lo tanto, segura para subprocesos. Dada la cantidad de procesamiento dinámico que potencialmente podría tener lugar al crear una nueva instancia de JAXBContxt, se recomienda que una instancia de JAXBContext se comparta entre subprocesos y se reutilice tanto como sea posible para mejorar el rendimiento de la aplicación.

Desafortunadamente, la especificación no hace ninguna afirmación con respecto a la seguridad de subprocesos de Unmarshallery Marshaller. Por lo que es mejor asumir que no lo son.

Resolví este problema usando:

• JAXBContext seguro para subprocesos compartidos y un / marschallers local de subprocesos
• (entonces, teóricamente, habrá tantas instancias un / marshaller como subprocesos que accedieron a ellas)
• con sincronización solo en la inicialización de un / marshaller .

public class MyClassConstructor {
    private final ThreadLocal<Unmarshaller> unmarshallerThreadLocal = new ThreadLocal<Unmarshaller>() {
        protected synchronized Unmarshaller initialValue() {
            try {
                return jaxbContext.createUnmarshaller();
            } catch (JAXBException e) {
                throw new IllegalStateException("Unable to create unmarshaller");
            }
        }
    };
    private final ThreadLocal<Marshaller> marshallerThreadLocal = new ThreadLocal<Marshaller>() {
        protected synchronized Marshaller initialValue() {
            try {
                return jaxbContext.createMarshaller();
            } catch (JAXBException e) {
                throw new IllegalStateException("Unable to create marshaller");
            }
        }
    };

    private final JAXBContext jaxbContext;

    private MyClassConstructor(){
        try {
            jaxbContext = JAXBContext.newInstance(Entity.class);
        } catch (JAXBException e) {
            throw new IllegalStateException("Unable to initialize");
        }
    }
}

¡¡Aun mejor!! Según la buena solución de la publicación anterior, cree el contexto solo una vez en el constructor y guárdelo en lugar de la clase.

Reemplazar la línea:

  private Class clazz;

Con este:

  private JAXBContext jc;

Y el constructor principal con este:

  private Jaxb(Class clazz)
  {
     this.jc = JAXBContext.newInstance(clazz);
  }

entonces en getMarshaller / getUnmarshaller puede eliminar esta línea:

  JAXBContext jc = JAXBContext.newInstance(clazz);

Esta mejora hace, en mi caso, que los tiempos de procesamiento bajen de 60 ~ 70ms a solo 5 ~ 10ms

Normalmente resuelvo problemas como este con un ThreadLocalpatrón de clase. Dado que necesita un marshaller diferente para cada clase, puede combinarlo con un singletonpatrón -map.

Para ahorrarle 15 minutos de trabajo. Aquí sigue mi implementación de una fábrica segura para subprocesos para Jaxb Marshallers y Unmarshallers.

Le permite acceder a las instancias de la siguiente manera ...

Marshaller m = Jaxb.get(SomeClass.class).getMarshaller();
Unmarshaller um = Jaxb.get(SomeClass.class).getUnmarshaller();

Y el código que necesitará es una pequeña clase Jaxb que tiene el siguiente aspecto:

public class Jaxb
{
  // singleton pattern: one instance per class.
  private static Map<Class,Jaxb> singletonMap = new HashMap<>();
  private Class clazz;

  // thread-local pattern: one marshaller/unmarshaller instance per thread
  private ThreadLocal<Marshaller> marshallerThreadLocal = new ThreadLocal<>();
  private ThreadLocal<Unmarshaller> unmarshallerThreadLocal = new ThreadLocal<>();

  // The static singleton getter needs to be thread-safe too, 
  // so this method is marked as synchronized.
  public static synchronized Jaxb get(Class clazz)
  {
    Jaxb jaxb =  singletonMap.get(clazz);
    if (jaxb == null)
    {
      jaxb = new Jaxb(clazz);
      singletonMap.put(clazz, jaxb);
    }
    return jaxb;
  }

  // the constructor needs to be private, 
  // because all instances need to be created with the get method.
  private Jaxb(Class clazz)
  {
     this.clazz = clazz;
  }

  /**
   * Gets/Creates a marshaller (thread-safe)
   * @throws JAXBException
   */
  public Marshaller getMarshaller() throws JAXBException
  {
    Marshaller m = marshallerThreadLocal.get();
    if (m == null)
    {
      JAXBContext jc = JAXBContext.newInstance(clazz);
      m = jc.createMarshaller();
      marshallerThreadLocal.set(m);
    }
    return m;
  }

  /**
   * Gets/Creates an unmarshaller (thread-safe)
   * @throws JAXBException
   */
  public Unmarshaller getUnmarshaller() throws JAXBException
  {
    Unmarshaller um = unmarshallerThreadLocal.get();
    if (um == null)
    {
      JAXBContext jc = JAXBContext.newInstance(clazz);
      um = jc.createUnmarshaller();
      unmarshallerThreadLocal.set(um);
    }
    return um;
  }
}