Musings of an orthogonal mind

Object conversion dozer(ed)

Shrihari Chakrapani — Mon, 24 Nov 2008 17:13:52 +0000

Continuing on my experiences on the object mapping exercises, I found a interesting site here , which eulogize it saying it is currently the most powerful bean-2-bean mapping utilities found on the net. Others being Apache Commons Beanutils and Spring BeanWrapper. I dont deny that Dozer is the most powerful bean mapping utility compared to others, but for simple and straightforward examples.

Dozer has following features which we use the most often:

Declarative mapping (default: dozerBeanMapping.xml) which contain source-destination object field-to-field mapping with hints.
Support for Custom-converters for custom mapping, or out-of-fit/inconvertible data-types
Better error-handling features and deep-index-hints for deep object indirections.

However we had two scenarios which we needed a bean-mapping utility to aid us convert deep-rooted object hierarchies.

Carving a subset of information from a superset object.
Combining different subsets of information and generate a superset object.

Dozer helps us solve both these scenarios where we could generate mappings distinguished by map_ids. We could identify and individually map source-object to destination-object construct, that could constitute either the big source-superset object or the destination-superset object in the respective scenarios. Dozer supports only index-based object referencing and does not support XPath based querying on instance object values, which we seriously needed, as we had an unordered instance object aggregate and mapping based on the certain named references.

We will talk about other experiences in the later posts. Until then, Ciao!

Object-Mapping Dilemma

Shrihari Chakrapani — Sat, 22 Nov 2008 18:31:32 +0000

In high loose-end systems, where communication happen through service-lookup interactions, there are common concerns with regard to mapping objects when the service-requests need to be processed.

You would need a subset of data from the request object, if there are fine grained delegation sub-request that may need to be executed in sequence. Carving an object subset from the original request object is ‘narrowing‘ a request state. A typical example would be to place an order in a shopping-cart scenario. The actual request (of placing an order) may be processed in two steps : authorizing a person into the site, and then placing the actual order.

You may also face another concern of carving a response object from the different response objects in the fine-grained sequence of smaller operations carried out during request processing. This would be called ‘broadening‘ the response state.

I am sure this is one of most common concerns we may have faced in some or the other scenario. We could achieve a solution to the problem of object-state narrowing or broadening in two approaches:

1) Bean-to-Bean Mapping (Tools like Dozer, Apache-Common-Beanutils, Spring BeanWrapper etc. would help us do that!)

2) XML-to-XML Mapping ( This is low-level activity, which would require us to serialize object-states to XML, map to destination XML using XSLT, de-serialize the destination object-state from the generated XML).

More on these approaches in my next post!. Until then, ciao!

My varied interests!

Shrihari Chakrapani — Wed, 07 May 2008 15:41:05 +0000

Welcome to read my first blog entry here on WordPress! Though I have been blogging for last two years elsewhere, I could not devote much time on a specific topic! I have couple of varied interests, which I would blogging about! First includes my technology interests in Java and architectural musings, and my other interests include my interests in visiting underground and collecting goodies. I would elaborate on these fronts in my future blogs.