Java XML & JSON Binding

JAXB and Inheritance - Using XmlAdapter

2012-01-25T06:09:00.001-05:00

In previous posts I have covered how to map inheritance relationships in JAXB. This can be done by element name (via @XmlElementRef), by the xsi:type attribute, or in EclipseLink MOXy using another XML attribute (via @XmlDescriminatorNode/@XmlDescriminatorValue). In this post the type indicator will be an XML attribute/element unique to that type, and we will leverage an XmlAdapter to implement this behaviour.

Read more »

How Does JAXB Compare to XMLBeans?

2012-01-24T06:05:00.000-05:00

In previous posts I compared JAXB (JSR-222) to Simple and XStream when starting from Java objects. In this post I'll compare JAXB to XMLBeans when starting from an XML schema. I will use XMLBeans 2.5.0 (December 2009) which is the latest release.

Read more »

EclipseLink MOXy is the JAXB Provider in WebLogic Server 12c

2011-12-16T15:26:00.001-05:00

I am very happy to announce that EclipseLink JAXB (MOXy) is now the default JAXB (JSR-222) provider in WebLogic Server 12c. I would like to thank the EclipseLink committers and the WebLogic team for all their hard work to make this happen.

In this post I will introduce how MOXy can be leveraged to create a JAX-WS service. In future posts I will cover more of the extensions in greater detail.

WebLogic Server 12c can be downloaded from OTN at the following link:

http://www.oracle.com/technetwork/middleware/weblogic/downloads/index.html

Reusing Generated JAXB Classes

2011-12-05T09:58:00.000-05:00

In this post I will demonstrate how to leverage the -episode XJC extension to reuse classes previously generated from.an XML schema. This is useful when an XML schema is imported by other XML schemas and you do not want the same classes generated each time.

JAXB and Namespace Prefixes

2011-11-30T16:37:00.001-05:00

In a previous post I covered how to use namespace qualification with JAXB. In this post I will cover how to control the prefixes that are used. This is not covered in the JAXB (JSR-222) specification but I will demonstrate the extensions available in both the reference and EclipseLink MOXy implementations for handling this use case.

JAXB (XJC) Imported Schemas and XML Catalogs

2011-10-12T15:30:00.000-04:00

XML schema has a power mechanism called "import". Import allows one XML schema to reference elements and types from another XML schema. This means you could define types to represent commonly used information once and import these types into other XML schemas. Like any powerful tool, the import mechanism also has the ability to inflict pain. In this post I'll demonstrate how to leverage an XML catalog to eliminate the pain when using JAXB's XJC tool to generate classes from an XML schema with imports.

Mixing Nesting and References with JAXB's XmlAdapter

2011-09-30T12:37:00.002-04:00

Recently I came across a question on Stack Overflow asking if JAXB could marshal the first occurrence of an object as containment and all subsequent occurrences as a reference. Below is an expanded version of my answer (up votes appreciated) demonstrating how this can be achieved by leveraging JAXB's XmlAdapter.

Mapping Objects to Multiple XML Schemas - Weather Example

2011-09-08T15:17:00.002-04:00

I have written previous posts on EclipseLink JAXB (MOXy)'s @XmlPath and external binding file extensions. In this post I will demonstrate how powerful these extensions are by mapping a single object model to two different XML schemas. To make the example more "real", the XML data will come from two different services that provide weather information: Google and Yahoo.

Read more »

XML Schema to Java - Generating XmlAdapters

2011-08-25T16:10:00.001-04:00

In previous posts I have demonstrated how powerful JAXB's XmlAdapter can be when starting from domain objects. In this example I will demonstrate how to leverage an XmlAdapter when generating an object model from an XML schema. This post was inspired by an answer I gave to a question on Stack Overflow (feel free to up vote).

Read more »

JAXB and Enums

2011-08-24T16:28:00.001-04:00

Today I answered a question on Stack Overflow (feel free to up vote) about JAXB and generating Java enums from an XML Schema. This is normally straight forward, but there are a couple "gotchas" to be aware of. In this post I'll demonstrate an easy and a harder use case.

JAXB and Java IO (Files, Streams, Readers, and Writers)

