Simple xml framework deserializing with multiple element names

Question

I am trying to serialize some xml data from a public web service into java objects with Simple XML Framework. The problem is that different methods from the service return the same concept with different element names. For example, method A returns element foo like this

<data><Foo>foo value</Foo></data>

whereas method B returns

<data><foo>foo value</foo></data>

and method C returns

<data><FOO>foo value</FOO></data>

Is there any way (a multiple name annotation or so) of getting this xml deserialized into the same class and same element? For example, deserializing the three method's results into the same "foo" element in three different "Foo" objects (one per method):

@Root(name="data")
public class Foo{
    @Element
    public String foo;
    (...)
}

Answer 1

Unfortunately you can't set more than one annotation per field and @Element only supports one name (case sensitive). As an alternative you can deserialize those fields by your own - here's an example how to do this:

@Root(name = "data")
@Convert(FooConverter.class) // Set the converter that's used for serializing / deserializing this class
public class Foo
{
    @Element( name = "foo") // For this solution it doesn't matter what you set here
    public String foo;

    // ...


    /*
     * The converter - Implement the serialization / deserialization here.
     * You don't have to use an inner class here.
     */
    public static class FooConverter implements Converter<Foo>
    {
        @Override
        public Foo read(InputNode node) throws Exception
        {
            Foo f = new Foo();
            InputNode nextNode = node.getNext();

            while( nextNode != null )
            {
                if( nextNode.getName().equalsIgnoreCase("foo") ) // Here you pick-up the node, however it's written
                {
                    f.setFoo(nextNode.getValue());
                }

                nextNode = node.getNext();
            }

            return f;
        }


        @Override
        public void write(OutputNode node, Foo value) throws Exception
        {
            // Not required in this example.
            throw new UnsupportedOperationException("Not supported yet.");
        }

    }
}

Example usage:

String str = "<data><foo>foo value</foo></data>"; // Foo can be written as you like

Serializer ser = new Persister(new AnnotationStrategy()); // Setting the AnnotationStrategy is important!!
Foo f = ser.read(Foo.class, str);

System.out.println(f);

Now it doesn't matter if foo is written as foo or FoO - as long it's a foo.