SimpleXML框架：如何转换非标准的基本类型表示形式？

Question

I am trying to convince SimpleXML to convert my Java objects to and from XML. I have a (seemingly) simple problem but I have now already wasted substantial time searching a description or an example for doing the following:

The XML format that I need to read or generate contains integer values that define colors and which are represented as hex integers (but without a leading "0x", same as in HTML or in misc. Android .xml files), ie red="ff0000", blue="00ff00", green="0000ff", etc.

My XML contains elements like:

<SomeObject name="foobar" checkedColor="123456" flaggedColor="FEDCBA" ... />

The corresponding Java class reads:

public class SomeObject 
{
    @Attribute
    String name;
    @Attribute #######
    int checkedColor;
    @Attribute #######
    int flaggedColor;
    // ...
}

I marked the two attributes I am talking about here with ####### above. The color values should be of type "int".

How do I teach SimpleXML that these value are represented as hex-string and how to convert them? What transformer or converter or whatever do I need to write so that these int values are converted to/from hex-strings as shown and what do I have to annotate in the above code to achieve that?

Answer 1

Use a Transform, see the documentation below

http://simple.sourceforge.net/download/stream/doc/javadoc/org/simpleframework/xml/transform/Transform.html

Answer 2

I was finally able to implement what I want by defining a type "HexInt" which looks as follows

public class HexInt
{
    private int value;

    public HexInt(int value) {
        setValue(value);
    }
    public HexInt(String value) {
        setValue(value);
    }

    protected int getValue() {
        return this.value;
    }

    protected void setValue(int value) {
        this.value = value;
    }
    protected void setValue(String value) {
        setValue(Integer.parseInt(value, 16));
    }

    @Override
    public String toString() {
        return Integer.toHexString(getValue());     
    }
}

and defining the corresponding attributes as

...
@Attribute(required=false)
protected HexInt checkedcolor;
@Attribute(required=false)
protected HexInt flaggedcolor;
...

plus defining a Matcher which for HexInt-s provides a corresponding Transformer that properly converts these values to and from strings.

But what I hate about this solution is, that I not only had to annotate my java code to achieve that result but actually had to use special, representation-specific classes, even though from the program logic there would be absolutely no need to define a special class containing only an int, just because I want to serialize these two fields in a special way. IMHO following an aspect oriented spirit the internal representation ("int") should be defined in the basic Java-code and that code should be agnostic of how the data gets represented when externalized. The external representation on the other hand (ie whether I want to represent int-value as a decimal or hexadecimal string) should be defined in the annotations ONLY (plus supportive classes like Matcher and Transformer) but not in the basic Java code.

Is there really no way in the SimpleXML-framework to keep these different aspects more cleanly separated?