Breakdown object in Java

Question

I have huge object, I have its class of course, I'm extracting some values from it, but since it is really big I don't know in which list or where the value I'm looking for is.

Is there a way to create some kind of object breakdown routing and search every part for the value I'm expecting, and it is hidden somewhere in the object, I just can't find it in Eclipse; it's too nested.

I thought of using reflection to go through all fields of object class and search for the value inside of each field (fields inside lists (list of lists etc)). Any other ideas?

See if it helps: http://stackoverflow.com/questions/301536/what-is-the-java-equivalent-of-php-var-dump — Alberto Zaccagni, Aug 10 '10 at 11:54
Since you're asking here, I assume the "ask the inventor" answer has already been pursued or is otherwise impossible? — Carl, Aug 10 '10 at 11:55
@Carl yes that is the case answer has already been persuaded — ant, Aug 10 '10 at 11:56
I don't understand this. Do you want to find some string in the source or some value of some unknown field at runtime? If the former use the eclipse search function. — Tim Büthe, Sep 23 '10 at 13:01

chedine · Accepted Answer · 2010-09-21T05:41:17.457

I assume you just want to find a specific value and to trace its source. And all this, you want to do at debug time. I would suggest two options.

Option1 Use JSON - Serialize the object to json string and do a manual text search on the result. You would neeed json.jar (or any other parser) for this.

    try {
       System.out.println(new JSONObject(new YourHugeObject()).toString(5));
    } catch (JSONException e) {
      log(e);
    }

Which will produce something like this. (I have simulated this by creating an object with some nested fields,lists,maps)

{
 "ct": {
      "a": 1,
      "b": "sdf",
      "f": 12,
      "nested": {
           "key1": {
                "kk": "kk",
                "ssdf": 123
           },
           "onemorekey": {
                "kk": "kk",
                "ssdf": 123
           }
      }
 },
 "doubleProp": 12.2,
 "lngprop": 1232323,
 "strProp": "123",
 "stringlist": [
      "String1",
      "String2",
      "String3"
 ]
}

Option2 Convert/Serialize the object to XML. Use XStream for this,which will be the easiest of all available parsers. With just two lines of code,

    XStream stream = new XStream();
    System.out.println(stream.toXML(new YourHugeObject()));

Which will produce,

<com.kmg.jsontools.test.JSTest>
<stringlist>
 <string>String1</string>
 <string>String2</string>
 <string>String3</string>
</stringlist>
<strProp>123</strProp>
<doubleProp>12.2</doubleProp>
<lngprop>1232323</lngprop>
<ct>
 <a>1</a>
 <b>sdf</b>
 <f>12.0</f>
 <nested>
   <entry>
     <string>key1</string>
     <com.kmg.jsontools.test.Type1>
       <kk>kk</kk>
       <ssdf>123</ssdf>
     </com.kmg.jsontools.test.Type1>
   </entry>
   <entry>
     <string>onemorekey</string>
     <com.kmg.jsontools.test.Type1>
       <kk>kk</kk>
       <ssdf>123</ssdf>
     </com.kmg.jsontools.test.Type1>
   </entry>
 </nested>
</ct>
</com.kmg.jsontools.test.JSTest>

Either of the above approaches,you can either print the result to the console or to a file and inspect it manually. Alternatively you can also use reflection,in which case you would have to write a lot of code and significant amount of time in testing it as well.

score 4 · Answer 2 · answered Sep 17 '10 at 07:32

4

How about using the ToStringBuilder from Jakarta-Commons org.apache.commons.lang.builder package.

System.out.println ( ToStringBuilder.reflectionToString( YOUR_OBJECT ) );

answered Sep 17 '10 at 07:32

Faisal Feroz

12,458
4
40
51

score 2 · Answer 3 · answered Sep 17 '10 at 07:23

2

Create some static method, assuming:

Map<String, Object> DebugHelper.breakDown(Object bean)

And implement it (for example) as datamining. Usage of org.apache.pivot.beans.BeanAdapter - for example can help you to treat the bean as plain Map, or (as you have written - you need mine in depth) use recursion to group all properties into single large Map

