A factory for creating
KeyInfo
objects from scratch or for
unmarshalling a
KeyInfo
object from a corresponding XML
representation.
Each instance of KeyInfoFactory
supports a specific
XML mechanism type. To create a KeyInfoFactory
, call one of the
static getInstance
methods, passing in the XML
mechanism type desired, for example:
KeyInfoFactory factory = KeyInfoFactory.getInstance("DOM");
The objects that this factory produces will be based
on DOM and abide by the DOM interoperability requirements as defined in the
DOM Mechanism Requirements section of the API overview. See the
Service Providers section of the API overview for a list of standard
mechanism types.
KeyInfoFactory
implementations are registered and loaded
using the Provider
mechanism.
For example, a service provider that supports the
DOM mechanism would be specified in the Provider
subclass as:
put("KeyInfoFactory.DOM", "org.example.DOMKeyInfoFactory");
Also, the XMLStructure
s that are created by this factory
may contain state specific to the KeyInfo
and are not
intended to be reusable.
An implementation MUST minimally support the default mechanism type: DOM.
Note that a caller must use the same KeyInfoFactory
instance to create the XMLStructure
s of a particular
KeyInfo
object. The behavior is undefined if
XMLStructure
s from different providers or different mechanism
types are used together.
Concurrent Access
The static methods of this class are guaranteed to be thread-safe.
Multiple threads may concurrently invoke the static methods defined in this
class with no ill effects.
However, this is not true for the non-static methods defined by this
class. Unless otherwise documented by a specific provider, threads that
need to access a single KeyInfoFactory
instance concurrently
should synchronize amongst themselves and provide the necessary locking.
Multiple threads each manipulating a different KeyInfoFactory
instance need not synchronize.