...
This data format supports the following options. You can set them via all DSLs. The defaults marked with with (*)
are determined by json-lib
, rather than the code of the data format itself. They are reflected reproduced here for convenience so that you don't have to dot back and forth with to avoid having to consult the json-lib
docs documentation directly.
Div | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Basic Usage
...
With the Java DSL
Explicitly
...
Instantiating the
...
DataFormat
Just instantiate the the XmlJsonDataFormat
from package org.apache.camel.dataformat.xmljson
. Make sure you have installed the camel-xmljson
feature (if running on OSGi) or that you've included included camel-xmljson-{version}.jar
and its transitive dependencies in your classpath.
Example, initialization with a default configuration:
Code Block | ||
---|---|---|
| ||
XmlJsonDataFormat xmlJsonFormat = new XmlJsonDataFormat(); |
To tune the behaviour behavior of the data format as per the options above, use the appropriate setters:
Code Block | ||
---|---|---|
| ||
XmlJsonDataFormat xmlJsonFormat = new XmlJsonDataFormat(); xmlJsonFormat.setEncoding("UTF-8"); xmlJsonFormat.setForceTopLevelObject(true); xmlJsonFormat.setTrimSpaces(true); xmlJsonFormat.setRootName("newRoot"); xmlJsonFormat.setSkipNamespaces(true); xmlJsonFormat.setRemoveNamespacePrefixes(true); xmlJsonFormat.setExpandableProperties(Arrays.asList("d", "e")); |
Once you've instantiated the data formatthe DataFormat
is instantiated, the next step is to actually use the it from within it as a parameter to either of the marshal()
and /
unmarshal()
DSL elements:
Code Block | ||
---|---|---|
| ||
// fromFrom XML to JSON from("direct:marshal") .marshal(xmlJsonFormat) .to("mock:json"); // fromFrom JSON to XML from("direct:unmarshal") .unmarshal(xmlJsonFormat) .to("mock:xml"); |
Defining the
...
DataFormat in-line
Alternatively, you can define the data format inline by using the xmljson()
DSL element.
Code Block | ||
---|---|---|
| ||
// fromFrom XML to JSON - inline dataformat from("direct:marshalInline") .marshal() .xmljson() .to("mock:jsonInline"); // fromFrom JSON to XML - inline dataformat from("direct:unmarshalInline") .unmarshal() .xmljson() .to("mock:xmlInline"); |
If you wish, you can even pass in a Map<String, String> to the inline methods to provide custom options:
Code Block | ||
---|---|---|
| ||
Map<String, String> xmlJsonOptions = new HashMap<String, String>(); xmlJsonOptions.put(org.apache.camel.model.dataformat.XmlJsonDataFormat.ENCODING, "UTF-8"); xmlJsonOptions.put(org.apache.camel.model.dataformat.XmlJsonDataFormat.ROOT_NAME, "newRoot"); xmlJsonOptions.put(org.apache.camel.model.dataformat.XmlJsonDataFormat.SKIP_NAMESPACES, "true"); xmlJsonOptions.put(org.apache.camel.model.dataformat.XmlJsonDataFormat.REMOVE_NAMESPACE_PREFIXES, "true"); xmlJsonOptions.put(org.apache.camel.model.dataformat.XmlJsonDataFormat.EXPANDABLE_PROPERTIES, "d e"); // fromFrom XML to JSON - inline dataformat w/ options from("direct:marshalInlineOptions") .marshal() .xmljson(xmlJsonOptions) .to("mock:jsonInlineOptions"); // formFromm JSON to XML - inline dataformat w/ options from("direct:unmarshalInlineOptions") .unmarshal() .xmljson(xmlJsonOptions). .to("mock:xmlInlineOptions"); |
Basic
...
Usage with Spring or Blueprint DSL
Within the <dataFormats>
block, simply configure an xmljson
element with unique IDs:
Code Block | ||
---|---|---|
| ||
<dataFormats> <xmljson id="xmljson"/> <xmljson id="xmljsonWithOptions" forceTopLevelObject="true" trimSpaces="true" <xmljson idrootName="xmljsonnewRoot"/> <xmljson id="xmljsonWithOptions" forceTopLevelObject="true" trimSpaces="true" rootName="newRoot" skipNamespaces="true" removeNamespacePrefixes="true" expandableProperties="d e"/> </dataFormats> |
Then you simply refer to the data format object within your <marshal/>
and { and <unmarshal/>
}} DSLs:
Code Block | ||
---|---|---|
| ||
<route>
<from uri="direct:marshal"/>
<marshal ref="xmljson"/>
<to uri="mock:json" />
</route>
<route>
<from uri="direct:unmarshalWithOptions"/>
<unmarshal ref="xmljsonWithOptions"/>
<to uri="mock:xmlWithOptions"/>
</route>
|
Enabling XML DSL autocompletion for this component is easy: just refer to the appropriate Schema locations, depending on whether you're using Spring or Blueprint DSL. Remember that this data format is available from Camel 2.10 onwards, so . Therefore only schemas from that version onwards or later will include these new XML elements and attributes.
The syntax with Blueprint is identical to that of the Spring DSL. Just ensure the correct namespaces and and schemaLocations
are in use.
Namespace
...
Mappings
XML has namespaces to fully qualify elements and attributes; JSON doesn't. You need to take this into account when performing XML-JSON conversions.
To bridge the gap, Json-lib has an option to bind namespace declarations in the form of prefixes and namespace URIs to XML output elements while unmarshalling (i, e.eg., converting from JSON to XML).
For example, provided the following JSON string:
Code Block |
---|
{ '"pref1:a'": '"value1'", '"pref2:b'": '"value2" } |
you can ask Jsonask json-lib
to output namespace declarations on elements "elements pref1:a
" and " and pref2:b
" to bind the prefixes "pref1" and "pref2" prefixes pref1
and pref2
to specific namespace URIs.
To use this feature, simply create XmlJsonDataFormat.NamespacesPerElementMapping
objects and add them to the namespaceMappings
option (which is a List
).
The XmlJsonDataFormat.NamespacesPerElementMapping
holds an element name and a Map of [prefix => namespace URI]
. To facilitate mapping multiple prefixes and namespace URIs, the NamespacesPerElementMapping(String element, String pipeSeparatedMappings)
constructor takes a String-based pipe-separated sequence of of [prefix, namespaceURI]
pairs in the following way: |ns2|http://camel.apache.org/personalData|ns3|http://camel.apache.org/personalData2|
.
In order to define a default namespace, just leave the corresponding key field empty: |ns1|http://camel.apache.org/test1||http://camel.apache.org/default|
.
Binding namespace declarations to an element name = empty string will attach those namespaces to the root element.
The full code would look like thatcode for this is:
Code Block | ||
---|---|---|
| ||
XmlJsonDataFormat namespacesFormat = new XmlJsonDataFormat(); List<XmlJsonDataFormat.NamespacesPerElementMapping> namespaces = new ArrayList<XmlJsonDataFormat.NamespacesPerElementMapping>(); namespaces.add(new XmlJsonDataFormat. NamespacesPerElementMapping("", "|ns1|http://camel.apache.org/test1||http://camel.apache.org/default|")); namespaces.add(new XmlJsonDataFormat. ; namespaces.add(new XmlJsonDataFormat.NamespacesPerElementMapping("surname", "|ns2|http://camel.apache.org/personalData|" + "ns3|http://camel.apache.org/personalData2|")); namespacesFormat.setNamespaceMappings(namespaces); namespacesFormat.setRootElement("person"); |
...
Using the namespace bindings in the Java snippet above on the following JSON string:
Code Block | ||
---|---|---|
| ||
{ "name": "Raul", "surname": "Kripalani", "f": true, "g": null} |
...
Code Block | ||||
---|---|---|---|---|
| ||||
<dependency> <groupId>org.apache.camel</groupId> <artifactId>camel-xmljson</artifactId> <version>x.x.x</version> <!-- Use the same version as camel-core, but remember that this component is only available from Camel 2.10 onwards --> </dependency> <!-- And also XOM must be included. XOM cannot be included by default due to an incompatible license with ASF; so add this manually --> <dependency> <groupId>xom</groupId> <artifactId>xom</artifactId> <version>1.2.5</version> </dependency> |
...