Another useful signature:

Map<String, Object> DebugHelper.breakDown(Object bean, String lookFor)

where second parameter used to find substring of value's from from Map of first method.

Why is this helpful? Because you can using eclipse's inspector to calculate the result of this method in any time of debugging

answered Sep 17 '10 at 07:23

Dewfy

23,277
13
73
121

can you please give example of that static method you're referring to I don't really understand your point at most of the case – ant Sep 17 '10 at 07:52
@c0mrade here it is: http://ideone.com/BjygK by placing to DebugHelper.breakDown(someInstance, "3.14") - you can find properties of bean with recursive mining that (for example) returns value of Pi. You can change policy of mining as you want. And note, this uses Apache's common bean utils – Dewfy Sep 17 '10 at 12:00

score 1 · Answer 4 · answered Aug 10 '10 at 14:27

If the class is Serializable, I often use XStream to dump an object to xml.

If not, here's some code to maybe get you started on the reflection mode. It's not as recursive as you need but could be modified pretty easily.

public static void debugPrint(Object o1)
{
    if(o1 == null)
    {
        System.out.println(o1);
        return;
    }

    Class c = o1.getClass();
    do
    {
        printFields(c, o1);
        c = c.getSuperclass();
    }
    while(c != null);
}

private static void printFields(Class c, Object o1)
{
    Field[] fields = c.getDeclaredFields();
    for(Field field : fields)
    {
        printField(field, o1);
    }
}

private static void printField(Field field, Object o1)
{
    try
    {
        if(Modifier.isFinal(field.getModifiers())) return;  //Skip this guy, he's trouble!

        field.setAccessible(true);

        Object val = field.get(o1);

        System.out.println(field.getName() + ":" + toString(val));
    }
    catch(IllegalAccessException ex)
    {
        System.out.println("Could not access field" + field.getName());
        ex.printStackTrace();
    }
}

private static String toString(Object o)
{
    if(o instanceof Object[])
        return Arrays.toString((Object[])o);
    else
        return String.valueOf(o);
}

score 1 · Answer 5 · answered Sep 20 '10 at 19:33

I think you need to use reflection to get the data. Here is some code that should get you started:

static String search(Object o, final String search) {
    try {
        inspect(new HashSet<Object>(), o, new StringWriter() {
            public void write(String s) {
                System.out.println(s);
                if (s.indexOf(search) >= 0) {
                    throw new RuntimeException(s) {
                        public Throwable fillInStackTrace() { return null; } };
                }
            }
        });
        return "not found";
    } catch (Exception e) {
        return e.getMessage();
    }
}

private static void inspect(HashSet<Object> ignore, Object o, Writer w)
        throws Exception {
    if (o == null) {
        return;
    }
    for (Class<?> c = o.getClass(); c != null ; c = c.getSuperclass()) {
        if (c.isArray()) {
            int len = Array.getLength(o);
            for (int i=0; i<len; i++) {
                inspect(ignore, Array.get(o, i), w);
            }
        } else if (c.isPrimitive()) {
            w.write(o.toString());
        } else {
            for (Field f : c.getDeclaredFields()) {
                if (!Modifier.isStatic(f.getModifiers())) {
                    f.setAccessible(true);
                    if (f.getType().isPrimitive()) {
                        w.write(f.getName() + ": " + f.get(o));
                    } else {
                        if (!ignore.contains(o)) {
                            ignore.add(o);
                            w.write(f.getName());
                            inspect(ignore, f.get(o), w);
                        }
                    }
                }
            }
        }
    }
}

score 0 · Answer 6 · answered Aug 10 '10 at 11:56

Some tips -

1 ) You can use shift and click on the variable / method / class, this will bring you to it correctly.

2 ) Right click - Open Call Hierarchy will show you exactly where the variable is called.

3 ) Command and O will show you an outline of teh class so you can navigate quickly

4 ) Quick Type Hierchy will show you how / where your variable sits in the grand scheme of the class.

Hope that helps

score 0 · Answer 7 · answered Aug 10 '10 at 14:23

0