2011-08-23T13:12:00.001-04:00

JAXB supports many different XML sources and targets. In this post I'll give an overview of how JAXB can be used with those found in the java.io package: File, InputStream, OutputStream, Reader, Writer and their subclasses.

Binding to JSON & XML - Geocode Example

2011-08-19T09:12:00.003-04:00

In a previous post I introduced the JSON binding that will be part of the MOXy component in EclipseLink 2.4. In that post I explained how the same metadata that is used for XML binding can be directly applied to JSON binding. In this post I will demonstrate how powerful this is, by mapping one object model to both XML and JSON using the same set of metadata. Google Maps Geocoding API V2 will be used to provide the XML and JSON inputs for this example.

You can try this out now using a nightly download available from:

http://www.eclipse.org/eclipselink/downloads/nightly.php

Using an Unmarshaller.Listener to Capture the Location

2011-08-16T14:58:00.002-04:00

Recently I came across a question on Stack Overflow asking how find where in the document an object was unmarshalled from. In this post I'll expand on my answer of using an XMLStreamReader and Unmarshaller.Listener to accomplish this.

JSON Binding with EclipseLink MOXy - Twitter Example

2011-08-15T13:49:00.004-04:00

In a previous post I described how the Jettison library could be used with any JAXB implementation (Metro, MOXy, JaxMe, etc) to produce/consume JSON. Now I'm happy to give you a sneak peak at the native object-to-JSON binding MOXy JAXB will be offering in EclipseLink 2.4. With MOXy as your JAXB provider you can produce/consume JSON using the standard JAXB APIs (available in Java SE 6) without adding any compile time dependencies.

You can try this out now using a nightly download available from:

http://www.eclipse.org/eclipselink/downloads/nightly.php

JAXB (XJC) and Nested Classes

2011-07-29T11:10:00.001-04:00

Recently I came across a complaint on Twitter about how JAXB (XJC) generates deeply nested class structures from XML schemas. In this post I want to first explain why JAXB does this, and second how to easily configure JAXB not to do this.

JAXB and Complex Types with Simple Content

2011-06-30T12:14:00.001-04:00

A common question that appears on the forums is something like: "How do I map an object to an XML element with attributes and text in JAXB?". The answer is to use JAXB's @XmlValue annotation. In this post I'll demonstrate how this annotation can be leveraged.

Related Stack Overflow Questions:

JAXB and Factory Methods

2011-06-27T16:25:00.001-04:00

Everyone knows that by default JAXB uses the no-argument constructor when instantiating objects. Readers of this blog are also familiar with using XmlAdapters to build objects. In this post I'll cover how the use of factory classes and methods can be configured through the @XmlType annotation.

Read more »

Using JAXB's @XmlAccessorType to Configure Field or Property Access

2011-06-24T13:48:00.001-04:00

JAXB offers a lot of flexibility when interacting with your object model. One area is configuring the use of fields or properties to access the data in your domain objects. This is specified as an XmlAccessType (PUBLIC_MEMBER, PROPERTY, FIELD, or NONE) via the @XmlAccessorType annotation. In this post we'll examine what these options really mean.

EclipseLink 2.3 Release Available for Download

2011-06-22T09:25:00.001-04:00

On behalf of the MOXy JAXB committers (great job by all), I am very proud to announce that EclipseLink 2.3 has been released and is available for download. In this post I will summarize what is new in the MOXy component:

MOXy Extensible Models - Multiple Versions

2011-06-21T12:15:00.002-04:00

Recently I have discussed support for extensible models in EclipseLink JAXB (MOXy) 2.3. The metadata for the extensions is supplied via MOXy's mapping document. In this post I will demonstrate how to leverage MOXy's support for multiple mapping documents to keep your metadata organized.

MOXy Extensible Models - Refresh Example

2011-06-14T16:25:00.002-04:00

In this example we will leverage EclipseLink JAXB (MOXy)'s concepts of externalized metadata (represented as a MetadataSource), and extensible models. The MetadataSource will be used to define the metadata for the extensions. In EclipseLink 2.3 we have introduced the ability for a JAXBContext to be "refreshed". This means that without stopping the application we can supply metadata about new extensions.

