Android speed issue with deserialization using SimpleXML

Question

Raised a bounty as the only answer doesn't provide a good implementation for Android. Is there a speedier implementation compatible with Android? Or is SimpleXML the best performance I'll get?

I'm fairly novice to Java and Android development so don't know the proper procedure for deserializing an xml string to an object. I found a method that works in:

public static Object deserializeXMLToObject(String xmlFile,Object objClass)  throws Exception 
{ 
    try
    {
            InputStream stream = new ByteArrayInputStream(xmlFile.getBytes("UTF-8"));

            Serializer serializer = new Persister();
            objClass = serializer.read(objClass, stream);
            return objClass;
    }
    catch (Exception e) 
    {
        return e;
    }
}

Where xmlFile is the (misnamed) xml string, and objClass is an empty class of the class I want to deserialize to. This is generally a list of other objects.

Example class:

@Root(name="DepartmentList")
public class DepartmentList {
    @ElementList(entry="Department", inline=true)
    public List<Department> DepartmentList =new ArrayList<Department>();
    public boolean FinishedPopulating = false;
}

Department class:

public class Department {

    @Element(name="DeptID")
    private String _DeptID ="";
    public String DeptID()
    {
        return _DeptID;
    }
    public void DeptID(String Value)
    {
        _DeptID = Value;
    }

    @Element(name="DeptDescription")
    private String _DeptDescription ="";
    public String DeptDescription()
    {
        return _DeptDescription;
    }
    public void DeptDescription(String Value)
    {
        _DeptDescription = Value;
    }
}

Example XML:

<DepartmentList>
  <Department>
    <DeptID>525</DeptID>
    <DeptDescription>Dept 1</DeptDescription>
  </Department>
  <Department>
    <DeptID>382</DeptID>
    <DeptDescription>Dept 2</DeptDescription>
  </Department>
</DepartmentList>

This has been working fine throughout the app, but I have come to a point where it needs to deserialise >300 objects in the list. This only takes approximately 5 secs, or close to a minute when debugging, but users are not happy with that performance and time wasted when debugging isn't desirable. Is there any way to speed this up? Or is there another way I should be doing this? Preferably only by changing the deserializeXMLToObject method.

is it this simple -- one type with a list and two fields or much more complex in reality? — hack_on, May 02 '13 at 09:47
It is one type but there are probably around 30 fields in around 300-400 rows. I just simplified it for example purposes. — anothershrubery, May 02 '13 at 10:52
One possible solution is to report results back without having to wait for the parser to parse the whole thing — Sherif elKhatib, May 07 '13 at 08:00
Can any one help me with this link: http://stackoverflow.com/questions/22385034/how-to-work-with-simple-xml-framework-for-maps — shaon007, Mar 16 '14 at 16:46

score 6 · Accepted Answer · edited May 23 '17 at 10:28

I am sure someone will point to a better library that's out there, but according to one detailed answer, they are all slow on Android.

So here is my quick hack (yes I know its not very maintainable and is brittle to the XML not being formed exactly as specified) and some results:

private void doTest()
{
    Thread t = new Thread()
    {
        public void run()
        {
            runOne(2000);
            runOne(300);
            runOne(20000);
        }

        private void runOne(int num)
        {
            String start = "<DepartmentList>";
            String mid1 =  "<Department>\n" +
                            "<DeptID>";
            String mid2 = "</DeptID>\n" +
                            "<DeptDescription>Dept ";
            String mid3 = "</DeptDescription></Department>";
            String fin = "</DepartmentList>";

            StringBuffer sb = new StringBuffer();
            sb.append(start);
            for (int i=0; i< num; i++)
            {
                sb.append(mid1);
                sb.append(""+i);
                sb.append(mid2);
                sb.append(""+i);
                sb.append(mid3);
            }
            sb.append(fin);

            Pattern p = Pattern.compile(
            "<Department\\s*>\\s*<DeptID\\s*>([^<]*)</DeptID>\\s*<DeptDescription\\s*>([^<]*)</DeptDescription>\\s*</Department>");

            long startN = System.currentTimeMillis();

            DepartmentList d = new DepartmentList();
            List<Department> departments = d.DepartmentList;

            Matcher m = p.matcher(sb);
            while (m.find())
            {
                Department department = new Department();
                department.DeptID(m.group(1));
                department.DeptDescription(m.group(2));
                departments.add(department);
            }

            long endN = System.currentTimeMillis();

            Log.d("Departments", "parsed: " + departments.size() + " in " + (endN-startN) + " millis");
            Log.d("Departments", "lastone: " + departments.get(departments.size() -1)._DeptID + " desc: " + departments.get(departments.size() -1)._DeptDescription);

        }
    };
    t.start();
}