It often helps to print out the values of a large object so you can look over them carefully. In both Java and C++ I've written functions to print all the contents of an object, along with recursion to handle embedded objects. Debugging a hardcopy of the object's variables is old fashion, but for very complex situations it will lead to additional discoveries.

answered Aug 10 '10 at 14:23

Michael Shopsin

2,055
2
24
43

`It often helps to print out the values of a large object so you can look over them carefully` this is what I am after – ant Aug 10 '10 at 14:45

score 0 · Answer 8 · answered Sep 23 '10 at 10:30

Maybe a totally different approach. Try to put your object (after decomposing) in in-memory data store (see http://www.google.de/search?hl=en&q=java+inmemory+data+store+search) and than use its search functionality. After performing tests you should get feeling if it performs better in your case. If you read the object intensively, maybe it will be even better to use in-memory database.

score 0 · Answer 9 · answered Sep 23 '10 at 16:19

0

I think you have to use Java Reflection APIs. Take a look here: http://java.sun.com/developer/technicalArticles/ALT/Reflection/

answered Sep 23 '10 at 16:19

a.bertucci

12,142
2
31
32

score 0 · Answer 10 · edited May 23 '17 at 12:11

Disclaimer: the code is brute-force and very ugly. I just want to demonstrate the possibility to do what OP wants with these basic ideas:

Reflection
Recursion
Field#setAccessible
Special cases for array, Iterable, Enumeration, primitive wrapper class and String

@Thomas Mueller's answer has elements of these but my #3 and #4 are slightly more robust. And his code doesn't seem to work with my crooked test classes. Yet I probably still missed some corner cases. Please don't send this to my Java tutor.

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.*;

public class BreakDown
{
    public static void main(String[] args)
    {
        printFields(new TestClass(), "");
    }

    private static void printFields(final Object obj, final String prefix)
    {
        if( basics.contains(obj.getClass()) )
        {
            System.out.println(prefix + obj);
            return;
        }
        for( final Field f : obj.getClass().getDeclaredFields() )
        {
            try
            {
                try
                {
                    printOneField(f, obj, prefix);
                    continue;
                }
                catch( SecurityException e ) {}
                catch( IllegalAccessException e ) {}
                AccessController.doPrivileged(new PrivilegedAction<Void>()
                {
                    public Void run()
                    {
                        try
                        {
                            printOneField(f, obj, prefix);
                        }
                        catch( Exception e )
                        {
                            e.printStackTrace();
                        }
                        return null;
                    }
                });
            }
            catch( Exception e )
            {
                e.printStackTrace();
            }
        }
    }

    private static void printOneField(Field f, Object obj, String prefix) throws Exception
    {
        f.setAccessible(true);
        System.out.println(prefix + "  |" + f.getName() + ":" + (obj = f.get(obj)));
        if( obj == null )
            return;

        if( obj.getClass().isArray() )
        {
            for( int i = 0; i < Array.getLength(obj); ++i )
                printObj(Array.get(obj, i), prefix, f.getName());
        }
        else if( obj instanceof Iterable )
        {
            Iterator<?> it = ((Iterable<?>)obj).iterator();
            for( ; it.hasNext(); )
                printObj(it.next(), prefix, f.getName());
        }
        else if( obj instanceof Enumeration<?> )
        {
            Enumeration<?> e = (Enumeration<?>)obj;
            for( ; e.hasMoreElements(); )
                printObj(e.nextElement(), prefix, f.getName());
        }
        else if( !basics.contains(obj.getClass()) )
            printFields(obj, prefix + "  |" + f.getName() + ":" + obj.getClass().getCanonicalName());
    }

    private static void printObj(Object o, String prefix, String name)
    {
        printFields(o, "  " + prefix + "  |" + name + ":[(" + o.getClass().getSimpleName() + ")");
    }

    private static final Set<Class<?>> basics = new HashSet<Class<?>>();
    static
    {
        basics.add(Integer.class);
        basics.add(Long.class);
        basics.add(Double.class);
        basics.add(Float.class);
        basics.add(Boolean.class);
        basics.add(Character.class);
        basics.add(Byte.class);
        basics.add(Void.class);
        basics.add(Short.class);
        basics.add(String.class);
    }
}

class TestClass
{
    public TestClass()
    {
        if( ++count_s < 3 )
            list.add(new TestClass());
    }

    private static int count_s = 0; 
    public final String a = "a";
    final TestClass2 obj = new TestClass2();
    final TestClass2[] objArray = new TestClass2[]{new TestClass2(), new TestClass2()};
    private final int b = count_s;
    private final boolean[] c = new boolean[]{true, false};
    private final List<TestClass> list = new ArrayList<TestClass>();
}

class TestClass2
{
    private static int count_s = 0; 
    private final float d = 1.5f * (++count_s);
}

The output is:

  |count_s:3
  |a:a
  |obj:TestClass2@6e1408
  |obj:TestClass2  |count_s:9
  |obj:TestClass2  |d:1.5
  |objArray:[LTestClass2;@5483cd
    |objArray:[(TestClass2)  |count_s:9
    |objArray:[(TestClass2)  |d:3.0
    |objArray:[(TestClass2)  |count_s:9
    |objArray:[(TestClass2)  |d:4.5
  |b:0
  |c:[Z@19ee1ac
    |c:[(Boolean)true
    |c:[(Boolean)false
  |list:[TestClass@1befab0]
    |list:[(TestClass)  |count_s:3
    |list:[(TestClass)  |a:a
    |list:[(TestClass)  |obj:TestClass2@13c5982
    |list:[(TestClass)  |obj:TestClass2  |count_s:9
    |list:[(TestClass)  |obj:TestClass2  |d:6.0
    |list:[(TestClass)  |objArray:[LTestClass2;@1186fab
      |list:[(TestClass)  |objArray:[(TestClass2)  |count_s:9
      |list:[(TestClass)  |objArray:[(TestClass2)  |d:7.5
      |list:[(TestClass)  |objArray:[(TestClass2)  |count_s:9
      |list:[(TestClass)  |objArray:[(TestClass2)  |d:9.0
    |list:[(TestClass)  |b:1
    |list:[(TestClass)  |c:[Z@14b7453
      |list:[(TestClass)  |c:[(Boolean)true
      |list:[(TestClass)  |c:[(Boolean)false
    |list:[(TestClass)  |list:[TestClass@c21495]
      |list:[(TestClass)  |list:[(TestClass)  |count_s:3
      |list:[(TestClass)  |list:[(TestClass)  |a:a
      |list:[(TestClass)  |list:[(TestClass)  |obj:TestClass2@1d5550d
      |list:[(TestClass)  |list:[(TestClass)  |obj:TestClass2  |count_s:9
      |list:[(TestClass)  |list:[(TestClass)  |obj:TestClass2  |d:10.5
      |list:[(TestClass)  |list:[(TestClass)  |objArray:[LTestClass2;@c2ea3f
        |list:[(TestClass)  |list:[(TestClass)  |objArray:[(TestClass2)  |count_s:9
        |list:[(TestClass)  |list:[(TestClass)  |objArray:[(TestClass2)  |d:12.0
        |list:[(TestClass)  |list:[(TestClass)  |objArray:[(TestClass2)  |count_s:9
        |list:[(TestClass)  |list:[(TestClass)  |objArray:[(TestClass2)  |d:13.5
      |list:[(TestClass)  |list:[(TestClass)  |b:2
      |list:[(TestClass)  |list:[(TestClass)  |c:[Z@15b7986
        |list:[(TestClass)  |list:[(TestClass)  |c:[(Boolean)true
        |list:[(TestClass)  |list:[(TestClass)  |c:[(Boolean)false
      |list:[(TestClass)  |list:[(TestClass)  |list:[]

score -1 · Answer 11 · answered Sep 22 '10 at 14:47

well if the complex object is composed by java objects like Strings, Lists, Maps, and such, you can by reflection iterate over them and when you find the "object" you're looking at is a String or int (and such) call toString

This wont work if your starting object contains a "custom" object

Breakdown object in Java

11 Answers11