Read more »

Using EclipseLink MOXy with a Metadata Repository

2011-06-03T16:29:00.001-04:00

EclipseLink JAXB (MOXy) provides an XML mapping document as an alternative to using annotations. This mapping document can be provided in many different forms: resource path, URL, File, Source, etc. If however you store your metadata in some sort of repository this flexibility might not be enough. This is why in EclipseLink 2.3 we have introduced a new mechanism to support this use case.

Read more »

MOXy Extensible Models - Multi-Tenant Example

2011-06-02T13:56:00.004-04:00

In a multi-tenant architecture a single application runs on a server, serving multiple client organizations (tenants). Good multi-tenant applications allow per-tenant customizations. When these customizations are made to data, it can be difficult for the binding layer to handle them. In this post I'll demonstrate how to leverage EclipseLink JAXB (MOXy)'s support for extensible models to easily handle this use case.

Read more »

Extensible Models with EclipseLink JAXB (MOXy)

2011-06-01T16:40:00.004-04:00

JAXB is designed to work with domain models that have real fields/properties. In EclipseLink 2.3, MOXy introduces the concept of virtual properties. Virtual properties are defined by the MOXy metadata file, and provide a way to extend a class without modifying the source. In this post I'll describe what virtual properties are, and in upcoming posts I'll cover how they can be leveraged:

MOXy Extensible Models - Multi-Tenant Example

Ignoring Inheritance with @XmlTransient

2011-06-01T11:42:00.001-04:00

In previous articles I have covered how to map inheritance relationships in JAXB and EclipseLink MOXy. In this example I will describe how to remove an inheritance relationship in JAXB by leveraging @XmlTransient at the type level.

JAXB and Joda-Time: Dates and Times

2011-05-30T14:17:00.002-04:00

Joda-Time provides an alternative to the Date and Calendar classes currently provided in Java SE. Since they are provided in a separate library JAXB does not provide a default mapping for these classes. We can supply the necessary mapping via XmlAdapters. In this post we will cover the following Joda-Time types: DateTime , DateMidnight, LocalDate, LocalTime, LocalDateTime.

Overriding JAXB's "Name Mangling" Algorithm with EclipseLink MOXy

2011-05-27T16:26:00.004-04:00

JAXB has well established rules for converting Java names to XML names. If you want to override the default name you can always do so through the use of annotations. Where this can become burdensome is if your names follow common rules (such as make everything upper case). In the upcoming EclipseLink 2.3 release we have added a new MOXy JAXB feature that allows you to override the default naming algorithm. You can try this out today using a nightly download:

http://www.eclipse.org/eclipselink/downloads/nightly.php

JAXB and DTD - Apache log4j Example

2011-05-24T17:02:00.002-04:00

There is a common misconception that JAXB requires an XML Schema. This is understandable since JAXB offers the ability to derive Java classes from an XML schema, and generate XML schemas from annotated Java classes. In reality the JAXB annotations are used to map XML to objects, and although not part of the JAXB specification, the XJC tool offers the ability to generate Java classes from a DTD. In this post we will use JAXB to interact with XML that corresponds to the Apache log4j DTD.

JAXB and Interface Fronted Models

2011-05-13T15:33:00.001-04:00

Usually with JAXB we are mapping POJOs to XML. In this example I will demonstrate how to handle a Java model that is exposed through a set of interfaces. This post was inspired by an answer I gave (feel free to upvote) to a question on Stack Overflow. In the question the poster was running into exceptions like the one below. This post will cover how to properly map this use case.

Exception in thread "main" com.sun.xml.bind.v2.runtime.IllegalAnnotationsException: 6 counts of IllegalAnnotationExceptions
blog.interfaces.Customer is an interface, and JAXB can't handle interfaces.
 this problem is related to the following location:
  at blog.interfaces.Customer
blog.interfaces.Customer does not have a no-arg default constructor.
 this problem is related to the following location:
  at blog.interfaces.Customer
...

Schema to Java: @XmlMimeType & @XmlInlineBinaryData

2011-05-05T16:56:00.001-04:00