public class DepartmentList {
    public List<Department> DepartmentList =new ArrayList<Department>();
    public boolean FinishedPopulating = false;
}

public class Department {

    private String _DeptID ="";
    public String DeptID()
    {
        return _DeptID;
    }
    public void DeptID(String Value)
    {
        _DeptID = Value;
    }

    private String _DeptDescription ="";
    public String DeptDescription()
    {
        return _DeptDescription;
    }
    public void DeptDescription(String Value)
    {
        _DeptDescription = Value;
    }
}

I pasted this into an Android project and called it from the onCreate() method. Here is the results:

Platform        num=300    num=2000     num=20000 
=================================================
Nexus 7         5          38           355
Galaxy Y        29         430          1173
HTC Desire HD   19         189          539
Galaxy Nexus    14         75           379

All times are in milliseconds.

Eventually got around to trying this method. While I agree it isn't the most efficient of methods, I only have 1 datatable which I need to deserialize in this way and it is providing the quickest solution. Down from 6.25s to <3s. that will have to do for now. Cheers. — anothershrubery, May 08 '13 at 09:48

score 3 · Answer 2 · edited May 23 '17 at 11:59

For my research this is the best way to optimize:

"Simple will dynamically build your object graph, this means that it will need to load classes that have not already been loaded, and build a schema for each class based on its annotations using reflection. So first use will always be by far the most expensive. Repeated use of the same persister instance will be many times faster. So try to avoid multiple persister instances, just use one if possible."

So refactoring your code to use the same Persister should improve you performance.

This and other tips I got from this question. In that case, this refactoring improved the performance, as stated by the author (from 15s to 3-5s).

Hope it helps

Using the same persister did improve performance, but only slightly. Went from 6.25s to 5.75s. 0.5s difference won't make much of a difference to users who will still complain. — anothershrubery, May 08 '13 at 10:12

score 2 · Answer 3 · answered Apr 10 '13 at 13:51

You can eliminate the intermediate (de)serialization steps by serializing directly to XML and deserializing directly from XML, using e.g. JAXB or XStream.

You may also be able to speed things up via multithreading. I'll assume that all of the XML strings you want to deserialize are in a ConcurrentLinkedQueue; alternatively, you can synchronize access to whatever non-threadsafe collection you're using. Use something like a ThreadPoolExecutor to minimize thread creation overhead.

public class DeserializeXML implements Runnable {
    private final String xml;
    private final ConcurrentLinkedQueue<Object> deserializedObjects;

    public DeserializeXML(String xml, ConcurrentLinkedQueue deserializedObjects) {
        this.xml = xml;
        this.deserializedObjects = deserializedObjects;
    }

    public void run() {
        deserializedObjects.offer(deserializeXMLToObject(xml, Object.class));
    }
}

// ***

ConcurrentLinkedQueue<String> serializedObjects;
ConcurrentLinkedQueue<Object> deserializedObjects;
ThreadPoolExecutor executor = new ThreadPoolExecutor;
while(!serializedObjects.isEmpty()) {
    executor.execute(new DeserializeXML(serializedObjects.poll(), deserializedObjects));
}

The deserialisation occurs on an ad hoc basis. When an event occurs it'll go off and deserialise 1 string, when another occurs, it'll deserialise another. They are not stored in a `ConcurrentLinkedQueue`, I don't even know where I'd begin to look into that. I looked at both JAXB and XStream and neither worked. One caused issues with duplicate package names, and the other just "didn't work" I can't remember what the exact issue was with it. I'll look over them both again, but I'd appreciate a link to a tutorial or working example for either JAXB or XStream as documentation seems to be scarce. — anothershrubery, Apr 24 '13 at 15:55
Ok, after researching more, neither of these packages appear to work with Android. I'm going to raise a bounty. — anothershrubery, May 01 '13 at 14:06

score 0 · Answer 4 · answered May 08 '13 at 07:51

Got a similar issue with a SOAP Web Service times ago. In the end I've changed the format of the XML, transforming the nodes in attributes.

example:

<node>
  <attr1>value1</attr1>
  <attr2>value2</attr2>
  <attr3>value3</attr3>
  <attr4>value4</attr4>
</node>

was transformed in

<node attr1='value1'attr2='value2' attr3='value3' attr4='value4' />

Maybe not the best solution theorically wise, but performance improvement was really good. Ofc if your XML is a bit more complex (repeteable nodes at various levels or multi level lists) things may be a bit complex.

score -1 · Answer 5 · answered May 06 '13 at 21:33

-1

Use a server proxy and transform your XML to JSON

answered May 06 '13 at 21:33

Julian Suarez

4,499
4
24
40

Android speed issue with deserialization using SimpleXML

5 Answers5