How to convert a Java object (bean) to key-value pairs (and vice versa)?

Question

Say I have a very simple java object that only has some getXXX and setXXX properties. This object is used only to handle values, basically a record or a type-safe (and performant) map. I often need to covert this object to key value pairs (either strings or type safe) or convert from key value pairs to this object.

Other than reflection or manually writing code to do this conversion, what is the best way to achieve this?

An example might be sending this object over jms, without using the ObjectMessage type (or converting an incoming message to the right kind of object).

Answer 1

Code generation would be the only other way I can think of. Personally, I'd got with a generally reusable reflection solution (unless that part of the code is absolutely performance-critical). Using JMS sounds like overkill (additional dependency, and that's not even what it's meant for). Besides, it probably uses reflection as well under the hood.

Answer 2

There is always apache commons beanutils but of course it uses reflection under the hood

Answer 3

JSON, for example using XStream + Jettison, is a simple text format with key value pairs. It is supported for example by the Apache ActiveMQ JMS message broker for Java object exchange with other platforms / languages.

Answer 4

You could use the Joda framework:

http://joda.sourceforge.net/

and take advantage of JodaProperties. This does stipulate that you create beans in a particular way however, and implement a specific interface. It does then however, allow you to return a property map from a specific class, without reflection. Sample code is here:

http://pbin.oogly.co.uk/listings/viewlistingdetail/0e78eb6c76d071b4e22bbcac748c57

Answer 5

My JavaDude Bean Annotation Processor generates code to do this.

http://javadude.googlecode.com

For example:

@Bean(
  createPropertyMap=true,
  properties={
    @Property(name="name"),
    @Property(name="phone", bound=true),
    @Property(name="friend", type=Person.class, kind=PropertyKind.LIST)
  }
)
public class Person extends PersonGen {}

The above generates superclass PersonGen that includes a createPropertyMap() method that generates a Map for all properties defined using @Bean.

(Note that I'm changing the API slightly for the next version -- the annotation attribute will be defineCreatePropertyMap=true)

Answer 6

If you do not want to hardcode calls to each getter and setter, reflection is the only way to call these methods (but it is not hard).

Can you refactor the class in question to use a Properties object to hold the actual data, and let each getter and setter just call get/set on it? Then you have a structure well suited for what you want to do. There is even methods to save and load them in the key-value form.

Answer 7

You should write a generic transformation Service! Use generics to keep it type free (so you can convert every object to key=>value and back).

What field should be the key? Get that field from the bean and append any other non transient value in a value map.

The way back is pretty easy. Read key(x) and write at first the key and then every list entry back to a new object.

You can get the property names of a bean with the apache commons beanutils!

Answer 8

The best solution is to use Dozer. You just need something like this in the mapper file:

<mapping map-id="myTestMapping">
  <class-a>org.dozer.vo.map.SomeComplexType</class-a>
  <class-b>java.util.Map</class-b>
</mapping>

And that's it, Dozer takes care of the rest!!!

Dozer Documentation URL

Answer 9

Lots of potential solutions, but let's add just one more. Use Jackson (JSON processing lib) to do "json-less" conversion, like:

ObjectMapper m = new ObjectMapper(); Map props = m.convertValue(myBean, Map.class); MyBean anotherBean = m.convertValue(props, MyBean.class);

(this blog entry has some more examples)

You can basically convert any compatible types: compatible meaning that if you did convert from type to JSON, and from that JSON to result type, entries would match (if configured properly can also just ignore unrecognized ones).

Works well for cases one would expect, including Maps, Lists, arrays, primitives, bean-like POJOs.