In a previous post I described the impact of the @XmlInlineBinaryData and @XmlMimeType annotations in a JAX-WS environment where binary data may be sent as attachments. One of the comments I received on that post was how to have those annotations generated onto your classes when starting from an XML schema. In this post I will address that question.

Read more »

Specifying EclipseLink MOXy as Your JAXB Provider

2011-05-03T16:51:00.002-04:00

To specify EclipseLink MOXy as the JAXB provider you need to put a jaxb.properties file in one of the packages for your domain classes, that is passed in to bootstrap the JAXBContext.

@XmlAnyElement and non-DOM Properties

2011-04-15T16:49:00.001-04:00

This post will cover how to use an alternate DOM representation (i.e. String) with @XmlAnyElement.

Read more »

JAXB and JSON via Jettison - Namespace Example

2011-04-15T14:53:00.001-04:00

In a previous post I described how Jettison can be leveraged by a JAXB implementation to produce/consume JSON. A reader correctly pointed out that I did not describe how to handle namespaces. Since JSON does not support namespaces you would not normally include them in your mappings. However if you wanted to map your object model to both JSON and XML with namespaces, this post will demonstrate how it can be done.

XML Schema to Java - XSD Choice

2011-04-15T13:18:00.002-04:00

In a previous blog post I wrote about how to map to the choice structure in XML schema when starting from classes. An astute reader tried generating an object model from that schema and noticed that the JAXB implementation generated something different than expected. In this post I'll explain the difference.

JAXB and JSON via Jettison

2011-04-12T12:04:00.002-04:00

JAXB implementations (Metro, EclipseLink MOXy, Apache JaxMe, etc) provide an easy means of converting objects to/from XML. There is a library called Jettison that exposes access to JSON messages via the StAX API that a JAXB implementation can use to convert objects to/from JSON. This library is being leveraged by a number of JAX-RS implementations. In this post I'll demonstrate its use in a standalone example.

MOXy's XML Metadata in a JAX-RS Service

2011-04-11T11:14:00.001-04:00

In previous posts I introduced how EclipseLink JAXB (MOXy) can represent it's metadata as XML, and how MOXy can be used in a JAX-RS service. In this post I'll demonstrate how to leverage MOXy's metadata file in a JAX-RS service by using a ContextResolver.

Read more »

JAXB, Web Services, and Binary Data

2011-03-23T10:05:00.002-04:00

When an instance of a class is used with a Web Service, the JAX-WS implementation can choose to handle fields/properties that hold binary data as SOAP attachment. An attachment is a means to send the data outside of the XML message, this is done as an optimization since binary data encoded as a xs:base64Binary string could be quite large. JAXB offers a couple of annotations to control this behaviour:

@XmlInlineBinaryData
This specifies that the binary data for this field/property must be written to the XML document as xs:base64Binary and not sent as an attachment.
@XmlMimeType
For properties of type java.awt.Image or javax.xml.transform.Source, this annotation allows the mime type to be specified that will be used for encoding the data as bytes.

Map to Element based on an Attribute Value with EclipseLink JAXB (MOXy)

2011-03-22T09:11:00.007-04:00

I am happy to announce that we are expanding MOXy's XPath based mapping in EclipseLink 2.3. You are now able to map to an element based on the value of an attribute. This is done by leveraging XPath predicates via MOXy's @XmlPath annotation.

You can try this out today by downloading one EclipseLink 2.3.0 nightly downloads starting on March 22, 2011 from:

http://www.eclipse.org/eclipselink/downloads/nightly.php

Preventing Entity Expansion Attacks in JAXB

2011-03-11T13:34:00.002-05:00

This post will cover how to protect yourself from the entity expansion attack when you are using JAXB.

Read more »

Handling Duplicate @XmlRootElement Declarations

2011-03-09T16:48:00.001-05:00

The following post was inspired by an answer I gave to a question on Stack Overflow (feel free to up vote). The problem arose from a JAXBContext being created on classes derived from two schemas that both use the same root element. The solution is to supply type of object to the unmarshal operation.

Read more »

Using JAXB to Implement a Copy Operation

2011-03-08T16:47:00.001-05:00

