javax.xml.bind

## Class Binder<XmlNode>

- java.lang.Object
- - javax.xml.bind.Binder<XmlNode>

-     public abstract class Binder<XmlNode>
      extends Object

  Enable synchronization between XML infoset nodes and JAXB objects representing same XML document.

  An instance of this class maintains the association between XML nodes of an infoset preserving view and a JAXB representation of an XML document. Navigation between the two views is provided by the methods `getXMLNode(Object)` and `getJAXBNode(Object)`.

  Modifications can be made to either the infoset preserving view or the JAXB representation of the document while the other view remains unmodified. The binder is able to synchronize the changes made in the modified view back into the other view using the appropriate Binder update methods, `updateXML(Object, Object)` or `updateJAXB(Object)`.

  A typical usage scenario is the following:

  - load XML document into an XML infoset representation
  - `unmarshal(Object)` XML infoset view to JAXB view. (Note to conserve resources, it is possible to only unmarshal a subtree of the XML infoset view to the JAXB view.)
  - application access/updates JAXB view of XML document.
  - `updateXML(Object)` synchronizes modifications to JAXB view back into the XML infoset view. Update operation preserves as much of original XML infoset as possible (i.e. comments, PI, ...)

  A Binder instance is created using the factory method `JAXBContext.createBinder()` or `JAXBContext.createBinder(Class)`.

  The template parameter, `XmlNode`, is the root interface/class for the XML infoset preserving representation. A Binder implementation is required to minimally support an `XmlNode` value of `org.w3c.dom.Node.class`. A Binder implementation can support alternative XML infoset preserving representations.

  Since:
    JAXB 2.0
  Author:
    Kohsuke Kawaguchi (kohsuke.kawaguchi@sun.com) Joseph Fialli

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `Binder()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `abstract ValidationEventHandler` | `getEventHandler()` Return the current event handler or the default event handler if one hasn't been set.
    `abstract Object` | `getJAXBNode(XmlNode xmlNode)` Gets the JAXB object associated with the given XML element.
    `abstract Object` | `getProperty(String name)` Get the particular property in the underlying implementation of `Binder`.
    `abstract Schema` | `getSchema()` Gets the last `Schema` object (including null) set by the `setSchema(Schema)` method.
    `abstract XmlNode` | `getXMLNode(Object jaxbObject)` Gets the XML element associated with the given JAXB object.
    `abstract void` | `marshal(Object jaxbObject, XmlNode xmlNode)` Marshal a JAXB object tree to a new XML document.
    `abstract void` | `setEventHandler(ValidationEventHandler handler)` Allow an application to register a `ValidationEventHandler`.
    `abstract void` | `setProperty(String name, Object value)` Set the particular property in the underlying implementation of `Binder`.
    `abstract void` | `setSchema(Schema schema)` Specifies whether marshal, unmarshal and update methods performs validation on their XML content.
    `abstract Object` | `unmarshal(XmlNode xmlNode)` Unmarshal XML infoset view to a JAXB object tree.
    `abstract <T> JAXBElement<T>` | `unmarshal(XmlNode xmlNode, Class<T> declaredType)` Unmarshal XML root element by provided `declaredType` to a JAXB object tree.
    `abstract Object` | `updateJAXB(XmlNode xmlNode)` Takes an XML node and updates its associated JAXB object and its descendants.
    `abstract XmlNode` | `updateXML(Object jaxbObject)` Takes an JAXB object and updates its associated XML node and its descendants.
    `abstract XmlNode` | `updateXML(Object jaxbObject, XmlNode xmlNode)` Changes in JAXB object tree are updated in its associated XML parse tree.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### Binder

          public Binder()

  - ### Method Detail

    - #### unmarshal

          public abstract Object unmarshal(XmlNode xmlNode)
                                    throws JAXBException

      Unmarshal XML infoset view to a JAXB object tree.

      This method is similar to `Unmarshaller.unmarshal(Node)` with the addition of maintaining the association between XML nodes and the produced JAXB objects, enabling future update operations, `updateXML(Object, Object)` or `updateJAXB(Object)`.

      When `getSchema()` is non-null, `xmlNode` and its descendants is validated during this operation.

      This method throws `UnmarshalException` when the Binder's `JAXBContext` does not have a mapping for the XML element name or the type, specifiable via `@xsi:type`, of `xmlNode` to a JAXB mapped class. The method `unmarshal(Object, Class)` enables an application to specify the JAXB mapped class that the `xmlNode` should be mapped to.

      Parameters:
        `xmlNode` - the document/element to unmarshal XML data from.
      Returns:
        the newly created root object of the JAXB object tree.
      Throws:
        `JAXBException` - If any unexpected errors occur while unmarshalling
        `UnmarshalException` - If the `ValidationEventHandler` returns false from its `handleEvent` method or the `Binder` is unable to perform the XML to Java binding.
        `IllegalArgumentException` - If the node parameter is null

    - #### unmarshal

          public abstract <T> JAXBElement<T> unmarshal(XmlNode xmlNode,
                                     Class<T> declaredType)
                                            throws JAXBException

      Unmarshal XML root element by provided `declaredType` to a JAXB object tree.

      Implements Unmarshal by Declared Type

      This method is similar to `Unmarshaller.unmarshal(Node, Class)` with the addition of maintaining the association between XML nodes and the produced JAXB objects, enabling future update operations, `updateXML(Object, Object)` or `updateJAXB(Object)`.

      When `getSchema()` is non-null, `xmlNode` and its descendants is validated during this operation.

      Parameters:
        `xmlNode` - the document/element to unmarshal XML data from.
        `declaredType` - appropriate JAXB mapped class to hold `node`'s XML data.
      Returns:
        JAXB Element representation of `node`
      Throws:
        `JAXBException` - If any unexpected errors occur while unmarshalling
        `UnmarshalException` - If the `ValidationEventHandler` returns false from its `handleEvent` method or the `Binder` is unable to perform the XML to Java binding.
        `IllegalArgumentException` - If any of the input parameters are null
      Since:
        JAXB2.0

    - #### marshal

          public abstract void marshal(Object jaxbObject,
                     XmlNode xmlNode)
                                throws JAXBException

      Marshal a JAXB object tree to a new XML document.

      This method is similar to `Marshaller.marshal(Object, Node)` with the addition of maintaining the association between JAXB objects and the produced XML nodes, enabling future update operations such as `updateXML(Object, Object)` or `updateJAXB(Object)`.

      When `getSchema()` is non-null, the marshalled xml content is validated during this operation.

      Parameters:
        `jaxbObject` - The content tree to be marshalled.
        `xmlNode` - The parameter must be a Node that accepts children.
      Throws:
        `JAXBException` - If any unexpected problem occurs during the marshalling.
        `MarshalException` - If the `ValidationEventHandler` returns false from its `handleEvent` method or the `Binder` is unable to marshal `jaxbObject` (or any object reachable from `jaxbObject`).
        `IllegalArgumentException` - If any of the method parameters are null

    - #### getXMLNode

          public abstract XmlNode getXMLNode(Object jaxbObject)

      Gets the XML element associated with the given JAXB object.

      Once a JAXB object tree is associated with an XML fragment, this method enables navigation between the two trees.

      An association between an XML element and a JAXB object is established by the bind methods and the update methods. Note that this association is partial; not all XML elements have associated JAXB objects, and not all JAXB objects have associated XML elements.

      Parameters:
        `jaxbObject` - An instance that is reachable from a prior call to a bind or update method that returned a JAXB object tree.
      Returns:
        null if the specified JAXB object is not known to this `Binder`, or if it is not associated with an XML element.
      Throws:
        `IllegalArgumentException` - If the jaxbObject parameter is null

    - #### getJAXBNode

          public abstract Object getJAXBNode(XmlNode xmlNode)

      Gets the JAXB object associated with the given XML element.

      Once a JAXB object tree is associated with an XML fragment, this method enables navigation between the two trees.

      An association between an XML element and a JAXB object is established by the unmarshal, marshal and update methods. Note that this association is partial; not all XML elements have associated JAXB objects, and not all JAXB objects have associated XML elements.

      Returns:
        null if the specified XML node is not known to this `Binder`, or if it is not associated with a JAXB object.
      Throws:
        `IllegalArgumentException` - If the node parameter is null

    - #### updateXML

          public abstract XmlNode updateXML(Object jaxbObject)
                                     throws JAXBException

      Takes an JAXB object and updates its associated XML node and its descendants.

      This is a convenience method of:

           updateXML( jaxbObject, getXMLNode(jaxbObject));

      Throws:
        `JAXBException` - If any unexpected problem occurs updating corresponding XML content.
        `IllegalArgumentException` - If the jaxbObject parameter is null

    - #### updateXML

          public abstract XmlNode updateXML(Object jaxbObject,
                          XmlNode xmlNode)
                                     throws JAXBException

      Changes in JAXB object tree are updated in its associated XML parse tree.

      This operation can be thought of as an "in-place" marshalling. The difference is that instead of creating a whole new XML tree, this operation updates an existing tree while trying to preserve the XML as much as possible.

      For example, unknown elements/attributes in XML that were not bound to JAXB will be left untouched (whereas a marshalling operation would create a new tree that doesn't contain any of those.)

      As a side-effect, this operation updates the association between XML nodes and JAXB objects.

      Parameters:
        `jaxbObject` - root of potentially modified JAXB object tree
        `xmlNode` - root of update target XML parse tree
      Returns:
        Returns the updated XML node. Typically, this is the same node you passed in as xmlNode, but it maybe a different object, for example when the tag name of the object has changed.
      Throws:
        `JAXBException` - If any unexpected problem occurs updating corresponding XML content.
        `IllegalArgumentException` - If any of the input parameters are null

    - #### updateJAXB

          public abstract Object updateJAXB(XmlNode xmlNode)
                                     throws JAXBException

      Takes an XML node and updates its associated JAXB object and its descendants.

      This operation can be thought of as an "in-place" unmarshalling. The difference is that instead of creating a whole new JAXB tree, this operation updates an existing tree, reusing as much JAXB objects as possible.

      As a side-effect, this operation updates the association between XML nodes and JAXB objects.

      Returns:
        Returns the updated JAXB object. Typically, this is the same object that was returned from earlier `marshal(Object,Object)` or `updateJAXB(Object)` method invocation, but it maybe a different object, for example when the name of the XML element has changed.
      Throws:
        `JAXBException` - If any unexpected problem occurs updating corresponding JAXB mapped content.
        `IllegalArgumentException` - If node parameter is null

    - #### setSchema

          public abstract void setSchema(Schema schema)

      Specifies whether marshal, unmarshal and update methods performs validation on their XML content.
      Parameters:
        `schema` - set to null to disable validation.
      See Also:
        `Unmarshaller.setSchema(Schema)`

    - #### getSchema

          public abstract Schema getSchema()

      Gets the last `Schema` object (including null) set by the `setSchema(Schema)` method.
      Returns:
        the Schema object for validation or null if not present

    - #### setEventHandler

          public abstract void setEventHandler(ValidationEventHandler handler)
                                        throws JAXBException

      Allow an application to register a `ValidationEventHandler`.

      The `ValidationEventHandler` will be called by the JAXB Provider if any validation errors are encountered during calls to any of the Binder unmarshal, marshal and update methods.

      Calling this method with a null parameter will cause the Binder to revert back to the default default event handler.

      Parameters:
        `handler` - the validation event handler
      Throws:
        `JAXBException` - if an error was encountered while setting the event handler

    - #### getEventHandler

          public abstract ValidationEventHandler getEventHandler()
                                                          throws JAXBException

      Return the current event handler or the default event handler if one hasn't been set.
      Returns:
        the current ValidationEventHandler or the default event handler if it hasn't been set
      Throws:
        `JAXBException` - if an error was encountered while getting the current event handler

    - #### setProperty

          public abstract void setProperty(String name,
                         Object value)
                                    throws PropertyException

      Set the particular property in the underlying implementation of `Binder`. This method can only be used to set one of the standard JAXB defined unmarshal/marshal properties or a provider specific property for binder, unmarshal or marshal. Attempting to set an undefined property will result in a PropertyException being thrown. See Supported Unmarshal Properties and Supported Marshal Properties.
      Parameters:
        `name` - the name of the property to be set. This value can either be specified using one of the constant fields or a user supplied string.
        `value` - the value of the property to be set
      Throws:
        `PropertyException` - when there is an error processing the given property or value
        `IllegalArgumentException` - If the name parameter is null

    - #### getProperty

          public abstract Object getProperty(String name)
                                      throws PropertyException

      Get the particular property in the underlying implementation of `Binder`. This method can only be used to get one of the standard JAXB defined unmarshal/marshal properties or a provider specific property for binder, unmarshal or marshal. Attempting to get an undefined property will result in a PropertyException being thrown. See Supported Unmarshal Properties and Supported Marshal Properties.
      Parameters:
        `name` - the name of the property to retrieve
      Returns:
        the value of the requested property
      Throws:
        `PropertyException` - when there is an error retrieving the given property or value property name
        `IllegalArgumentException` - If the name parameter is null

Copyright © 1996-2013, Oracle and/or its affiliates. All Rights Reserved. Use is subject to license terms.