The following post was inspired by an answer I gave to a question on Stack Overflow (feel free to up vote). I am not suggesting that JAXB should be used to implement copy methods, instead I'm using a copy operation to demonstrate that JAXB can treat an object model as XML input.

Read more »

JAXB and Choosing the List Implementation

2011-01-25T16:36:00.001-05:00

For elements with max occurs greater than one, JAXB will generate a java.util.List property and the underlying implementation will be java.util.ArrayList. You can control which list implementation is used through internal and external schema annotations. You can also use your own domain objects which gives you full control of your object model. This post will discuss these different options.

JAXB and Date/Time Properties

2011-01-20T16:59:00.002-05:00

In this post I will describe how JAXB handles date/time information. This post will also cover how the @XmlSchemaType annotation can be used to customize the XML representation.

Read more »

Represent String Values as Element Names with JAXB ("foo" as )

2010-12-21T14:14:00.001-05:00

In this example we will map a String value to an element name. Instead of <foo>bar</foo> we want <bar/>. We will accomplish this by using @XmlAdapter and @XmlElementRef.

Read more »

JAXB and Marshal/Unmarshal Schema Validation

2010-12-20T16:25:00.002-05:00

In a previous post I described how to validate an object model (mapped with JAXB annotations) against an XML schema using the javax.xml.validation APIs. In this post I'll describe how to leverage those APIs during unmarshal and marshal operations.

Read more »

Extending JAXB - Representing Metadata as XML

2010-12-10T10:49:00.004-05:00

In JAXB (JSR-222) metadata is applied to Java classes via standard annotations. There are times when using annotatations is not practical, and an alternate mechanism is required. In this post I'll demonstrate how EclipseLink JAXB (MOXy) can leverage XML to represent the JAXB metadata.

An XML metadata representation is useful when:

You cannot modify the domain model (it may come from a 3rd party).
You do not want to introduce compile dependencies on JAXB APIs (if you are using a version of Java prior to Java SE 6).
You want to apply multiple JAXB mappings to a domain model (you are limited to one representation with annotations).
Your object model already contains so many annotations from other technologies that adding more would make the class unreadable.

Case Insensitive Unmarshalling with JAXB

2010-12-07T16:30:00.003-05:00

Recently I've been asked in a couple different forums how to handle case insensitive unmarshalling in JAXB. In this post I'll discuss an approach using a StAX StreamReaderDelegate.

I am considering adding this as an official feature, and would be interested in your feed back. I am using the following bug to track this issue:

https://bugs.eclipse.org/331241

JAXB and Immutable Objects

2010-12-03T14:48:00.003-05:00

I was recently sent a blog post: JAXB and immutable objects, by Aniket Shaligram. In this post the author addresses the issue by adding a default constructor and using field access, to avoid adding set methods. This approach is perfectly valid, but leaves the class being more mutable than some people like (including the person who sent me the link). In this post I'll discuss an alternative approach using XmlAdapter.

Validate a JAXB Object Model With an XML Schema

2010-11-24T13:42:00.001-05:00

In this post I will demonstrate how to validate a JAXB object model against an XML schema. This will be done using the javax.xml.validation APIs.

JAXB and Inheritance - MOXy Extension @XmlDescriminatorNode/@XmlDescrimintatorValue

2010-11-05T16:41:00.003-04:00

In previous blog posts I described how to leverage the xsi:type attribute and substitution groups to represent inheritance. In this post I'll demonstrate how an upcoming EclipseLink 2.2 JAXB (MOXy) extension can be used to represent inheritance. It leverages an attribute of your own choosing to represent the subtype. If you are using a version of EclipseLink prior to 2.2 you can use the technique described here.

JAXB and Inheritance - Using Substitution Groups

2010-11-04T11:18:00.006-04:00

In a previous blog post I described how to leverage the xsi:type attribute to represent inheritance. In this post I'll demonstrate how to use the element name instead by leveraging the XML Schema concept of substitution groups.

JAXB and Inheritance - Using the xsi:type Attribute

2010-11-04T10:36:00.004-04:00

In a previous blog post I was challenged by an Xstream user to describe how JAXB handles inheritance. In this post I'll describe one strategy that can be used, and how easily this can be done with JAXB. I'll discuss alternate strategies in future posts.

How Does JAXB Compare to Simple?

2010-10-25T13:53:00.005-04:00

In a previous post I compared JAXB to XStream. In this post I'll run that comparison with the Simple XML Serialization framework.

Read more »

JAXB and XSD Choice: @XmlElements

2010-10-21T15:25:00.004-04:00

XML Schema has the concept of a choice element. The choice element indicates that one of the elements defined within the choice may occur at this point in the XML document. In this example I will demonstrate how easily this can be mapped using JAXB.

Read more »

JAXB and Shared References: @XmlID and @XmlIDREF

2010-10-07T16:09:00.003-04:00

When converting objects to XML, privately owned data can easily be represented through nested elements. When there are multiple references to an object another mechanism needs to be used. In JAXB this mechanism is @XmlID and @XmlIDREF.

How Does JAXB Compare to XStream?

2010-10-06T14:29:00.005-04:00

The XStream FAQ states the following when being compared to JAXB:

JAXB is a Java binding tool. It generates Java code from a schema and you are able to transform from those classes into XML matching the processed schema and back. Note, that you cannot use your own objects, you have to use what is generated.

In this post I will provide an alternative answer to that question.

Read more »

JAXB & Collection Properties

2010-09-28T13:09:00.002-04:00

In this post will examine the different options JAXB offers for representing collections in XML. We will look at the following annotations:

@XmlElement
@XmlElementWrapper
@XmlList
@XmlList and @XmlAttribute
@XmlList and @XmlValue

JAXB & XML Infoset Preservation

2010-09-28T10:17:00.002-04:00

In this post we will discuss how to use JAXB to preserve the XML Infoset.

Read more »

XPath Based Mapping - Geocode Example

2010-09-13T14:57:00.033-04:00

In a previous post I introduced MOXy's XPath based mapping JAXB extension. In this post I'll use Google Maps Geocoding API V2 to demonstrate how powerful this extension is.

Read more »

Processing Atom Feeds with SDO

2010-09-10T16:15:00.003-04:00

Service Data Objects (SDO) is a Java standard (JSR-235) that can be used to process XML. In this post we will compare SDO to JAXB by processing an Atom feed.

Processing Atom Feeds with JAXB

Processing Atom Feeds with JAXB

2010-09-08T13:39:00.001-04:00

Atom is an XML format for representing web feeds. A standard format allows reader applications to display feeds from different sources. In this example we will process the Atom feed for this blog.

Read more »

EclipseLink 2.1.1 Patch Set Released

2010-08-26T15:03:00.002-04:00

The first patch set for the EclipseLink 2.1 stream is now available. EclipseLink 2.1.1 can be downloaded here:

http://www.eclipse.org/eclipselink/downloads/

The following XML binding layer bugs were fixed:

Using @XmlAnyElement to Build a Generic Message

2010-08-26T14:42:00.002-04:00

In this post we are building our own XML messaging framework. We want to have a standard message object (similar to a SOAP envelope) that the framework can understand, and the ability to easily add domain specific payloads over time.

Read more »

@XmlTransformation - Going Beyond XmlAdapter

2010-08-25T14:16:00.004-04:00

XML Adapter is my favourite JAXB feature, which is why it was the topic of my first post XmlAdapter - JAXB's Secret Weapon. With it there is no such thing as an unmappable object in JAXB. However today I came across a use case where the MOXy's transformation mapping was a much better fit.

Read more »

Creating a RESTful Web Service - Part 5/5

2010-08-23T15:15:00.002-04:00

In this post we will examine how a client may interact with the RESTful service we created in part 4.

Creating a RESTful Web Service - Part 4/5

2010-08-20T11:35:00.006-04:00

Java API for RESTful Web Services (JAX-RS) is the Java EE standard for creating RESTful Web Services. In this post we will create a RESTful service from an EJB session bean using JAX-RS.

Creating a RESTful Web Service - Part 3/5

2010-08-20T08:00:00.014-04:00

Java Architecture for XML Binding (JAXB) is the Java EE standard for mapping POJOs to XML. In this example we will use JAXB to apply an XML representation to the JPA entities we created in part 2. Since we are mapping JPA entities to XML we will use the MOXy JAXB implementation and leverage some of its extensions.

Some developers will maintain separate JPA and JAXB models, and perform a copy step to move data between them. This can be quite a painful and error prone process. Luckily MOXy has a number of extensions that make this unnessary:

Creating a RESTful Web Service - Part 2/5

2010-08-19T10:39:00.006-04:00

Java Persistence Architecture (JPA) is the Java EE standard for mapping POJOs to a relational database. In this example we will use JPA to interact with our database data we set up in part 1.

Creating a RESTful Web Service - Part 1/5

2010-08-18T10:24:00.003-04:00

I have been doing a lot of work with data access services recently so I figure it's time to share what I have discovered. Don't be scared off that this series is broken into 5 parts, I will keep them short:

Part 1 - The Database

Part 2 - Mapping the Database to JPA Entities

Part 3 - Mapping JPA entities to XML (using JAXB)

Part 4 - The RESTful Service

Part 5 - The Client

In this series of posts we will use a number of standard Java EE technologies to quickly create a RESTful data access service:

XML Binding Talk at JavaOne

2010-08-17T11:40:00.002-04:00

This year I will be doing a talk on XML Binding at JavaOne in San Francisco. I will be pitting the two XML binding standards: JAXB (JSR-222) & SDO (JSR-235) against each other to help you determine which one is right for you. I hope to see you there.

Details:

Effective XML: Leveraging JAXB and SDO (S314491)
Wednesday September 22, 1-2pm
Hilton San Francisco, Yosemite A

JAXB & Namespaces

2010-08-11T14:25:00.004-04:00

The majority of XML documents are namespace qualified, yet most XML binding examples do not demonstrate namespaces (sometimes because the XML binding solution does not support them). In this post I'll demonstrate how easy namespace handling is using JAXB.

Read more »

JPA Entities to XML - Bidirectional Relationships

2010-07-26T11:03:00.002-04:00

JAXB is your best choice when binding Java objects to XML. But what happens when those Java objects turn out to be JPA entities? For the most part it is business as usual, although there are a couple things to be aware of. In this post we'll cover a MOXy extension that can be used to map a bidirectional relationship.

Read more »

MOXy JAXB - Map Interfaces to XML

2010-07-23T09:06:00.004-04:00

I recently came across a Twitter message (tweet) complaining that JAXB does not support binding Java interfaces to XML. Below I'll describe how this can be accomplished using MOXy in the upcoming EclipseLink 2.1.1 and 2.2 releases (try it now).

Read more »

JAXB - The XML Binding Standard

2010-07-20T13:04:00.003-04:00

Many people think of JAXB as an implementation (the reference implementation included in Java SE 6). In reality JAXB is a Java Community Process (JCP) specification with multiple implementations (such as EclipseLink MOXy). In this post I'll discuss the importance of JAXB the standard.

Read more »

XPath Based Mapping

2010-07-14T10:43:00.011-04:00

In this post we'll explore the XPath based mapping aspect of EclipseLink JAXB (MOXy). XPath based mapping is what allows an existing object model to be mapped to an existing XML schema. MOXy is the only XML binding solution I'm aware of with this ability and therefore the only true object-to-XML mapper (OXM).

Read more »

CDATA, CDATA Run, Run Data Run

2010-07-13T08:31:00.138-04:00

Recently the topic of JAXB's handling of CDATA has come up on a few separate Twitter messages (tweets). In this post I will describe how to handle CDATA using EclipseLink JAXB (MOXy).

Read more »

XmlAdapter - JAXB's Secret Weapon

2010-07-12T15:55:00.019-04:00

The XmlAdapter mechanism in JAXB ensures that there is no such thing as an unmappable class (with a little programmatic help). However there appears to be some confusion on how to use XmlAdapter, below is the general concept:

Identify the unmappable class
Create an equivalent class that is mappable
Create an XmlAdapter to convert between unmappable and mappable objects
Specify the XmlAdapter

Part of the problem may be due to the Javadocs on the XmlAdapter class. Below I'll flush out the example used there.

Read more »